@x-code-cli/core 0.1.3 → 0.1.5

package/dist/agent/loop.js

@@ -1,148 +1,22 @@
-// @x-code-cli/core — Agent Loop (core logic: streaming, tool calls, permission, context compression)
-import { execa } from 'execa';
+// @x-code-cli/core — Agent Loop (orchestration: streaming, tool calls, permission, context compression)
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { generateText, streamText } from 'ai';
-import { buildKnowledgeContext, loadRuleFiles } from '../knowledge/loader.js';
-import { formatSessionForPrompt, generateSessionSummary, loadLatestSession, saveSessionSummary, } from '../knowledge/session.js';
-import { checkPermission } from '../permissions/index.js';
+import { buildKnowledgeContext } from '../knowledge/loader.js';
+import { generateSessionSummary, saveSessionSummary } from '../knowledge/session.js';
+import { clearProgressReporter, setProgressReporter } from '../tools/progress.js';
 import { toolRegistry, truncateToolResult } from '../tools/index.js';
-import { getShellConfig } from '../tools/shell-utils.js';
-import { estimateTokens, toolResultMessage } from './messages.js';
-import { ensurePlansDir, generatePlanId, getPlanPath } from './plan-mode.js';
-import { estimateCost } from './pricing.js';
+import { debugLog } from '../utils.js';
+import { classifyApiError, isContextTooLongError } from './api-errors.js';
+import { estimateTokenCount, getCompressionThreshold, getMaxOutputTokens } from './context-window.js';
+import { createLoopState } from './loop-state.js';
+import { ensureReasoningContentParts } from './provider-compat.js';
+import { drainStreamResult } from './stream-utils.js';
 import { buildSystemPrompt } from './system-prompt.js';
+import { processToolCalls } from './tool-execution.js';
+/** Number of recent messages to keep verbatim when compressing. */
 const KEEP_RECENT = 6;
