@pentoshi/clai 3.11.33 → 3.11.35

package/dist/agent/runner.js

@@ -923,6 +923,8 @@ export async function runAgentTurn(prompt, options = {}) {
         // Track tool calls truncated by the token limit so we can ask the model
         // to retry in smaller pieces instead of leaking broken JSON as an answer.
         let truncatedToolRetries = 0;
+        /** Consecutive model rounds whose native tool arguments were unusable. */
+        let malformedNativeArgsRounds = 0;
         let bareToolJsonRetries = 0;
         // Track a ```tool fence that is present but whose JSON could not be parsed
         // (e.g. malformed extra/missing braces that are NOT simple truncation). We
@@ -3730,7 +3732,45 @@ export async function runAgentTurn(prompt, options = {}) {
                         }
                     }
                 }
+                if (nativeToolCalls.length) {
+                    const unparseable = nativeToolCalls.filter((tc) => Boolean(tc.args?._parseError));
+                    if (unparseable.length > 0) {
+                        malformedNativeArgsRounds += 1;
+                        if (malformedNativeArgsRounds >= 2) {
+                            const names = [...new Set(unparseable.map((tc) => tc.name))].join(", ");
+                            for (const entry of deferredToolCalls) {
+                                if (!entry.shown || entry.call.name === "…")
+                                    continue;
+                                writeToolBlocked(entry.eventId, entry.call.name, "Native tool arguments were unusable again; nothing ran. Reissue as a fenced tool block.", chalk.yellow("  ⚠ native tool arguments were unusable again — nothing ran\n"));
+                            }
+                            markTextOnlyModel(provider, model);
+                            writeNotice("warn", "native tool arguments keep arriving unusable — switching this model to the text tool protocol", chalk.yellow("  ⚠ native tool arguments keep arriving unusable — switching this model to the text tool protocol\n"));
+                            commitAssistantRetry(assistantText.visible);
+                            messages.push(recoveryUserMessage(`Your native ${names || "tool"} call arguments were not usable, so nothing ran. ` +
+                                "Do not repeat that call. Emit exactly one complete fenced ```tool block with valid JSON arguments now."));
+                            nativeToolCalls = [];
+                            call = undefined;
+                            deferredToolCalls.length = 0;
+                            continue;
+                        }
+                    }
+                    else {
+                        malformedNativeArgsRounds = 0;
+                    }
+                }
                 if (!canonicalAssistantVisible.trim() && !call) {
+                    const incompleteNativeStream = nativeToolCalls.length === 0 &&
+                        deferredToolCalls.some((entry) => entry.shown && entry.call.name !== "…");
+                    if (incompleteNativeStream) {
+                        const reason = "The provider began this native tool call but never completed it. Nothing ran; reissue a complete call.";
+                        for (const deferred of deferredToolCalls) {
+                            if (!deferred.shown || deferred.call.name === "…")
+                                continue;
+                            writeToolBlocked(deferred.eventId, deferred.call.name, reason, chalk.yellow(`  ⚠ ${reason}\n`));
+                        }
+                        markTextOnlyModel(provider, model);
+                        writeNotice("warn", "provider abandoned a native tool call — switching this model to the text tool protocol", chalk.yellow("  ⚠ provider abandoned a native tool call — switching this model to the text tool protocol\n"));
+                    }
                     emptyVisibleRetries += 1;
                     if (emptyVisibleRetries <= 3) {
                         if (assistantText.hasThinking) {
@@ -3743,15 +3783,17 @@ export async function runAgentTurn(prompt, options = {}) {
                             retryWithoutThinking = true;
                         commitAssistantRetry(assistantText.visible);
                         // Keep nudges SHORT — cheap models lose the key instruction in long text.
-                        const buildNudge = isPlanMode && !activePlan
-                            ? toolsAttached
-                                ? "No visible output. In plan mode: gather context or call plan.create when ready (do not only describe the plan)."
-                                : "No visible output. In plan mode: emit a ```tool block for research/recon or plan.create. " +
-                                    "Do NOT hide tool calls in <think> tags — put them in the visible response."
-                            : toolsAttached
-                                ? "No visible output. " + toolNudge(true)
-                                : "No visible output. Emit a ```tool block or give your final answer. " +
-                                    "Do NOT hide tool calls in <think> tags — put them in the visible response.";
+                        const buildNudge = incompleteNativeStream
+                            ? "Your native tool call was incomplete, so nothing ran. Use exactly one complete fenced ```tool block now; do not repeat the incomplete native call."
+                            : isPlanMode && !activePlan
+                                ? toolsAttached
+                                    ? "No visible output. In plan mode: gather context or call plan.create when ready (do not only describe the plan)."
+                                    : "No visible output. In plan mode: emit a ```tool block for research/recon or plan.create. " +
+                                        "Do NOT hide tool calls in <think> tags — put them in the visible response."
+                                : toolsAttached
+                                    ? "No visible output. " + toolNudge(true)
+                                    : "No visible output. Emit a ```tool block or give your final answer. " +
+                                        "Do NOT hide tool calls in <think> tags — put them in the visible response.";
                         messages.push(recoveryUserMessage(buildNudge));
                         continue;
                     }