@pentoshi/clai 3.11.3 → 3.11.5

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";
@@ -38,7 +38,7 @@ function safeEngagementActionsForToolCall(call) {
 }
 import { availableToolNames, normalizeToolCall, runToolCall, BATCH_SAFE_TOOLS, } from "../tools/registry.js";
 import { getToolDefinitions, getCompactToolDefinitions, RUNNER_META_TOOL_NAMES, } from "../tools/definitions.js";
-import { appendAssistantWithTools, ensureUniqueToolCallIds, appendToolResult, assertValidToolProtocol, fillMissingToolResults, repairToolProtocol, } from "./tool-history.js";
+import { appendAssistantWithTools, ensureUniqueToolCallIds, toolCallIdsInHistory, appendToolResult, assertValidToolProtocol, fillMissingToolResults, repairToolProtocol, } from "./tool-history.js";
 import { formatViewportHint, registerViewport } from "../ui/output-pane.js";
 import { compactMessagesWithSummary, shouldApplyAutoCompact, COMPACTION_MEMORY_PREFIX, PLAN_IMPLEMENT_MEMORY_PREFIX, isCompactionMemoryMessage, } from "./context-manager.js";
 import { buildContextBreakdown, contextBreakdownAuditPayload, describeDominantContextBlock, toolSchemaHash, } from "./context-breakdown.js";
@@ -410,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
@@ -442,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
@@ -456,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 = "";
@@ -529,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 } : {}),
             });
@@ -892,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.
@@ -2068,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 } : {}),
@@ -3158,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.
@@ -3314,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.
@@ -3389,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);
                         }
@@ -3608,11 +3632,14 @@ export async function runAgentTurn(prompt, options = {}) {
                                         writeNotice("info", `native tool call was truncated — salvaged ${lineCount} lines and wrote to ${salvaged.path}`, chalk.cyan(`  ℹ native tool call was truncated — salvaged ${lineCount} lines to ${salvaged.path}\n`));
                                         // Pair assistant tool_calls with synthetic results so the
                                         // next turn is not orphaned, then nudge for append.
-                                        appendAssistantWithTools(messages, assistantText.visible, nativeToolCalls, completion.reasoningBlock);
-                                        for (const tc of nativeToolCalls) {
-                                            appendToolResult(messages, tc.id, tc.id === writeTc.id
+                                        const salvageHistoryCalls = ensureUniqueToolCallIds(nativeToolCalls, toolCallIdsInHistory(messages));
+                                        const salvagedCallIndex = nativeToolCalls.indexOf(writeTc);
+                                        const salvagedCallId = salvageHistoryCalls[salvagedCallIndex]?.id ?? writeTc.id;
+                                        appendAssistantWithTools(messages, assistantText.visible, salvageHistoryCalls, completion.reasoningBlock);
+                                        for (const tc of salvageHistoryCalls) {
+                                            appendToolResult(messages, tc.id, tc.id === salvagedCallId
                                                 ? `Tool ${tc.name} result (exit=0, ok=true):\nSalvaged partial write: ${lineCount} lines to ${salvaged.path}`
-                                                : `Tool ${tc.name} result (exit=1, ok=false):\nCancelled — sibling write was truncated and salvaged.`, tc.name, tc.id === writeTc.id);
+                                                : `Tool ${tc.name} result (exit=1, ok=false):\nCancelled — sibling write was truncated and salvaged.`, tc.name, tc.id === salvagedCallId);
                                         }
                                         const priorBytes = writeResult.bytesOnDisk;
                                         const salvagedToolName = salvaged.operation === "append"
@@ -4227,7 +4254,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 // assistant toolCalls and role:tool results always share the same id.
                 // Mismatched ids make results look orphaned → repair injects placeholders
                 // → model thrash-retries tools that already succeeded in the UI.
-                const historyNativeCalls = ensureUniqueToolCallIds(bound.map((b) => b.native));
+                const historyNativeCalls = ensureUniqueToolCallIds(bound.map((b) => b.native), toolCallIdsInHistory(messages));
                 for (let i = 0; i < bound.length; i++) {
                     const fixed = historyNativeCalls[i];
                     bound[i] = {
@@ -4433,6 +4460,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;