* tools: raise orchestration limit to 20 turns and force finalization on limit;

Author: borro

internal/app/tools/run.go

@@ -18,11 +18,12 @@ import (
 )
 
 const (
-	toolsMaxTurns                 = 10
+	toolsMaxTurns                 = 20
 	toolsMaxConsecutiveNoProgress = 2
 	toolsMaxConsecutiveDuplicates = 2
 	emptyFinalAnswerRetryLimit    = 1
 	stalledToolRetryLimit         = 1
+	maxTurnFinalizationRetries    = 1
 )
 
 type Options struct{}
@@ -214,6 +215,7 @@ func Run(ctx context.Context, client llm.ChatRequester, filePath, prompt string,
 	var toolChoiceToSend interface{} = "auto"
 	emptyFinalAnswerRetries := 0
 	stalledToolRetries := 0
+	haveToolResults := false
 
 	logStop := func(reason string, turns int) {
 		slog.Debug("tools processing finished",
@@ -308,6 +310,7 @@ func Run(ctx context.Context, client llm.ChatRequester, filePath, prompt string,
 					ToolCallID: choice.Message.ToolCalls[i].ID,
 				})
 			}
+			haveToolResults = haveToolResults || len(results) > 0
 			if err != nil {
 				var orchErr orchestrationError
 				if errorsAsOrchestration(err, &orchErr) && shouldRetryWithoutTools(orchErr) && stalledToolRetries < stalledToolRetryLimit {
@@ -357,6 +360,18 @@ func Run(ctx context.Context, client llm.ChatRequester, filePath, prompt string,
 		return choice.Message.Content, nil
 	}
 
+	if haveToolResults {
+		finalMeter.Start(localize.T("progress.tools.text_answer", localize.Data{"Turn": toolsMaxTurns + 1}))
+		result, err := requestFinalAnswerWithoutTools(ctx, client, messages, toolsConfig.tools, maxTurnFinalizationRetries)
+		if err == nil {
+			finalMeter.Done(localize.T("progress.tools.final_done", localize.Data{"Turn": toolsMaxTurns + 1}))
+			logStop("forced_final_answer", toolsMaxTurns)
+			return result, nil
+		}
+		logStop("orchestration_limit_finalization_failed", toolsMaxTurns)
+		return "", err
+	}
+
 	logStop("orchestration_limit", toolsMaxTurns)
 	return "", orchestrationError{
 		Code:    "orchestration_limit",
@@ -735,3 +750,38 @@ func shouldRetryWithoutTools(err orchestrationError) bool {
 		return false
 	}
 }
+
+func requestFinalAnswerWithoutTools(ctx context.Context, client llm.ChatRequester, messages []openai.ChatCompletionMessage, tools []openai.Tool, retries int) (string, error) {
+	attemptMessages := append([]openai.ChatCompletionMessage{}, messages...)
+
+	for attempt := 0; attempt <= retries; attempt++ {
+		attemptMessages = append(attemptMessages, openai.ChatCompletionMessage{
+			Role:    "user",
+			Content: localize.T("tools.prompt.stop_calls"),
+		})
+
+		resp, _, err := client.SendRequestWithMetrics(ctx, openai.ChatCompletionRequest{
+			Messages:   attemptMessages,
+			Tools:      tools,
+			ToolChoice: "none",
+		})
+		if err != nil {
+			return "", fmt.Errorf("failed to send forced finalization request: %w", err)
+		}
+		if len(resp.Choices) == 0 {
+			return "", fmt.Errorf("forced finalization returned no choices")
+		}
+
+		choice := resp.Choices[0]
+		attemptMessages = append(attemptMessages, choice.Message)
+		if strings.TrimSpace(choice.Message.Content) != "" {
+			return choice.Message.Content, nil
+		}
+	}
+
+	return "", orchestrationError{
+		Code:    "orchestration_limit",
+		Message: fmt.Sprintf("tools orchestration exceeded %d turns and forced finalization returned no answer", toolsMaxTurns),
+		Details: map[string]any{"max_turns": toolsMaxTurns},
+	}
+}

internal/app/tools/run_test.go

@@ -199,16 +199,52 @@ func TestRunTools_MultiStepToolLoop(t *testing.T) {
 	}
 }
 
-func TestRunTools_StopsAfterMaxTurns(t *testing.T) {
+func TestRunTools_FinalizesWithoutToolsAfterMaxTurns(t *testing.T) {
 	responses := make([]*openai.ChatCompletionResponse, 0, toolsMaxTurns)
 	for i := 0; i < toolsMaxTurns; i++ {
 		responses = append(responses, chatResponse(message("assistant", "", []openai.ToolCall{
 			toolCall("loop-call", "search_file", fmt.Sprintf(`{"query":"x","limit":1,"offset":%d}`, i)),
 		})))
 	}
+	responses = append(responses, chatResponse(message("assistant", "Итог после принудительной финализации", nil)))
 
 	client := &scriptedRequester{responses: responses}
-	filePath := writeTempFile(t, "x1\nx2\nx3\nx4\nx5\nx6\nx7\nx8\nx9\nx10\n")
+	filePath := writeTempFile(t, strings.Join(buildNumberedLines("x", toolsMaxTurns+5), "\n")+"\n")
+
+	result, err := Run(context.Background(), client, filePath, "loop?", nil)
+	if err != nil {
+		t.Fatalf("RunTools() error = %v", err)
+	}
+	if result != "Итог после принудительной финализации" {
+		t.Fatalf("RunTools() result = %q, want forced finalization answer", result)
+	}
+	if len(client.requests) != toolsMaxTurns+1 {
+		t.Fatalf("requests = %d, want %d", len(client.requests), toolsMaxTurns+1)
+	}
+	lastReq := client.requests[len(client.requests)-1]
+	if lastReq.ToolChoice != "none" {
+		t.Fatalf("ToolChoice = %#v, want none", lastReq.ToolChoice)
+	}
+	lastMsg := lastReq.Messages[len(lastReq.Messages)-1]
+	if !strings.Contains(lastMsg.Content, "Останови вызовы инструментов") {
+		t.Fatalf("finalization message = %q, want stop-tools instruction", lastMsg.Content)
+	}
+}
+
+func TestRunTools_ReturnsOrchestrationLimitWhenForcedFinalizationStillEmpty(t *testing.T) {
+	responses := make([]*openai.ChatCompletionResponse, 0, toolsMaxTurns+2)
+	for i := 0; i < toolsMaxTurns; i++ {
+		responses = append(responses, chatResponse(message("assistant", "", []openai.ToolCall{
+			toolCall("loop-call", "search_file", fmt.Sprintf(`{"query":"x","limit":1,"offset":%d}`, i)),
+		})))
+	}
+	responses = append(responses,
+		chatResponse(message("assistant", "", nil)),
+		chatResponse(message("assistant", "", nil)),
+	)
+
+	client := &scriptedRequester{responses: responses}
+	filePath := writeTempFile(t, strings.Join(buildNumberedLines("x", toolsMaxTurns+5), "\n")+"\n")
 
 	_, err := Run(context.Background(), client, filePath, "loop?", nil)
 	var orchErr orchestrationError
@@ -525,6 +561,14 @@ func toolCall(id string, name string, arguments string) openai.ToolCall {
 	}
 }
 
+func buildNumberedLines(prefix string, count int) []string {
+	lines := make([]string, 0, count)
+	for i := 1; i <= count; i++ {
+		lines = append(lines, fmt.Sprintf("%s%d", prefix, i))
+	}
+	return lines
+}
+
 func writeTempFile(t *testing.T, content string) string {
 	t.Helper()