-const DEFAULT_TOKEN_BUDGET_RATIO = 0.8;
-/** Count occurrences of a substring without creating intermediate arrays */
-function countOccurrences(content, search) {
-    let count = 0;
-    let pos = 0;
-    while ((pos = content.indexOf(search, pos)) !== -1) {
-        count++;
-        pos += search.length;
-    }
-    return count;
-}
-/**
- * Ensure all assistant messages have a reasoning content part.
- *
- * DeepSeek Reasoner requires the `reasoning_content` field on every assistant
- * message during tool-call chains.  The upstream `@ai-sdk/deepseek` converter
- * sets `reasoning_content: undefined` when no reasoning part exists, and
- * `JSON.stringify` strips `undefined` values — causing the DeepSeek API to
- * reject the request with a 400 "Missing reasoning_content" error.
- *
- * This helper injects an empty `{ type: 'reasoning', text: '' }` part into any
- * assistant message that lacks one, so the converter always produces
- * `"reasoning_content": ""` in the JSON body.
- */
-function ensureReasoningContentParts(messages, modelId) {
-    if (!modelId.includes('deepseek-reasoner'))
-        return;
-    for (const msg of messages) {
-        if (msg.role !== 'assistant')
-            continue;
-        const content = msg.content;
-        if (!Array.isArray(content))
-            continue;
-        const hasReasoning = content.some((p) => p.type === 'reasoning');
-        if (!hasReasoning) {
-            // Prepend an empty reasoning part so the converter produces `reasoning_content: ""`
-            ;
-            content.unshift({ type: 'reasoning', text: '' });
-        }
-    }
-}
-/** Context window sizes per model (tokens). Falls back to provider default, then 128k. */
-const MODEL_CONTEXT_WINDOWS = {
-    // Anthropic
-    'anthropic:claude-opus-4-6': 200000,
-    'anthropic:claude-sonnet-4-5': 200000,
-    'anthropic:claude-haiku-4-5': 200000,
-    // OpenAI
-    'openai:gpt-4.1': 1047576,
-    'openai:gpt-4.1-mini': 1047576,
-    'openai:gpt-4.1-nano': 1047576,
-    'openai:o3': 200000,
-    'openai:o4-mini': 200000,
-    // Google
-    'google:gemini-2.5-pro': 1000000,
-    'google:gemini-2.5-flash': 1000000,
-    // DeepSeek
-    'deepseek:deepseek-chat': 64000,
-    'deepseek:deepseek-reasoner': 64000,
-    // Alibaba
-    'alibaba:qwen-max': 128000,
-    'alibaba:qwen-plus': 128000,
-    // xAI
-    'xai:grok-3': 131072,
-    'xai:grok-3-mini': 131072,
-    // Zhipu
-    'zhipu:glm-4-plus': 128000,
-    // Moonshot
-    'moonshotai:kimi-k2.5': 131072,
-};
-/** Provider-level fallback context windows */
-const PROVIDER_CONTEXT_WINDOWS = {
-    anthropic: 200000,
-    openai: 128000,
-    google: 1000000,
-    deepseek: 64000,
-    alibaba: 128000,
-    xai: 128000,
-    zhipu: 128000,
-    moonshotai: 128000,
-};
-function getTokenBudget(modelId) {
-    const contextWindow = MODEL_CONTEXT_WINDOWS[modelId] ?? PROVIDER_CONTEXT_WINDOWS[modelId.split(':')[0]] ?? 128000;
-    return Math.floor(contextWindow * DEFAULT_TOKEN_BUDGET_RATIO);
-}
-/** Execute a write tool (writeFile / edit) */
-async function executeWriteTool(toolName, input) {
-    if (toolName === 'writeFile') {
-        const filePath = input.filePath;
-        const content = input.content;
-        await fs.mkdir(path.dirname(filePath), { recursive: true });
-        await fs.writeFile(filePath, content, 'utf-8');
-        return `File written: ${filePath} (${content.length} characters)`;
-    }
-    if (toolName === 'edit') {
-        const filePath = input.filePath;
-        const oldString = input.oldString;
-        const newString = input.newString;
-        const replaceAll = input.replaceAll ?? false;
-        const content = await fs.readFile(filePath, 'utf-8');
-        if (!replaceAll) {
-            const count = countOccurrences(content, oldString);
-            if (count === 0)
-                return `Error: old_string not found in ${filePath}`;
-            if (count > 1)
-                return `Error: old_string is not unique in ${filePath} (found ${count} occurrences). Provide more context or set replaceAll: true.`;
-        }
-        const newContent = replaceAll ? content.replaceAll(oldString, newString) : content.replace(oldString, newString);
-        await fs.writeFile(filePath, newContent, 'utf-8');
-        return `File edited: ${filePath}`;
-    }
-    return 'Error: unknown write tool';
-}
-/** Execute a shell command with streaming */
-async function executeShell(command, timeout, callbacks) {
-    const { executable, args } = getShellConfig();
-    const proc = execa(executable, [...args, command], {
-        timeout,
-        reject: false,
-    });
-    proc.stdout?.on('data', (chunk) => {
-        callbacks.onShellOutput(chunk.toString());
-    });
-    proc.stderr?.on('data', (chunk) => {
-        callbacks.onShellOutput(chunk.toString());
-    });
-    const result = await proc;
-    return `exit code: ${result.exitCode}\n${result.stdout}\n${result.stderr}`.trim();
-}
-/** Compress old messages into a summary */
+/** Compress old messages into a summary. */
 export async function compressMessages(messages, model) {
     const recent = messages.slice(-KEEP_RECENT);
     const old = messages.slice(0, -KEEP_RECENT);
@@ -155,272 +29,223 @@ export async function compressMessages(messages, model) {
     });
     return [{ role: 'user', content: `[Previous conversation summary]\n${summary}` }, ...recent];
 }
