@pentoshi/clai 3.11.2 → 3.11.4

package/dist/agent/runner.js

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { completeWithProvider, streamWithProvider } from "../llm/router.js";
 import { streamAlreadyEmitted } from "../llm/stream-progress.js";
 import { classifyStreamFailure, planStreamRecovery, recordRecoveryAttempt, createStreamRecoveryState, resetStreamRecoveryState, } from "./stream-recovery.js";
-import { resolveToolDialect } from "../llm/capabilities.js";
+import { modelSupportsVision, resolveToolDialect } from "../llm/capabilities.js";
 import { syntheticToolCallId, isTextOnlyModel, markTextOnlyModel, fromWireName, } from "../llm/tool-protocol.js";
 import { sanitizeAssistantText } from "../ui/ansi-box.js";
 import { randomUUID } from "node:crypto";
@@ -168,6 +168,37 @@ export async function runAgentTurn(prompt, options = {}) {
     // the normal tool path already surfaced, which would render it twice. Reset
     // at the top of every loop iteration.
     let visibleCommitted = false;
+    let interruptedVisible = "";
+    const trimExactContinuationOverlap = (previous, current, minLength = 32) => {
+        if (previous.length > 0 && current.startsWith(previous)) {
+            return current.slice(previous.length);
+        }
+        const maxLength = Math.min(previous.length, current.length);
+        if (maxLength < minLength)
+            return current;
+        const pattern = current.slice(0, maxLength);
+        const fallback = new Uint32Array(maxLength);
+        for (let index = 1, matched = 0; index < maxLength; index += 1) {
+            while (matched > 0 && pattern[index] !== pattern[matched]) {
+                matched = fallback[matched - 1];
+            }
+            if (pattern[index] === pattern[matched])
+                matched += 1;
+            fallback[index] = matched;
+        }
+        let matched = 0;
+        for (let index = previous.length - maxLength; index < previous.length; index += 1) {
+            while (matched > 0 && previous[index] !== pattern[matched]) {
+                matched = fallback[matched - 1];
+            }
+            if (previous[index] === pattern[matched])
+                matched += 1;
+            if (matched === maxLength && index < previous.length - 1) {
+                matched = fallback[matched - 1];
+            }
+        }
+        return matched >= minLength ? current.slice(matched) : current;
+    };
     const noopSpinner = {
         setLabel: () => { },
         bumpReasoning: () => { },
@@ -331,7 +362,7 @@ export async function runAgentTurn(prompt, options = {}) {
             jobManager.releaseResponderNotificationClaim(notificationId);
         }
     };
-    const finishTurn = (answer, steps, status = "succeeded", remainingCriteria = [], reason) => {
+    const finishTurn = (answer, steps, status = "succeeded", remainingCriteria = [], reason, displayAnswer) => {
         releaseUnreadResponderClaims();
         const outcome = createTurnOutcome(normalizeTurnOutcomeInput({
             status,
@@ -340,13 +371,22 @@ export async function runAgentTurn(prompt, options = {}) {
             remainingCriteria,
             reason,
         }));
-        const rendered = renderTurnOutcome(outcome, {
+        const renderOptions = {
             diagnostics: !suppressOutcomeDiagnostics,
-        });
-        writeAssistantMessage(rendered);
+        };
+        const rendered = renderTurnOutcome(outcome, renderOptions);
+        const displayRendered = displayAnswer === undefined
+            ? rendered
+            : renderTurnOutcome({ ...outcome, answer: displayAnswer }, renderOptions);
+        if (displayRendered.trim()) {
+            writeAssistantMessage(displayRendered);
+        }
+        else if (!writesDirectly) {
+            emit({ type: "assistant-message", text: "" });
+        }
         if (options.onMessages) {
             try {
-                options.onMessages(buildTurnHistory(liveMessages, rendered));
+                options.onMessages(buildTurnHistory(liveMessages, displayRendered));
             }
             catch {
                 // Persisting history must never break the turn.
@@ -370,10 +410,20 @@ export async function runAgentTurn(prompt, options = {}) {
         const projectContext = await loadProjectContext();
         const hasAttachedImages = Boolean(options.images?.length);
         const imageOcrEnabled = shouldEnableImageOcr(prompt, hasAttachedImages, options.visionProven !== false);
-        // A vision-capable request already carries the actual image bytes. Hiding
-        // image.ocr from the model prevents it from replacing visual inspection
-        // with a lossy Tesseract pass (which produced fabricated screenshot text).
-        const toolNames = availableToolNames().filter((name) => name !== "image.ocr" || imageOcrEnabled);
+        const initialProvider = options.provider ?? config.defaultProvider;
+        const initialModel = options.model ?? config.defaultModel;
+        // image.view is different from optimistic user-attachment handling: once
+        // the tool succeeds, the model must actually receive and inspect its bytes.
+        // Offer it only with affirmative capability evidence for the active route.
+        const routeToolNames = (routeProvider, routeModel) => availableToolNames().filter((name) => {
+            if (name === "image.ocr")
+                return imageOcrEnabled;
+            if (name === "image.view") {
+                return modelSupportsVision(routeProvider, routeModel);
+            }
+            return true;
+        });
+        const toolNames = routeToolNames(initialProvider, initialModel);
         // Build / scaffold / continuation turns must NEVER be diverted into a
         // web.search for "current info". The /implement directive ("Execute it
         // now…") and prompts like "create a react app" contain words such as
@@ -402,9 +452,9 @@ export async function runAgentTurn(prompt, options = {}) {
             !idleOrSocialPrompt &&
             toolNames.includes("web.search") &&
             requiresFreshWebSearch(prompt);
-        let provider = options.provider ?? config.defaultProvider;
+        let provider = initialProvider;
         await ensureProviderConfigured(provider);
-        let model = options.model ?? config.defaultModel;
+        let model = initialModel;
         // Some Groq free-tier models have a per-request/per-minute input budget
         // below the normal agent prompt alone. Select a purpose-built compact
         // instruction set before the request is made, rather than treating the
@@ -416,13 +466,16 @@ export async function runAgentTurn(prompt, options = {}) {
             return { dialect, native: dialect !== "none" };
         };
         let { dialect: toolDialect, native: nativeToolsActive } = resolveNativeTools(provider, model);
-        const selectToolDefs = (native, compact) => {
+        const selectToolDefs = (native, compact, routeProvider = provider, routeModel = model) => {
             if (!native)
                 return undefined;
             const base = compact
                 ? getCompactToolDefinitions()
                 : getToolDefinitions();
-            const allow = new Set([...toolNames, ...RUNNER_META_TOOL_NAMES]);
+            const allow = new Set([
+                ...routeToolNames(routeProvider, routeModel),
+                ...RUNNER_META_TOOL_NAMES,
+            ]);
             return base.filter((d) => allow.has(d.name));
         };
         let lastAnswer = "";
@@ -489,11 +542,13 @@ export async function runAgentTurn(prompt, options = {}) {
         // constitution (and, on Anthropic, the native tool schemas before it).
         const buildStableSystemContent = (native) => {
             const reliability = getReliabilityPolicy();
+            const visionAvailable = modelSupportsVision(provider, model);
             return (useCompactSystemPrompt
                 ? renderCompactAgentSystemPrompt
-                : renderAgentSystemPrompt)(toolNames.join(", "), {
+                : renderAgentSystemPrompt)(routeToolNames(provider, model).join(", "), {
                 nativeTools: native,
                 stableEnvironment: true,
+                imageView: visionAvailable,
                 // E6: slim native constitution when API tool schemas are attached.
                 ...(native ? { slimNative: reliability.slimNativePrompt } : {}),
             });
@@ -852,6 +907,7 @@ export async function runAgentTurn(prompt, options = {}) {
         // reset on any successful stream so each failure episode gets a fresh
         // budget and we only give up in the worst case.
         let allowModelFallback = false;
+        let preferModelFallback = false;
         const recoveryState = createStreamRecoveryState();
         // 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.
@@ -2028,6 +2084,10 @@ export async function runAgentTurn(prompt, options = {}) {
                     },
                     confirmed: true,
                     userPrompt: prompt,
+                    // image.view needs the active route to check vision support and size
+                    // images to the provider's per-image budget.
+                    llmProvider: provider,
+                    llmModel: model,
                     sessionId: session.sessionId,
                     ...(delegation?.taskId ? { taskId: delegation.taskId } : {}),
                     ...(delegation ? { delegationId: delegation.id } : {}),
@@ -3006,6 +3066,7 @@ export async function runAgentTurn(prompt, options = {}) {
             options.signal?.throwIfAborted();
             let call;
             let assistantText;
+            let canonicalAssistantVisible = "";
             let recoveredFromBareJson = false;
             if (pendingCalls.length > 0) {
                 call = pendingCalls.shift();
@@ -3117,6 +3178,7 @@ export async function runAgentTurn(prompt, options = {}) {
                             provider,
                             model,
                             allowModelFallback,
+                            preferModelFallback,
                             messages,
                             // Sampling is provider/model policy (llm/sampling.ts).
                             // Sending a fixed 0.2 here overrode it for every model.
@@ -3273,6 +3335,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         // starts fresh (and we never give up while making progress).
                         resetStreamRecoveryState(recoveryState);
                         allowModelFallback = false;
+                        preferModelFallback = false;
                     }
                     catch (streamError) {
                         // User cancelled (double-Esc) — never try to recover, just stop.
@@ -3311,15 +3374,16 @@ export async function runAgentTurn(prompt, options = {}) {
                             deltaParser?.finish();
                             const partial = rememberThinkingFromText(accumulatedText);
                             const hasShownToolCall = deferredToolCalls.some((entry) => entry.shown);
-                            const partialVisible = textBeforeToolCall(stripThinking(collapseRepeatedText(accumulatedText)).visible).trim();
+                            const rawPartialVisible = textBeforeToolCall(stripThinking(collapseRepeatedText(accumulatedText)).visible);
+                            const normalizedPartialVisible = trimExactContinuationOverlap(interruptedVisible, rawPartialVisible);
+                            const partialVisible = normalizedPartialVisible.trim();
                             if (partialVisible) {
-                                if (!hasShownToolCall) {
-                                    writeAssistantMessage(partialVisible);
-                                }
+                                writeAssistantMessage(partialVisible);
                                 pushAssistantHistory(partialVisible);
+                                interruptedVisible += normalizedPartialVisible;
                             }
-                            else if (!writesDirectly && !hasShownToolCall) {
-                                emit({ type: "assistant-message", text: partial.visible });
+                            else if (!writesDirectly) {
+                                emit({ type: "assistant-message", text: "" });
                             }
                             if (partial.hasThinking && !hasShownToolCall) {
                                 writeThinkingBlock(partial.thinkContent);
@@ -3347,6 +3411,8 @@ export async function runAgentTurn(prompt, options = {}) {
                             retryWithoutThinking = true;
                         if (plan.allowModelFallback)
                             allowModelFallback = true;
+                        if (plan.preferModelFallback)
+                            preferModelFallback = true;
                         if (plan.forceCompact) {
                             await maybeAutoCompact(`stream-recovery:${failureKind}`, true);
                         }
@@ -3412,11 +3478,16 @@ export async function runAgentTurn(prompt, options = {}) {
                 const usedNativeProtocol = Boolean(completion.toolCalls?.length) ||
                     (toolsAttached && !isTextOnlyModel(provider, model));
                 const assistantTextResult = rememberThinkingFromText(completion.text);
-                assistantText = assistantTextResult;
+                const continuedVisible = trimExactContinuationOverlap(interruptedVisible, assistantTextResult.visible);
+                canonicalAssistantVisible = interruptedVisible + continuedVisible;
+                assistantText = {
+                    ...assistantTextResult,
+                    visible: continuedVisible,
+                };
                 const commitAssistantRetry = (historyText) => {
                     const hasShownToolCall = deferredToolCalls.some((entry) => entry.shown);
                     if (!hasShownToolCall) {
-                        const displayText = textBeforeToolCall(stripThinking(collapseRepeatedText(completion.text)).visible).trim();
+                        const displayText = textBeforeToolCall(collapseRepeatedText(assistantText.visible)).trim();
                         if (displayText) {
                             writeAssistantMessage(displayText);
                         }
@@ -3431,6 +3502,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         }
                     }
                     pushAssistantHistory(historyText);
+                    interruptedVisible = "";
                 };
                 // Only emit a thinking-block event when the classic renderer is
                 // active (writesDirectly / no deltaParser).  In TUI v2 the
@@ -3600,7 +3672,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         }
                     }
                 }
-                if (!assistantText.visible.trim() && !call) {
+                if (!canonicalAssistantVisible.trim() && !call) {
                     emptyVisibleRetries += 1;
                     if (emptyVisibleRetries <= 3) {
                         if (assistantText.hasThinking) {
@@ -3611,7 +3683,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         }
                         if (assistantText.hasThinking)
                             retryWithoutThinking = true;
-                        commitAssistantRetry(stripThinking(collapseRepeatedText(completion.text)).visible);
+                        commitAssistantRetry(assistantText.visible);
                         // Keep nudges SHORT — cheap models lose the key instruction in long text.
                         const buildNudge = freshWebSearchRequired && !sawFreshWebSearch
                             ? toolsAttached
@@ -3817,7 +3889,8 @@ export async function runAgentTurn(prompt, options = {}) {
                         }
                         // Exhausted retries — fall through to the normal path.
                     }
-                    const cleaned = collapseRepeatedText(stripSentinelTokens(assistantText.visible));
+                    const displayCleaned = collapseRepeatedText(stripSentinelTokens(assistantText.visible));
+                    const cleaned = collapseRepeatedText(stripSentinelTokens(canonicalAssistantVisible));
                     const narratedAction = looksLikeActionNarration(cleaned);
                     const narratedWebAction = looksLikeWebActionNarration(cleaned);
                     const reconciledPlanAtCompletion = await reconcileOpenTaskBeforeFinalizing();
@@ -4094,7 +4167,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         ? "One or more required plan tasks failed."
                         : outcomeStatus === "partial"
                             ? "Required outcome criteria remain unsupported by current evidence."
-                            : undefined);
+                            : undefined, displayCleaned);
                 }
                 // A valid primary tool call exists for this fresh model turn. Show any
                 // prose / thinking that preceded it, record the assistant message ONCE.
@@ -4103,10 +4176,13 @@ export async function runAgentTurn(prompt, options = {}) {
                     : nativeToolCalls.length
                         ? assistantText.visible.trim()
                         : textBeforeToolCall(assistantText.visible);
-                if (beforeTool &&
-                    !deferredToolCalls.some((entry) => entry.shown)) {
+                if (beforeTool) {
                     writeAssistantMessage(beforeTool);
                 }
+                else if (deltaParser) {
+                    emit({ type: "assistant-message", text: "" });
+                }
+                interruptedVisible = "";
                 let bound = [];
                 if (nativeToolCalls.length) {
                     bound = nativeToolCalls.map((tc, index) => {
@@ -4381,6 +4457,23 @@ export async function runAgentTurn(prompt, options = {}) {
                             content: toolContent,
                         });
                     }
+                    // image.view hands back real image bytes. Tool results are text-only
+                    // on every provider wire, and images are only serialized on user
+                    // turns, so the bytes ride a deferred internal user message that
+                    // lands after the assistant→tool group is closed — inserting it here
+                    // would orphan the remaining tool results.
+                    if (res.result.images?.length) {
+                        deferredPostToolMessages.push({
+                            role: "user",
+                            internal: true,
+                            content: `[${res.call.name}] The ${res.result.images.length === 1 ? "image" : `${res.result.images.length} images`} you asked to look at ` +
+                                `${res.result.images.length === 1 ? "is" : "are"} attached to this message` +
+                                `${res.result.images.length === 1 ? "" : ", in the order you requested them"}: ` +
+                                `${res.result.images.map((image) => image.path ?? "(unnamed)").join(", ")}. ` +
+                                "Judge them from the pixels and continue the task.",
+                            images: res.result.images,
+                        });
+                    }
                     // Reset retry counters — they track consecutive failures, not cumulative.
                     truncatedToolRetries = 0;
                     malformedFenceRetries = 0;