@pentoshi/clai 3.12.0 → 3.13.0

package/dist/agent/runner.js

@@ -1,6 +1,7 @@
 import chalk from "chalk";
 import { join } from "node:path";
-import { completeWithProvider, streamWithProvider } from "../llm/router.js";
+import { streamWithProvider } from "../llm/router.js";
+import { modelContextWindow } from "../llm/token-usage.js";
 import { streamAlreadyEmitted } from "../llm/stream-progress.js";
 import { classifyStreamFailure, planStreamRecovery, recordRecoveryAttempt, createStreamRecoveryState, resetStreamRecoveryState, } from "./stream-recovery.js";
 import { modelSupportsVision, resolveToolDialect } from "../llm/capabilities.js";
@@ -55,7 +56,7 @@ import { analyzeTask, formatTaskAnalysisHint, isNarrowExplicitNmapOperation, } f
 import { computeMaxIterations, computeStepBudget } from "./step-budget.js";
 import { isScratchOnlyWrite } from "./scratch-write.js";
 import { buildDurableEnvelope, WorkLedger, } from "./durable-envelope.js";
-import { COMPACTION_SYSTEM_PROMPT, COMPACTION_MAX_COMPLETION_TOKENS, COMPACTION_MAP_MAX_COMPLETION_TOKENS, } from "./compaction-summary.js";
+import { buildCompactionRetryPrompt, compactionSinglePassInputBudget, COMPACTION_SYSTEM_PROMPT, COMPACTION_MAX_COMPLETION_TOKENS, COMPACTION_MAP_MAX_COMPLETION_TOKENS, isCompactionCompletionTruncated, looksLikeIncompleteCompactionSummary, looksLikeTranscriptReplay, normalizeCompactionSummary, } from "./compaction-summary.js";
 import { maybeAppendPlanModeReminder, PLAN_REMINDER_TOAST, } from "./plan-mode-reminders.js";
 import { LoopGuard } from "./loop-guard.js";
 import { appendInterruptedReasoning, interruptedReasoningBrief, isMeaningfulResumptionYield, } from "./interrupted-reasoning.js";
@@ -315,12 +316,21 @@ export async function runAgentTurn(prompt, options = {}) {
             process.stdout.write(chalk.dim("  ✦ Compacted Context · streaming Markdown\n\n"));
         }
     };
