Preserve repair settings and cumulative usage

internal/usecase/runner.go

@@ -175,18 +175,20 @@ func (r *Runner) executePreparedRun(
 ) (*domain.RunResult, error) {
 	executionTarget := prepared.EffectiveModelParams
 	executionTarget.APIKey = directAPIKey
-	genResp, err := r.llm.Generate(ctx, domain.GenerateRequest{
-		Prompt:           domain.RenderedPrompt{SessionID: prepared.SessionID, Messages: prepared.Messages},
-		Target:           executionTarget,
-		TargetPresence:   prepared.TargetPresence,
-		StructuredOutput: prepared.StructuredOutput,
-	})
+	genResp, err := r.llm.Generate(ctx, newGenerationRequest(
+		domain.RenderedPrompt{Messages: prepared.Messages},
+		prepared.SessionID,
+		executionTarget,
+		prepared.TargetPresence,
+		prepared.StructuredOutput,
+	))
 	if err != nil {
 		if errors.Is(err, llm.ErrInvalidRequest) {
 			return nil, fmt.Errorf("%w: %w", ErrInvalidRequest, err)
 		}
 		return nil, fmt.Errorf("%w: %w", ErrLLMGenerate, err)
 	}
+	usage := genResp.Usage
 
 	outputArtifact := buildOutputArtifact(genResp.Content, prepared.OutputContract.Format)
 	validationResult, err := validateArtifact(ctx, &outputArtifact, 0)
@@ -204,6 +206,7 @@ func (r *Runner) executePreparedRun(
 				ValidationErrors: validationResult.Errors,
 				SessionID:        prepared.SessionID,
 				Target:           executionTarget,
+				TargetPresence:   prepared.TargetPresence,
 				StructuredOutput: prepared.StructuredOutput,
 				Attempt:          attemptsUsed,
 				MaxAttempts:      prepared.OutputContract.RepairAttempts,
@@ -217,6 +220,7 @@ func (r *Runner) executePreparedRun(
 			}
 
 			genResp = repairResp
+			usage = addTokenUsage(usage, repairResp.Usage)
 			outputArtifact = buildOutputArtifact(genResp.Content, prepared.OutputContract.Format)
 
 			validationResult, err = validateArtifact(ctx, &outputArtifact, attemptsUsed)
@@ -245,13 +249,23 @@ func (r *Runner) executePreparedRun(
 		Endpoint:             prepared.EffectiveModelParams.Endpoint,
 		EffectiveModelParams: executionTarget,
 		InputHashes:          prepared.InputHashes,
-		Usage:                genResp.Usage,
+		Usage:                usage,
 		StartTime:            start,
 		EndTime:              end,
 		Duration:             end.Sub(start),
 	}, nil
 }
 
+func addTokenUsage(total, next domain.TokenUsage) domain.TokenUsage {
+	return domain.TokenUsage{
+		PromptTokens:     total.PromptTokens + next.PromptTokens,
+		CompletionTokens: total.CompletionTokens + next.CompletionTokens,
+		TotalTokens:      total.TotalTokens + next.TotalTokens,
+		CachedTokens:     total.CachedTokens + next.CachedTokens,
+		CacheWriteTokens: total.CacheWriteTokens + next.CacheWriteTokens,
+	}
+}
+
 func (r *Runner) Prepare(ctx context.Context, req domain.RunRequest) (*domain.PreparedRun, error) {
 	state, err := r.resolvePreparation(ctx, req, time.Now().UTC())
 	if err != nil {