-/** Classify API error and return a user-friendly recovery message */
-function classifyApiError(err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    const statusMatch = msg.match(/(\d{3})/);
-    const status = statusMatch ? Number(statusMatch[1]) : 0;
-    if (msg.includes('Missing `reasoning_content`') || msg.includes('reasoning_content')) {
-        return {
-            message: 'DeepSeek Reasoner requires reasoning_content in assistant messages during tool-call chains. This is usually an SDK compatibility issue — please report it.',
-            retryable: false,
-        };
-    }
-    if (msg.includes('API key is missing') || msg.includes('API_KEY')) {
-        // Extract provider name from message like "DeepSeek API key API key is missing..."
-        const providerMatch = msg.match(/^(\w+)\s+API key/i);
-        const provider = providerMatch ? providerMatch[1] : 'Provider';
-        return {
-            message: `${provider} API key is not set. Please set the corresponding environment variable (e.g. ${provider.toUpperCase()}_API_KEY).`,
-            retryable: false,
-        };
-    }
-    if (status === 401 || msg.includes('Unauthorized') || msg.includes('Invalid API Key')) {
-        return {
-            message: 'API authentication failed (401). Please check your API key with /model or reconfigure with `xc init`.',
-            retryable: false,
-        };
-    }
-    if (status === 403 || msg.includes('Forbidden')) {
-        return {
-            message: 'API access forbidden (403). Your API key may not have permission for this model.',
-            retryable: false,
-        };
-    }
-    if (status === 503 || msg.includes('Service Unavailable') || msg.includes('overloaded')) {
-        return {
-            message: 'Model service unavailable (503). Try switching to a different model with /model.',
-            retryable: false,
-        };
-    }
-    if (status === 429 || msg.includes('rate limit') || msg.includes('Rate limit')) {
-        return {
-            message: 'Rate limited (429). Waiting for retry... (AI SDK handles exponential backoff automatically with maxRetries: 3)',
-            retryable: true, // AI SDK maxRetries handles this
-        };
+/**
+ * Proactive compression: compress when either the last real input-token count
+ * or the character-based estimate has crossed the threshold.
+ */
+async function checkAndCompressContext(state, model, threshold, callbacks) {
+    const needsCompression = state.lastInputTokens > threshold || estimateTokenCount(state.messages) > threshold;
+    if (!needsCompression || state.messages.length <= KEEP_RECENT)
+        return;
+    try {
+        const summary = await generateSessionSummary(state.messages, model, state.sessionId, state.startedAt, [
+            ...state.filesModified,
+        ]);
+        await saveSessionSummary(summary);
     }
-    if (msg.includes('timeout') || msg.includes('ETIMEDOUT') || msg.includes('ECONNRESET')) {
-        return {
-            message: `Network error: ${msg}. Retrying...`,
-            retryable: true,
-        };
+    catch {
+        // Don't block compression on session save failure
     }
-    return { message: msg, retryable: false };
+    state.messages = await compressMessages(state.messages, model);
+    state.lastInputTokens = 0;
+    callbacks.onContextCompressed('Context compressed to fit context window.');
 }
-/** Helper to push a tool result to state and notify the UI */
-function pushToolResult(state, callbacks, toolCallId, toolName, output) {
-    state.messages.push(toolResultMessage(toolCallId, toolName, output));
-    callbacks.onToolResult(toolCallId, output);
+/**
+ * Reactive compact: when a stream errors because the prompt was too long,
+ * compress and signal the caller to retry. Mirrors Claude Code's reactiveCompact.
+ * Returns true if compression happened (caller should retry this turn).
+ */
+async function handleContextTooLong(state, model, callbacks) {
+    if (state.messages.length <= KEEP_RECENT)
+        return false;
+    state.messages = await compressMessages(state.messages, model);
+    state.lastInputTokens = 0;
+    callbacks.onContextCompressed('Context too long — automatically compressed. Retrying...');
+    return true;
 }
-/** Handle all tool calls from a single model turn */
-async function handleToolCalls(toolCalls, state, options, callbacks) {
-    for (const tc of toolCalls) {
-        const { toolName, input, toolCallId } = tc;
-        let output;
-        // ── Plan mode tools ──
-        if (toolName === 'enterPlanMode') {
-            state.planMode = true;
-            state.planId = generatePlanId();
-            await ensurePlansDir();
-            output = `Plan mode activated. Plan ID: ${state.planId}. Use only read-only tools. Save plan to ${getPlanPath(state.planId)}`;
-            pushToolResult(state, callbacks, toolCallId, toolName, output);
-            continue;
+/** Consume streamText output, dispatching chunks to the UI via callbacks.
+ *  Reasoning-delta chunks (thinking-mode models — DeepSeek-reasoner, o1,
+ *  etc.) are deliberately ignored: that's the model's internal chain of
+ *  thought, not user-facing output. The final user-facing answer arrives
+ *  as regular text-delta chunks. */
+async function streamChunksToUI(result, callbacks) {
+    for await (const chunk of result.fullStream) {
+        if (chunk.type === 'text-delta') {
+            const text = chunk.text ?? '';
+            debugLog('stream.text-delta', text);
+            callbacks.onTextDelta(text);
         }
-        if (toolName === 'exitPlanMode') {
-            state.planMode = false;
-            if (state.planId) {
-                const planPath = getPlanPath(state.planId);
-                try {
-                    const planContent = await fs.readFile(planPath, 'utf-8');
-                    output = `Plan ready for review:\n\n${planContent}`;
-                }
-                catch {
-                    output = 'Plan mode exited. No plan file found.';
-                }
+        else if (chunk.type === 'tool-call') {
+            debugLog('stream.tool-call', `${chunk.toolName ?? ''} ${JSON.stringify(chunk.input ?? {})}`);
+            const toolCallId = chunk.toolCallId ?? '';
+            // Register the progress side-channel BEFORE tools start executing —
+            // AI SDK will synchronously invoke `execute(input, { toolCallId })`
+            // for auto-executed tools right after this event, and those tools
+            // call reportProgress(toolCallId, ...) to stream status updates.
+            if (toolCallId) {
+                setProgressReporter(toolCallId, (msg) => callbacks.onToolProgress(toolCallId, msg));
             }
-            else {
-                output = 'Plan mode exited.';
-            }
-            pushToolResult(state, callbacks, toolCallId, toolName, output);
-            continue;
+            callbacks.onToolCall(toolCallId, chunk.toolName ?? '', (chunk.input ?? {}));
         }
-        // ── askUser tool ──
-        if (toolName === 'askUser') {
-            const question = input.question;
-            const optionsList = input.options;
-            const answer = await callbacks.onAskUser(question, optionsList);
-            output = `User answered: ${answer}`;
-            pushToolResult(state, callbacks, toolCallId, toolName, output);
-            continue;
+        else if (chunk.type === 'tool-result') {
+            // Notify UI about auto-executed tool results (readFile, glob, grep, etc.)
+            const raw = typeof chunk.output === 'string' ? chunk.output : JSON.stringify(chunk.output ?? '');
+            debugLog('stream.tool-result', `${chunk.toolCallId ?? ''} ${raw}`);
+            if (chunk.toolCallId)
+                clearProgressReporter(chunk.toolCallId);
+            callbacks.onToolResult(chunk.toolCallId ?? '', truncateToolResult(raw));
         }
-        // ── Permission check for write tools and shell ──
-        if (toolName === 'writeFile' || toolName === 'edit' || toolName === 'shell') {
-            const approved = await checkPermission({ toolName, input }, options.trustMode, callbacks.onAskPermission);
-            if (!approved) {
-                pushToolResult(state, callbacks, toolCallId, toolName, 'Permission denied by user.');
-                continue;
-            }
-        }
-        // ── Execute tool ──
-        try {
-            if (toolName === 'writeFile' || toolName === 'edit') {
-                output = await executeWriteTool(toolName, input);
-                const filePath = input.filePath;
-                state.filesModified.add(filePath);
-            }
-            else if (toolName === 'shell') {
-                const timeout = input.timeout ?? 30000;
-                output = await executeShell(input.command, timeout, callbacks);
-            }
-            else {
-                // Tools with execute (readFile, glob, grep, etc.) are auto-executed by AI SDK
-                continue;
-            }
+        else {
+            debugLog('stream.other-chunk', chunk.type);
         }
-        catch (err) {
-            output = `Error: ${err instanceof Error ? err.message : String(err)}`;
+        // reasoning-delta / reasoning-start / reasoning-end: intentionally dropped from UI
+        // but logged above under stream.other-chunk so we can see them in debug mode.
+    }
+}
+/** Pull the response + usage off a completed stream and fold into state. */
+async function collectTurnResponse(result, state, modelId, callbacks) {
+    const response = await result.response;
+    state.messages.push(...response.messages);
+    ensureReasoningContentParts(state.messages, modelId);
+    const usage = await result.usage;
+    if (usage) {
+        state.tokenUsage.inputTokens += usage.inputTokens ?? 0;
+        state.tokenUsage.outputTokens += usage.outputTokens ?? 0;
+        state.tokenUsage.totalTokens = state.tokenUsage.inputTokens + state.tokenUsage.outputTokens;
+        if (usage.inputTokens != null)
+            state.lastInputTokens = usage.inputTokens;
+        callbacks.onUsageUpdate(state.tokenUsage);
+    }
+    return result.finishReason;
+}
+/** Run one agent turn: stream to UI, collect response. Resilient to errors. */
+async function runTurn(state, model, options, systemPrompt, callbacks) {
+    let result;
+    try {
+        result = streamText({
+            model,
+            system: systemPrompt,
+            messages: state.messages,
+            tools: toolRegistry,
+            maxRetries: 3,
+            abortSignal: options.abortSignal,
+            // Explicit ceiling so provider defaults don't silently truncate long
+            // replies. Most providers clamp a too-high value, but some reject it
+            // outright with HTTP 400. getMaxOutputTokens applies per-model ceilings;
+            // unknown models fall through to the module-level default.
+            maxOutputTokens: getMaxOutputTokens(options.modelId),
+        });
+    }
+    catch (err) {
+        callbacks.onError(new Error(classifyApiError(err).message));
+        return { kind: 'error' };
+    }
+    // Pre-attach .catch(noop) handlers to every sibling promise the SDK exposes
+    // (response/usage/finishReason/toolCalls) BEFORE we await the stream. On
+    // request failure the SDK rejects all of them in the same tick — if we wait
+    // for fullStream to throw and only then drain, Node's unhandled-rejection
+    // sweep can run first and terminate the process. Attaching catch handlers
+    // early is idempotent: a later `await result.response` still rejects and
+    // propagates normally through our error path.
+    drainStreamResult(result);
+    try {
+        await streamChunksToUI(result, callbacks);
+    }
+    catch (err) {
+        // Silently drain all pending AI SDK promises so unhandled-rejection
+        // warnings (NoOutputGeneratedError) don't leak to stderr.
+        drainStreamResult(result);
+        if (isContextTooLongError(err)) {
+            const compressed = await handleContextTooLong(state, model, callbacks);
+            if (compressed)
+                return { kind: 'retry' };
         }
-        output = truncateToolResult(output);
-        pushToolResult(state, callbacks, toolCallId, toolName, output);
+        callbacks.onError(new Error(classifyApiError(err).message));
+        return { kind: 'error' };
+    }
+    try {
+        const finishReason = await collectTurnResponse(result, state, options.modelId, callbacks);
+        debugLog('turn.finish', `reason=${finishReason} turn=${state.turnCount} input=${state.lastInputTokens} total=${state.tokenUsage.totalTokens}`);
+        return { kind: 'done', finishReason, result };
+    }
+    catch (err) {
+        drainStreamResult(result);
+        callbacks.onError(new Error(classifyApiError(err).message));
+        return { kind: 'error' };
     }
 }
-/** Main agent loop */
+/** Main agent loop. */
 export async function agentLoop(userMessage, model, options, callbacks, existingState) {
-    const state = existingState ?? {
-        messages: [],
-        tokenUsage: { inputTokens: 0, outputTokens: 0, totalTokens: 0, estimatedCost: 0, costCurrency: 'USD' },
-        planMode: false,
-        planId: null,
-        sessionId: Date.now().toString(36),
-        startedAt: new Date().toISOString(),
-        filesModified: new Set(),
-        turnCount: 0,
-    };
+    const state = existingState ?? createLoopState();
     state.messages.push({ role: 'user', content: userMessage });
-    // Load rules once — shared between @rule-name resolution and buildKnowledgeContext
-    const rules = await loadRuleFiles();
-    // Check for @rule-name references in user message
-    const ruleRefs = userMessage.match(/@([\w-]+)/g);
-    let extraRuleContext = '';
-    if (ruleRefs) {
-        for (const ref of ruleRefs) {
-            const ruleName = ref.slice(1); // remove @
-            const rule = rules.find((r) => r.filename === ruleName);
-            if (rule) {
-                extraRuleContext += `\n\n### Rule: ${rule.filename}\n${rule.content}`;
-            }
-        }
-    }
-    const sessionSummary = await loadLatestSession();
-    const sessionContext = sessionSummary ? formatSessionForPrompt(sessionSummary) : undefined;
-    const knowledgeContext = await buildKnowledgeContext({ sessionContext, rules });
-    const fullKnowledgeContext = knowledgeContext + extraRuleContext;
-    const tokenBudget = getTokenBudget(options.modelId);
+    // Session continuation is handled explicitly by the UI: if the user accepts
+    // the resume prompt, the pending work is embedded directly in their first
+    // user message. Auto-injecting it into every system prompt made the model
+    // treat trivial greetings as "continue exploring", so we no longer do that.
+    const fullKnowledgeContext = await buildKnowledgeContext();
+    // Detect git repo once — cheap stat, avoids per-turn disk hit
+    const isGitRepo = await fs
+        .stat(path.join(process.cwd(), '.git'))
+        .then(() => true)
+        .catch(() => false);
+    const compressionThreshold = getCompressionThreshold(options.modelId);
+    // Auto-continuation on `length` finish. Reasoning models can exhaust the
+    // output token budget before the user-visible reply completes — the old
+    // behavior was to stop mid-sentence and surface an error, which looks
+    // broken to the user. Instead, we push a short "continue" nudge and loop,
+    // capped so a pathologically runaway reply still terminates eventually.
+    const MAX_CONTINUATIONS = 3;
+    let continuationAttempts = 0;
     while (state.turnCount < options.maxTurns) {
         state.turnCount++;
-        // Context compression check — also saves session summary before compressing
-        if (estimateTokens(state.messages) > tokenBudget) {
-            try {
-                const summary = await generateSessionSummary(state.messages, model, state.sessionId, state.startedAt, [
-                    ...state.filesModified,
-                ]);
-                await saveSessionSummary(summary);
-            }
-            catch {
-                // Don't block compression on session save failure
-            }
-            state.messages = await compressMessages(state.messages, model);
-            callbacks.onContextCompressed('Context compressed to fit token budget.');
-        }
+        await checkAndCompressContext(state, model, compressionThreshold, callbacks);
         const systemPrompt = buildSystemPrompt({
             knowledgeContext: fullKnowledgeContext,
-            planMode: state.planMode,
             modelId: options.modelId,
+            isGitRepo,
         });
-        let result;
-        try {
-            result = streamText({
-                model,
-                system: systemPrompt,
-                messages: state.messages,
-                tools: toolRegistry,
-                maxRetries: 3,
-                abortSignal: options.abortSignal,
-            });
-        }
-        catch (err) {
-            const classified = classifyApiError(err);
-            callbacks.onError(new Error(classified.message));
-            break;
-        }
-        // Stream chunks to UI
-        try {
-            for await (const chunk of result.fullStream) {
-                if (chunk.type === 'text-delta') {
-                    callbacks.onTextDelta(chunk.text ?? '');
-                }
-                if (chunk.type === 'tool-call') {
-                    callbacks.onToolCall(chunk.toolName ?? '', (chunk.input ?? {}));
-                }
-                // Truncate auto-executed tool results (readFile, glob, grep, etc.)
-                if (chunk.type === 'tool-result') {
-                    const raw = typeof chunk.output === 'string' ? chunk.output : JSON.stringify(chunk.output ?? '');
-                    const truncated = truncateToolResult(raw);
-                    if (truncated !== raw) {
-                        // Result was truncated — the original is already in messages via AI SDK,
-                        // but we notify via callback so the UI can show it
-                        callbacks.onToolResult(chunk.toolCallId ?? '', truncated);
-                    }
-                }
-            }
-        }
-        catch (err) {
-            const classified = classifyApiError(err);
-            callbacks.onError(new Error(classified.message));
-            if (!classified.retryable)
-                break;
-            // For retryable errors, AI SDK maxRetries already handles retry;
-            // if we still get here, the retries were exhausted — break
-            break;
-        }
-        // Collect response + usage (may fail if stream errored)
-        let finishReason;
-        try {
-            const response = await result.response;
-            state.messages.push(...response.messages);
-            // Workaround: DeepSeek Reasoner requires `reasoning_content` on every
-            // assistant message in tool-call chains.  Ensure it's always present.
-            ensureReasoningContentParts(state.messages, options.modelId);
-            const usage = await result.usage;
-            if (usage) {
-                state.tokenUsage.inputTokens += usage.inputTokens ?? 0;
-                state.tokenUsage.outputTokens += usage.outputTokens ?? 0;
-                state.tokenUsage.totalTokens = state.tokenUsage.inputTokens + state.tokenUsage.outputTokens;
-                const costEstimate = estimateCost(options.modelId, state.tokenUsage.inputTokens, state.tokenUsage.outputTokens);
-                state.tokenUsage.estimatedCost = costEstimate.cost;
-                state.tokenUsage.costCurrency = costEstimate.currency;
-                callbacks.onUsageUpdate(state.tokenUsage);
-            }
-            finishReason = await result.finishReason;
-        }
-        catch (err) {
-            const classified = classifyApiError(err);
-            callbacks.onError(new Error(classified.message));
+        const outcome = await runTurn(state, model, options, systemPrompt, callbacks);
+        if (outcome.kind === 'error')
             break;
+        if (outcome.kind === 'retry') {
+            // Don't count a failed attempt that got recovered via reactive compaction.
+            state.turnCount--;
+            continue;
         }
-        if (finishReason === 'tool-calls') {
+        if (outcome.finishReason === 'tool-calls') {
+            // Any successful tool round means the model is making real progress —
+            // reset the consecutive-truncation counter.
+            continuationAttempts = 0;
             let toolCalls;
             try {
-                toolCalls = await result.toolCalls;
+                toolCalls = await outcome.result.toolCalls;
             }
             catch (err) {
-                const classified = classifyApiError(err);
-                callbacks.onError(new Error(classified.message));
+                callbacks.onError(new Error(classifyApiError(err).message));
                 break;
             }
-            await handleToolCalls(toolCalls, state, options, callbacks);
+            await processToolCalls(toolCalls, state, options, callbacks);
             continue;
         }
+        if (outcome.finishReason === 'length') {
+            if (continuationAttempts < MAX_CONTINUATIONS) {
+                continuationAttempts++;
+                debugLog('turn.length-continuation', `attempt=${continuationAttempts}/${MAX_CONTINUATIONS} turn=${state.turnCount}`);
+                // Nudge the model to pick up exactly where it stopped. This goes
+                // into state.messages but NOT into UI messages, so the user sees
+                // one continuous streamed reply with at most a brief pause.
+                state.messages.push({
+                    role: 'user',
+                    content: 'Output token limit hit. Resume directly — no apology, no recap. Pick up mid-thought if that is where the cut happened. Break remaining work into smaller pieces.',
+                });
+                continue;
+            }
+            callbacks.onError(new Error(`Response still truncated after ${MAX_CONTINUATIONS} continuation attempts — ask a narrower question.`));
+            break;
+        }
+        if (outcome.finishReason === 'content-filter') {
+            callbacks.onError(new Error('Response stopped by the provider content filter.'));
+        }
         break;
     }
     if (state.turnCount >= options.maxTurns) {
@@ -428,16 +253,23 @@ export async function agentLoop(userMessage, model, options, callbacks, existing
     }
     return state;
 }
-/** Save session on exit */
-export async function saveSession(state, model) {
+/** Save session on exit. Summary generation makes an LLM call that can be
+ *  slow, so we bound it with a 2s timeout — on Ctrl+C we want to return
+ *  to the shell promptly, not wait for a roundtrip. If the timeout fires
+ *  or the call fails, we silently skip (session summaries are nice-to-have,
+ *  not critical for exit). */
+export async function saveSession(state, model, timeoutMs = 2000) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
     try {
-        const summary = await generateSessionSummary(state.messages, model, state.sessionId, state.startedAt, [
-            ...state.filesModified,
-        ]);
+        const summary = await generateSessionSummary(state.messages, model, state.sessionId, state.startedAt, [...state.filesModified], controller.signal);
         await saveSessionSummary(summary);
     }
     catch {
-        // Don't crash on session save failure
+        // Timeout or any other failure — skip summary silently.
+    }
+    finally {
+        clearTimeout(timer);
     }
 }
 //# sourceMappingURL=loop.js.map