-    const writeCompactionDelta = (id, text) => {
-        if (!text)
+    const writeCompactionDelta = (id, text, replace = false) => {
+        if (!text && !replace)
             return;
-        emit({ type: "compaction-delta", id, text });
-        if (writesDirectly)
-            process.stdout.write(text);
+        emit({
+            type: "compaction-delta",
+            id,
+            text,
+            ...(replace ? { replace: true } : {}),
+        });
+        if (writesDirectly) {
+            if (replace)
+                process.stdout.write(chalk.dim("\n  ↻ rewriting compacted context\n\n"));
+            if (text)
+                process.stdout.write(text);
+        }
     };
     const writeCompactionCompleted = (id, summary, beforeTokens, afterTokens) => {
         emit({
@@ -913,6 +923,7 @@ export async function runAgentTurn(prompt, options = {}) {
         // Track consecutive thinking-only responses so we can nudge the model
         // to actually act instead of silently returning an empty answer.
         let emptyVisibleRetries = 0;
+        let truncatedBudgetRounds = 0;
         let retryWithoutThinking = false;
         // Robust stream-failure recovery. When a provider stream/complete fails we
         // try working approaches (backoff, compaction, thinking-off, provider
@@ -1164,6 +1175,7 @@ export async function runAgentTurn(prompt, options = {}) {
         /** Successful file mutation this turn — kills false "error diagnosed but not fixed". */
         let sawSuccessfulMutation = false;
         let step = -1;
+        let stepMaxTokens = 0;
         let nextToolEventId = 0;
         const alreadyPrintedIds = new Set();
         const promptMutex = {
@@ -2771,50 +2783,105 @@ export async function runAgentTurn(prompt, options = {}) {
         const summarizeForCompaction = async (summaryPrompt, stage) => {
             const streamFinalSummary = stage?.phase !== "map";
             const compactionId = streamFinalSummary ? activeCompactionId : undefined;
-            const deltaParser = compactionId
-                ? createThinkingStreamParser((text) => writeCompactionDelta(compactionId, text), undefined, { remember: false })
+            const maxTokens = stage?.phase === "map"
+                ? COMPACTION_MAP_MAX_COMPLETION_TOKENS
+                : COMPACTION_MAX_COMPLETION_TOKENS;
+            const sourceMessages = stage?.sourceMessages;
+            const compactionTools = sourceMessages
+                ? selectToolDefs(nativeToolsActive, useCompactSystemPrompt)
                 : undefined;
             const request = {
                 provider,
                 model,
-                messages: [
-                    { role: "system", content: COMPACTION_SYSTEM_PROMPT },
-                    { role: "user", content: summaryPrompt },
-                ],
+                messages: sourceMessages
+                    ? [
+                        ...sourceMessages,
+                        { role: "user", content: summaryPrompt },
+                    ]
+                    : [
+                        { role: "system", content: COMPACTION_SYSTEM_PROMPT },
+                        { role: "user", content: summaryPrompt },
+                    ],
                 temperature: 0.1,
-                maxTokens: stage?.phase === "map"
-                    ? COMPACTION_MAP_MAX_COMPLETION_TOKENS
-                    : COMPACTION_MAX_COMPLETION_TOKENS,
+                maxTokens,
                 thinking: { enabled: false, effort: "none" },
                 signal: options.signal,
                 allowModelFallback: true,
+                ...(compactionTools?.length
+                    ? {
+                        tools: compactionTools,
+                        toolChoice: "none",
+                    }
+                    : {}),
             };
-            const response = await streamWithProvider(request, (token) => deltaParser?.push(token), { onStatus: () => undefined, maxRetries: 0 });
-            deltaParser?.finish();
-            const parsed = stripThinking(response.text);
-            if (parsed.visible.trim() || !parsed.hasThinking)
-                return response.text;
-            const retry = await completeWithProvider({
-                ...request,
-                messages: [
-                    {
-                        role: "system",
-                        content: `${COMPACTION_SYSTEM_PROMPT}\nReturn only the continuation-memory summary. Do not include analysis, reasoning, or <think> tags.`,
-                    },
-                    { role: "user", content: summaryPrompt },
-                ],
-                temperature: 0,
-                maxTokens: stage?.phase === "map"
-                    ? COMPACTION_MAP_MAX_COMPLETION_TOKENS
-                    : COMPACTION_MAX_COMPLETION_TOKENS,
-                thinking: { enabled: false, effort: "none" },
-                allowModelFallback: true,
-            }, { maxRetries: 0 });
-            const retryVisible = stripThinking(retry.text).visible.trim();
-            if (retryVisible && compactionId) {
-                writeCompactionDelta(compactionId, retryVisible);
+            const runAttempt = async (attemptRequest, replace = false) => {
+                if (compactionId && replace) {
+                    writeCompactionDelta(compactionId, "", true);
+                }
+                const parser = createThinkingStreamParser((text) => {
+                    if (compactionId)
+                        writeCompactionDelta(compactionId, text);
+                }, undefined, { remember: false });
+                const result = await streamWithProvider(attemptRequest, (token) => parser.push(token), { onStatus: () => undefined, maxRetries: 0 });
+                parser.finish();
+                return result;
+            };
+            const first = await runAttempt(request);
+            let visible = normalizeCompactionSummary(stripThinking(first.text).visible);
+            let retryReason;
+            if (isCompactionCompletionTruncated(first, maxTokens)) {
+                retryReason = "truncated";
+            }
+            else if (!visible) {
+                retryReason = "reasoning-only";
+            }
+            else if (looksLikeTranscriptReplay(visible)) {
+                retryReason = "replayed";
+            }
+            else if (looksLikeIncompleteCompactionSummary(visible)) {
+                retryReason = "incomplete";
+            }
+            if (retryReason) {
+                const retry = await runAttempt({
+                    ...request,
+                    messages: sourceMessages
+                        ? [
+                            ...sourceMessages,
+                            {
+                                role: "user",
+                                content: buildCompactionRetryPrompt(summaryPrompt, retryReason),
+                            },
+                        ]
+                        : [
+                            {
+                                role: "system",
+                                content: `${COMPACTION_SYSTEM_PROMPT}\nReturn only a complete continuation-memory summary. Do not include analysis, reasoning, or <think> tags.`,
+                            },
+                            {
+                                role: "user",
+                                content: buildCompactionRetryPrompt(summaryPrompt, retryReason),
+                            },
+                        ],
+                    temperature: 0,
+                    maxTokens,
+                    thinking: { enabled: false, effort: "none" },
+                    allowModelFallback: true,
+                }, true);
+                if (isCompactionCompletionTruncated(retry, maxTokens)) {
+                    throw new Error("compaction failed: model hit the summary output limit twice — original context retained");
+                }
+                visible = normalizeCompactionSummary(stripThinking(retry.text).visible);
+                if (!visible) {
+                    throw new Error("compaction failed: model returned an empty summary");
+                }
+                if (looksLikeTranscriptReplay(visible)) {
+                    throw new Error("compaction failed: model replayed the transcript twice — original context retained");
+                }
+                if (looksLikeIncompleteCompactionSummary(visible)) {
+                    throw new Error("compaction failed: model returned an incomplete summary twice — original context retained");
+                }
             }
-            return retry.text;
+            return visible;
         };
         /**
          * Estimate the complete next model request, including attached native-tool
@@ -2907,9 +2974,12 @@ export async function runAgentTurn(prompt, options = {}) {
             activeCompactionId = compactionId;
             writeCompactionStarted(compactionId, beforeTokens);
             try {
+                const compactionTools = selectToolDefs(nativeToolsActive, useCompactSystemPrompt);
+                const compactionSchemaTokens = buildContextBreakdown([], compactionTools).estimatedTotalTokens;
                 const result = await compactMessagesWithSummary(messages, summarizeForCompaction, {
                     budgetTokens: 0,
                     keepRecent: AUTO_COMPACT_KEEP_RECENT,
+                    singlePassInputBudgetTokens: Math.max(0, compactionSinglePassInputBudget(contextLimitTokens ?? modelContextWindow(model, provider)) - compactionSchemaTokens),
                     ...(durableEnvelope ? { durableEnvelope } : {}),
                 });
                 const summaryBody = result.messages.find((m) => isCompactionMemoryMessage(m))?.content ??
@@ -3096,6 +3166,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 }, 10_000);
                 heartbeat.unref?.();
                 const deferredToolCalls = [];
+                const streamedNativeCallNames = new Map();
                 const deltaParser = writesDirectly
                     ? undefined
                     : createThinkingStreamParser((text) => emit({ type: "assistant-delta", text }), (text) => {
@@ -3165,6 +3236,7 @@ export async function runAgentTurn(prompt, options = {}) {
                             nativeToolsActive,
                             toolsAttached,
                             recoveryNudge: retryWithoutThinking,
+                            truncationDepth: truncatedBudgetRounds,
                         }),
                     });
                     // Resume / mid-turn abort can leave orphan tool rows or a user
@@ -3175,10 +3247,11 @@ export async function runAgentTurn(prompt, options = {}) {
                     repairToolProtocol(messages);
                     assertValidToolProtocol(messages);
                     // E3: adaptive completion budget (still large enough for writes).
-                    const stepMaxTokens = resolveStepMaxTokens({
+                    stepMaxTokens = resolveStepMaxTokens({
                         nativeToolsActive,
                         toolsAttached,
                         recoveryNudge: retryWithoutThinking,
+                        truncationDepth: truncatedBudgetRounds,
                     });
                     try {
                         if (responderDelivery &&
@@ -3204,64 +3277,22 @@ export async function runAgentTurn(prompt, options = {}) {
                                     tools: turnTools,
                                     toolChoice: "auto",
                                     parallelToolCalls: true,
-                                    // P2-3: emit tool cards as soon as the function name arrives.
                                     onToolCallDelta: (delta) => {
                                         if (!delta.name)
                                             return;
                                         const name = fromWireName(delta.name) ?? delta.name;
-                                        const existing = deferredToolCalls[delta.index];
-                                        if (existing && existing.call.name !== "…") {
-                                            if (delta.argumentsBytes &&
-                                                delta.argumentsBytes >= 4096 &&
-                                                !writesDirectly) {
-                                                emit({
-                                                    type: "status",
-                                                    text: `${name} (${Math.round(delta.argumentsBytes / 1024)}KB args)`,
-                                                });
-                                            }
-                                            return;
-                                        }
-                                        while (deferredToolCalls.length < delta.index) {
-                                            const slot = deferredToolCalls.length;
-                                            const placeholderId = `tool-${++nextToolEventId}`;
-                                            callIds[slot] = placeholderId;
-                                            deferredToolCalls.push({
-                                                eventId: placeholderId,
-                                                call: { name: "…", args: {} },
-                                                rendered: "",
-                                                shown: false,
-                                            });
-                                        }
-                                        const call = normalizeToolCall({
-                                            name,
-                                            args: {},
-                                        });
-                                        const eventId = existing?.eventId ?? `tool-${++nextToolEventId}`;
-                                        callIds[delta.index] = eventId;
-                                        alreadyPrintedIds.add(eventId);
-                                        const toolCallLine = chalk.cyan(`  ▶ ${call.name}`) +
-                                            chalk.gray(` ${formatToolArgs(call)}`);
-                                        const entry = {
-                                            eventId,
-                                            call,
-                                            rendered: styleToolChatter(call, toolCallLine) + "\n",
-                                            shown: false,
-                                        };
-                                        if (deferredToolCalls.length === delta.index) {
-                                            deferredToolCalls.push(entry);
-                                        }
-                                        else {
-                                            deferredToolCalls[delta.index] = entry;
-                                        }
-                                        streamedCallsCount = Math.max(streamedCallsCount, deferredToolCalls.length);
+                                        streamedNativeCallNames.set(delta.index, name);
                                         if (!writesDirectly) {
-                                            writeToolCall(eventId, call, entry.rendered);
-                                            entry.shown = true;
-                                            emit({ type: "status", text: call.name });
+                                            emit({
+                                                type: "status",
+                                                text: delta.argumentsBytes && delta.argumentsBytes >= 4096
+                                                    ? `${name} (${Math.round(delta.argumentsBytes / 1024)}KB args)`
+                                                    : name,
+                                            });
                                         }
                                         else {
                                             spinner.stop();
-                                            spinner = startThinkingSpinner(`tool ${call.name}…`, options.signal);
+                                            spinner = startThinkingSpinner(`tool ${name}…`, options.signal);
                                         }
                                     },
                                 }
@@ -3279,7 +3310,7 @@ export async function runAgentTurn(prompt, options = {}) {
                                         spinner.stop();
                                     }
                                     while (streamedCallsCount < parsedCalls.length) {
-                                        const call = parsedCalls[streamedCallsCount];
+                                        const call = normalizeToolCall(parsedCalls[streamedCallsCount]);
                                         const eventId = `tool-${++nextToolEventId}`;
                                         callIds[streamedCallsCount] = eventId;
                                         alreadyPrintedIds.add(eventId);
@@ -3767,8 +3798,24 @@ export async function runAgentTurn(prompt, options = {}) {
                     }
                 }
                 if (!canonicalAssistantVisible.trim() && !call) {
+                    const completionTokens = completion.usage?.completionTokens ?? 0;
+                    const hitOutputLimit = completion.finishReason === "length" ||
+                        (completionTokens > 0 && stepMaxTokens > 0 && completionTokens >= stepMaxTokens - 64);
+                    const truncatedRoundText = collapseRepeatedText(completion.text ?? "");
+                    if (hitOutputLimit && truncatedRoundText.trim() && truncatedBudgetRounds < 2) {
+                        truncatedBudgetRounds += 1;
+                        writeNotice("warn", "response hit the output token limit — continuing from where it stopped", chalk.yellow("  ⚠ response hit the output token limit — continuing from where it stopped\n"));
+                        messages.push({
+                            role: "assistant",
+                            content: sanitizeAssistantText(truncatedRoundText),
+                        });
+                        messages.push(recoveryUserMessage("Your previous response was cut off by the output token limit before it completed. " +
+                            "Continue directly from where it stopped — do not restart the analysis or repeat prior text. " +
+                            "Finish briefly: emit the next tool call, or the final answer if the task is complete."));
+                        continue;
+                    }
                     const incompleteNativeStream = nativeToolCalls.length === 0 &&
-                        deferredToolCalls.some((entry) => entry.shown && entry.call.name !== "…");
+                        streamedNativeCallNames.size > 0;
                     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) {
@@ -3811,6 +3858,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 else {
                     // Reset the counter on any successful visible output or recovered call.
                     emptyVisibleRetries = 0;
+                    truncatedBudgetRounds = 0;
                     retryWithoutThinking = false;
                 }
                 let bareArgsOnly = false;
@@ -4180,13 +4228,14 @@ export async function runAgentTurn(prompt, options = {}) {
                     let parsed = parseAllToolCalls(assistantText.visible || assistantText.thinkContent);
                     if (parsed.length === 0 && call)
                         parsed = [call];
-                    bound = parsed.map((c, index) => {
+                    bound = parsed.map((rawCall, index) => {
+                        const call = normalizeToolCall(rawCall);
                         const id = syntheticToolCallId(index);
                         return {
                             index,
                             id,
-                            call: c,
-                            native: { id, name: c.name, args: c.args },
+                            call,
+                            native: { id, name: call.name, args: call.args },
                         };
                     });
                 }
@@ -4356,7 +4405,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 for (const deferred of activeDeferredToolCalls.slice(0, allCalls.length)) {
                     if (!deferred.call.name || deferred.call.name === "…")
                         continue;
-                    if (!deferred.shown || !writesDirectly) {
+                    if (!deferred.shown) {
                         writeToolCall(deferred.eventId, deferred.call, deferred.rendered);
                         deferred.shown = true;
                     }