Add shared tool loop stop policy

src/ai/tool-loop-control.ts

@@ -0,0 +1,38 @@
+import type {ToolCallData} from "./unified-ai-runner.shared.js";
+
+export type ToolLoopStopReason = "no_tool_calls" | "max_rounds_reached";
+
+export type ToolLoopContinuation = {
+    continue: boolean;
+    reason?: ToolLoopStopReason;
+    remainingRounds: number;
+};
+
+export function decideToolLoopContinuation(params: {
+    round: number;
+    maxRounds: number;
+    toolCalls: readonly ToolCallData[];
+}): ToolLoopContinuation {
+    const remainingRounds = Math.max(params.maxRounds - params.round - 1, 0);
+
+    if (!params.toolCalls.length) {
+        return {
+            continue: false,
+            reason: "no_tool_calls",
+            remainingRounds,
+        };
+    }
+
+    if (remainingRounds === 0) {
+        return {
+            continue: false,
+            reason: "max_rounds_reached",
+            remainingRounds,
+        };
+    }
+
+    return {
+        continue: true,
+        remainingRounds,
+    };
+}

src/ai/unified-ai-runner.mistral.ts

@@ -18,6 +18,7 @@ import {
     ToolExecutionMemory
 } from "./unified-ai-runner.shared";
 import {executeToolBatchWithAdapter} from "./tool-batch-runner";
+import {decideToolLoopContinuation} from "./tool-loop-control";
 import {Message} from "typescript-telegram-bot-api";
 
 export async function runMistral(
@@ -111,6 +112,17 @@ export async function runMistral(
                     adapter,
                     appendTargets: [messages, requestMessages],
                 });
+                const continuation = decideToolLoopContinuation({
+                    round,
+                    maxRounds: MAX_TOOL_ROUNDS,
+                    toolCalls: calls,
+                });
+                if (!continuation.continue && continuation.reason === "max_rounds_reached") {
+                    aiLog("warn", "mistral.tool_loop.max_rounds_reached", {
+                        round,
+                        maxRounds: MAX_TOOL_ROUNDS,
+                    });
+                }
                 continue;
             }
 
@@ -168,6 +180,17 @@ export async function runMistral(
                 adapter,
                 appendTargets: [messages, requestMessages],
             });
+            const continuation = decideToolLoopContinuation({
+                round,
+                maxRounds: MAX_TOOL_ROUNDS,
+                toolCalls: calls,
+            });
+            if (!continuation.continue && continuation.reason === "max_rounds_reached") {
+                aiLog("warn", "mistral.tool_loop.max_rounds_reached", {
+                    round,
+                    maxRounds: MAX_TOOL_ROUNDS,
+                });
+            }
         }
     } finally {
         await adapter.finalize().catch(() => undefined);

src/ai/unified-ai-runner.ollama.ts

@@ -33,6 +33,7 @@ import {
     ToolExecutionMemory
 } from "./unified-ai-runner.shared";
 import {executeToolBatchWithAdapter} from "./tool-batch-runner";
+import {decideToolLoopContinuation} from "./tool-loop-control";
 import {getToolPrompts} from "./tools/registry";
 import {GetNoteFileResult, GetNoteFileResultSchema} from "./tools/notes";
 import {getModelCapabilities} from "./provider-model-runtime";
@@ -296,6 +297,18 @@ export async function runOllama(
                     appendTargets: [messages],
                 });
 
+                const continuation = decideToolLoopContinuation({
+                    round,
+                    maxRounds: MAX_TOOL_ROUNDS,
+                    toolCalls: calls,
+                });
+                if (!continuation.continue && continuation.reason === "max_rounds_reached") {
+                    aiLog("warn", "ollama.tool_loop.max_rounds_reached", {
+                        round,
+                        maxRounds: MAX_TOOL_ROUNDS,
+                    });
+                }
+
                 continue;
             }
 
@@ -414,6 +427,18 @@ export async function runOllama(
                 appendTargets: [messages],
             });
 
+            const continuation = decideToolLoopContinuation({
+                round,
+                maxRounds: MAX_TOOL_ROUNDS,
+                toolCalls: calls,
+            });
+            if (!continuation.continue && continuation.reason === "max_rounds_reached") {
+                aiLog("warn", "ollama.tool_loop.max_rounds_reached", {
+                    round,
+                    maxRounds: MAX_TOOL_ROUNDS,
+                });
+            }
+
             let successGetNoteFileResult: GetNoteFileResult | undefined = undefined;
 
             for (const toolResult of toolResults) {

src/ai/unified-ai-runner.openai.ts

@@ -33,6 +33,7 @@ import {
     allToolSchemaNames
 } from "./unified-ai-runner.shared";
 import {executeToolBatchWithAdapter} from "./tool-batch-runner";
+import {decideToolLoopContinuation} from "./tool-loop-control";
 import {bot} from "../index";
 import fs from "node:fs";
 import path from "node:path";
@@ -204,6 +205,18 @@ export async function runOpenAi(
                     }
                 }
 
+                const continuation = decideToolLoopContinuation({
+                    round,
+                    maxRounds: MAX_TOOL_ROUNDS,
+                    toolCalls: calls,
+                });
+                if (!continuation.continue && continuation.reason === "max_rounds_reached") {
+                    aiLog("warn", "openai.tool_loop.max_rounds_reached", {
+                        round,
+                        maxRounds: MAX_TOOL_ROUNDS,
+                    });
+                }
+
                 responseInput = [...responseInput, ...(response.output ?? []), ...toolOutputs];
                 continue;
             }
@@ -400,6 +413,18 @@ export async function runOpenAi(
                 }
             }
 
+            const continuation = decideToolLoopContinuation({
+                round,
+                maxRounds: MAX_TOOL_ROUNDS,
+                toolCalls: calls,
+            });
+            if (!continuation.continue && continuation.reason === "max_rounds_reached") {
+                aiLog("warn", "openai.tool_loop.max_rounds_reached", {
+                    round,
+                    maxRounds: MAX_TOOL_ROUNDS,
+                });
+            }
+
             responseInput = [...responseInput, ...(completedResponse.output ?? []), ...toolOutputs];
         }
     } finally {