erosolar-cli 1.7.414 → 1.7.416

package/dist/core/agent.js

@@ -0,0 +1,881 @@
+import { isMultilinePaste, processPaste } from './multilinePasteHandler.js';
+import { safeErrorMessage } from './secretStore.js';
+/**
+ * Maximum number of context overflow recovery attempts
+ */
+const MAX_CONTEXT_RECOVERY_ATTEMPTS = 3;
+/**
+ * Maximum number of auto-continuation attempts when model expresses intent but doesn't act
+ */
+const MAX_AUTO_CONTINUE_ATTEMPTS = 3;
+/**
+ * Streaming safety timeouts (ms)
+ * - First chunk timeout: fail fast if the stream never starts
+ * - Inactivity timeout: abort if no chunks arrive for an extended period
+ */
+// Allow more headroom before declaring a streaming stall to avoid premature fallbacks.
+const STREAM_FIRST_CHUNK_TIMEOUT_MS = 25000;
+const STREAM_INACTIVITY_TIMEOUT_MS = 60000;
+/**
+ * Patterns that indicate the model intends to take action but hasn't yet
+ * These suggest the model should be prompted to continue
+ */
+const INTENT_WITHOUT_ACTION_PATTERNS = [
+    // "Let me X" patterns - model is stating what it will do
+    /\blet me\s+(create|write|implement|add|update|edit|modify|fix|build|make|refactor|read|check|look|search|find|analyze|examine|review)/i,
+    // "I'll X" / "I will X" patterns
+    /\bi['']ll\s+(create|write|implement|add|update|edit|modify|fix|build|make|refactor|read|check|look|search|find|analyze|start|begin|now)/i,
+    /\bi will\s+(create|write|implement|add|update|edit|modify|fix|build|make|refactor|read|check|look|search|find|analyze|start|begin|now)/i,
+    // "I'm going to X" patterns
+    /\bi['']m going to\s+(create|write|implement|add|update|edit|modify|fix|build|make|refactor|read|check|look|search|find|analyze)/i,
+    // "Now I'll X" / "First, I'll X" patterns
+    /\b(now|first|next)\s*(,)?\s*i['']ll\s+/i,
+    // Explicit continuation signals
+    /\bhere['']s (the|my) (plan|approach|solution|implementation)/i,
+    // Numbered steps suggesting action to come
+    /^\s*\d+\.\s+(create|write|implement|add|update|edit|modify|fix|show|read|check)/im,
+    // Bullet points suggesting planned actions
+    /^[\s•\-\*]+\s*(create|write|implement|add|update|edit|modify|fix|shows?|reads?|checks?)\s/im,
+];
+const AUTO_CONTINUE_PROMPTS = [
+    'Continue. Use tools now: start with Read/read_file to inspect the target file, then call Edit (or Write if available) with file_path/old_string/new_string to apply changes. Keep using tools until the task is done.',
+    'You MUST call tools immediately. Issue Read -> Edit/Write tool calls with explicit parameters; no more explaining or planning.',
+    'CRITICAL: Call a tool right now. Use Edit with file_path, old_string, new_string (or Write with file_path and content). Respond with tool calls only.',
+];
+/**
+ * Check if response indicates intent to act without actually acting
+ * This detects when the model says "let me do X" but doesn't call any tools
+ */
+function shouldAutoContinue(content, hasToolCalls) {
+    // If there are tool calls, no need to auto-continue
+    if (hasToolCalls) {
+        return false;
+    }
+    // If content is very short, likely not an incomplete intent
+    if (content.length < 50) {
+        return false;
+    }
+    // Check for intent patterns
+    for (const pattern of INTENT_WITHOUT_ACTION_PATTERNS) {
+        if (pattern.test(content)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check if an error is a context overflow error
+ */
+function isContextOverflowError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message.toLowerCase();
+    return (message.includes('context length') ||
+        message.includes('token') && (message.includes('limit') || message.includes('exceed') || message.includes('maximum')) ||
+        message.includes('too long') ||
+        message.includes('too many tokens') ||
+        message.includes('max_tokens') ||
+        message.includes('context window'));
+}
+class StreamInterruptionError extends Error {
+    reason;
+    partialResponse;
+    constructor(reason, message, partialResponse) {
+        super(message);
+        this.name = 'StreamInterruptionError';
+        this.reason = reason;
+        this.partialResponse = partialResponse;
+    }
+}
+export class AgentRuntime {
+    messages = [];
+    provider;
+    toolRuntime;
+    callbacks;
+    contextManager;
+    activeRun = null;
+    baseSystemPrompt;
+    providerId;
+    modelId;
+    workingDirectory;
+    cancellationRequested = false;
+    _autoContinueEnabled = false;
+    constructor(options) {
+        this.provider = options.provider;
+        this.toolRuntime = options.toolRuntime;
+        this.callbacks = options.callbacks ?? {};
+        this.contextManager = options.contextManager ?? null;
+        this.providerId = options.providerId ?? 'unknown';
+        this.modelId = options.modelId ?? 'unknown';
+        this.workingDirectory = options.workingDirectory ?? process.cwd();
+        this._autoContinueEnabled = options.autoContinue ?? false;
+        const trimmedPrompt = options.systemPrompt.trim();
+        this.baseSystemPrompt = trimmedPrompt || null;
+        if (trimmedPrompt) {
+            this.messages.push({ role: 'system', content: trimmedPrompt });
+        }
+    }
+    /**
+     * Request cancellation of the current operation.
+     * The agent will stop at the next safe point (after current tool completes).
+     */
+    requestCancellation() {
+        this.cancellationRequested = true;
+    }
+    /**
+     * Check if cancellation has been requested.
+     */
+    isCancellationRequested() {
+        return this.cancellationRequested;
+    }
+    /**
+     * Check if the agent is currently processing a request.
+     */
+    isRunning() {
+        return this.activeRun !== null;
+    }
+    /**
+     * Check if auto-continuation is enabled.
+     */
+    isAutoContinueEnabled() {
+        return this._autoContinueEnabled;
+    }
+    /**
+     * Enable or disable auto-continuation.
+     */
+    setAutoContinue(enabled) {
+        this._autoContinueEnabled = enabled;
+    }
+    async send(text, useStreaming = false) {
+        const prompt = text.trim();
+        if (!prompt) {
+            return '';
+        }
+        // Reset cancellation flag at start of new request
+        this.cancellationRequested = false;
+        // Handle multi-line paste: show summary to user, send full content to AI
+        if (isMultilinePaste(prompt)) {
+            const processed = processPaste(prompt);
+            // Notify UI about the paste summary
+            this.callbacks.onMultilinePaste?.(processed.displaySummary, processed.metadata);
+            // But send the full content to the AI
+            this.messages.push({ role: 'user', content: processed.fullContent });
+        }
+        else {
+            // Single-line or short text: send as-is
+            this.messages.push({ role: 'user', content: prompt });
+        }
+        const run = { startedAt: Date.now() };
+        this.activeRun = run;
+        try {
+            if (useStreaming && this.provider.generateStream) {
+                try {
+                    return await this.processConversationStreaming();
+                }
+                catch (error) {
+                    const message = safeErrorMessage(error);
+                    const reason = error instanceof StreamInterruptionError ? error.reason : undefined;
+                    const partialResponse = error instanceof StreamInterruptionError ? error.partialResponse : undefined;
+                    console.warn(`[agent] Streaming failed, falling back to non-streaming: ${message}`);
+                    this.callbacks.onStreamFallback?.({ message, error, reason, partialResponse });
+                    return await this.processConversation();
+                }
+            }
+            return await this.processConversation();
+        }
+        finally {
+            if (this.activeRun === run) {
+                this.activeRun = null;
+            }
+            // Reset cancellation flag when done
+            this.cancellationRequested = false;
+        }
+    }
+    async processConversation() {
+        let contextRecoveryAttempts = 0;
+        let autoContinueAttempts = 0;
+        while (true) {
+            // Check for cancellation at start of each iteration
+            if (this.cancellationRequested) {
+                this.callbacks.onCancelled?.();
+                return '[Operation cancelled by user]';
+            }
+            // Prune messages if approaching context limit (BEFORE generation)
+            await this.pruneMessagesIfNeeded();
+            try {
+                const response = await this.provider.generate(this.messages, this.providerTools);
+                const usage = response.usage ?? null;
+                const contextStats = this.getContextStats();
+                // Reset recovery attempts on successful generation
+                contextRecoveryAttempts = 0;
+                if (response.type === 'tool_calls') {
+                    const narration = response.content?.trim();
+                    if (narration) {
+                        this.emitAssistantMessage(narration, { isFinal: false, usage, contextStats });
+                    }
+                    const assistantMessage = {
+                        role: 'assistant',
+                        content: response.content ?? '',
+                    };
+                    if (response.toolCalls?.length) {
+                        assistantMessage.toolCalls = response.toolCalls;
+                    }
+                    this.messages.push(assistantMessage);
+                    await this.resolveToolCalls(response.toolCalls);
+                    // Reset auto-continue counter since model is actively working
+                    autoContinueAttempts = 0;
+                    continue;
+                }
+                const reply = response.content?.trim() ?? '';
+                // Check if model expressed intent to act but didn't call tools
+                // This catches "Let me create..." without actual tool calls
+                // Only auto-continue if the feature is enabled
+                if (this._autoContinueEnabled && shouldAutoContinue(reply, false) && autoContinueAttempts < MAX_AUTO_CONTINUE_ATTEMPTS) {
+                    autoContinueAttempts++;
+                    // Emit the planning content but mark as non-final
+                    if (reply) {
+                        this.emitAssistantMessage(reply, { isFinal: false, usage, contextStats });
+                    }
+                    this.messages.push({ role: 'assistant', content: reply });
+                    // Auto-prompt with increasingly direct instructions
+                    const promptIndex = Math.min(autoContinueAttempts - 1, AUTO_CONTINUE_PROMPTS.length - 1);
+                    this.messages.push({
+                        role: 'user',
+                        content: AUTO_CONTINUE_PROMPTS[promptIndex],
+                    });
+                    const autoContinueMessage = `Model expressed intent but didn't use tools. Auto-prompting to continue...`;
+                    this.callbacks.onAutoContinue?.(autoContinueAttempts, MAX_AUTO_CONTINUE_ATTEMPTS, autoContinueMessage);
+                    continue;
+                }
+                if (reply) {
+                    this.emitAssistantMessage(reply, { isFinal: true, usage, contextStats });
+                }
+                this.messages.push({ role: 'assistant', content: reply });
+                // Trigger verification for final responses with verifiable claims
+                this.triggerVerificationIfNeeded(reply);
+                return reply;
+            }
+            catch (error) {
+                // Auto-recover from context overflow errors
+                if (isContextOverflowError(error) && contextRecoveryAttempts < MAX_CONTEXT_RECOVERY_ATTEMPTS) {
+                    contextRecoveryAttempts++;
+                    const recovered = await this.recoverFromContextOverflow(contextRecoveryAttempts);
+                    if (recovered) {
+                        // Notify UI that we're continuing after recovery
+                        this.callbacks.onContinueAfterRecovery?.();
+                        // Retry the generation with reduced context
+                        continue;
+                    }
+                }
+                // Re-throw if not recoverable or recovery failed
+                throw error;
+            }
+        }
+    }
+    async processConversationStreaming() {
+        if (!this.provider.generateStream) {
+            return this.processConversation();
+        }
+        let contextRecoveryAttempts = 0;
+        let autoContinueAttempts = 0;
+        while (true) {
+            // Check for cancellation at start of each iteration
+            if (this.cancellationRequested) {
+                this.callbacks.onCancelled?.();
+                return '[Operation cancelled by user]';
+            }
+            // Prune messages if approaching context limit (BEFORE generation)
+            await this.pruneMessagesIfNeeded();
+            try {
+                let fullContent = '';
+                const toolCalls = [];
+                let usage = null;
+                const stream = this.provider.generateStream(this.messages, this.providerTools);
+                const iterator = stream[Symbol.asyncIterator]();
+                let streamClosed = false;
+                const closeStream = async () => {
+                    if (streamClosed) {
+                        return;
+                    }
+                    streamClosed = true;
+                    if (typeof iterator.return === 'function') {
+                        try {
+                            await iterator.return();
+                        }
+                        catch (closeError) {
+                            console.warn(`[agent] Failed to close stream cleanly: ${safeErrorMessage(closeError)}`);
+                        }
+                    }
+                };
+                const buildTimeoutError = (reason) => {
+                    const base = reason === 'startup-timeout'
+                        ? 'Streaming stalled before any content arrived.'
+                        : 'Streaming stalled due to inactivity.';
+                    return new StreamInterruptionError(reason, `${base} Falling back to non-streaming.`, fullContent);
+                };
+                // Timer for first token arrival
+                let startupTimer = null;
+                const startupTimeoutPromise = new Promise((_, reject) => {
+                    startupTimer = setTimeout(() => reject(buildTimeoutError('startup-timeout')), STREAM_FIRST_CHUNK_TIMEOUT_MS);
+                });
+                const createIdleTimeout = () => {
+                    let idleTimer = null;
+                    const promise = new Promise((_, reject) => {
+                        idleTimer = setTimeout(() => reject(buildTimeoutError('idle-timeout')), STREAM_INACTIVITY_TIMEOUT_MS);
+                    });
+                    const cancel = () => {
+                        if (idleTimer) {
+                            clearTimeout(idleTimer);
+                            idleTimer = null;
+                        }
+                    };
+                    return { promise, cancel };
+                };
+                let idleTimeout = createIdleTimeout();
+                let firstChunkSeen = false;
+                try {
+                    while (true) {
+                        const races = [
+                            iterator.next(),
+                            idleTimeout.promise,
+                        ];
+                        if (!firstChunkSeen) {
+                            races.push(startupTimeoutPromise);
+                        }
+                        const result = (await Promise.race(races));
+                        // Reset idle timer for the next iteration
+                        idleTimeout.cancel();
+                        idleTimeout = createIdleTimeout();
+                        // Check for cancellation during streaming
+                        if (this.cancellationRequested) {
+                            await closeStream();
+                            this.callbacks.onCancelled?.();
+                            if (fullContent.trim()) {
+                                this.messages.push({ role: 'assistant', content: fullContent + '\n\n[Cancelled by user]' });
+                            }
+                            return '[Operation cancelled by user]';
+                        }
+                        if (result.done) {
+                            break;
+                        }
+                        const chunk = result.value;
+                        if (!firstChunkSeen) {
+                            firstChunkSeen = true;
+                            if (startupTimer) {
+                                clearTimeout(startupTimer);
+                                startupTimer = null;
+                            }
+                        }
+                        if (chunk.type === 'content' && chunk.content) {
+                            fullContent += chunk.content;
+                            this.callbacks.onStreamChunk?.(chunk.content);
+                        }
+                        else if (chunk.type === 'tool_call' && chunk.toolCall) {
+                            toolCalls.push(chunk.toolCall);
+                        }
+                        else if (chunk.type === 'usage' && chunk.usage) {
+                            usage = chunk.usage;
+                        }
+                    }
+                }
+                finally {
+                    idleTimeout.cancel();
+                    if (startupTimer) {
+                        clearTimeout(startupTimer);
+                    }
+                    await closeStream();
+                }
+                // Reset recovery attempts on successful generation
+                contextRecoveryAttempts = 0;
+                const contextStats = this.getContextStats();
+                // Check if we got tool calls
+                if (toolCalls.length > 0) {
+                    const narration = fullContent.trim();
+                    if (narration) {
+                        // Mark as wasStreamed since content was already output via onStreamChunk
+                        this.emitAssistantMessage(narration, { isFinal: false, usage, contextStats, wasStreamed: true });
+                    }
+                    const assistantMessage = {
+                        role: 'assistant',
+                        content: fullContent,
+                        toolCalls,
+                    };
+                    this.messages.push(assistantMessage);
+                    await this.resolveToolCalls(toolCalls);
+                    // Reset auto-continue counter since model is actively working
+                    autoContinueAttempts = 0;
+                    continue;
+                }
+                // Check if model expressed intent to act but didn't call tools
+                // This catches "Let me create..." without actual tool calls
+                // Only auto-continue if the feature is enabled
+                const reply = fullContent.trim();
+                if (this._autoContinueEnabled && shouldAutoContinue(reply, false) && autoContinueAttempts < MAX_AUTO_CONTINUE_ATTEMPTS) {
+                    autoContinueAttempts++;
+                    // Emit the planning content but mark as non-final
+                    // Mark as wasStreamed since content was already output via onStreamChunk
+                    if (reply) {
+                        this.emitAssistantMessage(reply, { isFinal: false, usage, contextStats, wasStreamed: true });
+                    }
+                    this.messages.push({ role: 'assistant', content: reply });
+                    // Auto-prompt with increasingly direct instructions
+                    const promptIndex = Math.min(autoContinueAttempts - 1, AUTO_CONTINUE_PROMPTS.length - 1);
+                    this.messages.push({
+                        role: 'user',
+                        content: AUTO_CONTINUE_PROMPTS[promptIndex],
+                    });
+                    const autoContinueMessage = `Model expressed intent but didn't use tools. Auto-prompting to continue...`;
+                    this.callbacks.onAutoContinue?.(autoContinueAttempts, MAX_AUTO_CONTINUE_ATTEMPTS, autoContinueMessage);
+                    continue;
+                }
+                // Final message - mark as streamed to avoid double-display in UI
+                if (reply) {
+                    this.emitAssistantMessage(reply, { isFinal: true, usage, contextStats, wasStreamed: true });
+                }
+                this.messages.push({ role: 'assistant', content: reply });
+                // Trigger verification for final responses with verifiable claims
+                this.triggerVerificationIfNeeded(reply);
+                return reply;
+            }
+            catch (error) {
+                // Auto-recover from context overflow errors
+                if (isContextOverflowError(error) && contextRecoveryAttempts < MAX_CONTEXT_RECOVERY_ATTEMPTS) {
+                    contextRecoveryAttempts++;
+                    const recovered = await this.recoverFromContextOverflow(contextRecoveryAttempts);
+                    if (recovered) {
+                        // Notify UI that we're continuing after recovery
+                        this.callbacks.onContinueAfterRecovery?.();
+                        // Retry the generation with reduced context
+                        continue;
+                    }
+                }
+                // Re-throw if not recoverable or recovery failed
+                throw error;
+            }
+        }
+    }
+    /**
+     * Execute tool calls with optimized concurrency
+     *
+     * PERF: Uses Promise.all for parallel execution with early result handling.
+     * Results are collected in order but execution happens concurrently.
+     * For very large batches (>10 tools), uses chunked execution to prevent
+     * overwhelming system resources.
+     */
+    async resolveToolCalls(toolCalls) {
+        const numCalls = toolCalls.length;
+        // Check for cancellation before starting tool execution
+        if (this.cancellationRequested) {
+            // Add cancellation message for each pending tool call
+            for (const call of toolCalls) {
+                this.messages.push({
+                    role: 'tool',
+                    name: call.name,
+                    toolCallId: call.id,
+                    content: '[Tool execution cancelled by user]',
+                });
+            }
+            return;
+        }
+        // Fast path: single tool call
+        if (numCalls === 1) {
+            const call = toolCalls[0];
+            const output = await this.toolRuntime.execute(call);
+            this.messages.push({
+                role: 'tool',
+                name: call.name,
+                toolCallId: call.id,
+                content: output,
+            });
+            return;
+        }
+        // PERF: For reasonable batch sizes, execute all in parallel
+        if (numCalls <= 10) {
+            const results = await Promise.all(toolCalls.map(async (call) => ({
+                call,
+                output: await this.toolRuntime.execute(call),
+            })));
+            // Add results to messages in the same order as tool calls
+            for (const { call, output } of results) {
+                this.messages.push({
+                    role: 'tool',
+                    name: call.name,
+                    toolCallId: call.id,
+                    content: output,
+                });
+            }
+            return;
+        }
+        // PERF: For large batches, use chunked parallel execution
+        // This prevents memory pressure from too many concurrent operations
+        const CHUNK_SIZE = 8;
+        const results = [];
+        for (let i = 0; i < numCalls; i += CHUNK_SIZE) {
+            const chunk = toolCalls.slice(i, i + CHUNK_SIZE);
+            const chunkResults = await Promise.all(chunk.map(async (call) => ({
+                call,
+                output: await this.toolRuntime.execute(call),
+            })));
+            results.push(...chunkResults);
+        }
+        // Add results to messages in order
+        for (const { call, output } of results) {
+            this.messages.push({
+                role: 'tool',
+                name: call.name,
+                toolCallId: call.id,
+                content: output,
+            });
+        }
+    }
+    get providerTools() {
+        return this.toolRuntime.listProviderTools();
+    }
+    emitAssistantMessage(content, metadata) {
+        if (!content) {
+            return;
+        }
+        const elapsedMs = this.activeRun ? Date.now() - this.activeRun.startedAt : undefined;
+        const payload = { ...metadata };
+        if (typeof elapsedMs === 'number') {
+            payload.elapsedMs = elapsedMs;
+        }
+        this.callbacks.onAssistantMessage?.(content, payload);
+    }
+    /**
+     * Trigger verification for a final response if callback is registered
+     * and response contains verifiable claims (implementation, build success, etc.)
+     */
+    triggerVerificationIfNeeded(response) {
+        if (!this.callbacks.onVerificationNeeded) {
+            return;
+        }
+        // Only trigger verification for responses that likely contain verifiable claims
+        // These patterns indicate the model is claiming to have completed work
+        const verifiablePatterns = [
+            /\b(implemented|created|wrote|added|fixed|built|deployed|completed|refactored)\b/i,
+            /\b(tests?\s+(are\s+)?pass(ing)?|build\s+succeed)/i,
+            /\b(file|function|class|module|component)\s+(has been|is now|was)\s+(created|updated|modified)/i,
+            /✅|✓|\[done\]|\[complete\]/i,
+            /\bcommit(ted)?\b.*\b(success|done)\b/i,
+        ];
+        const hasVerifiableClaims = verifiablePatterns.some(pattern => pattern.test(response));
+        if (!hasVerifiableClaims) {
+            return;
+        }
+        // Build conversation history for context (last 5 user/assistant exchanges)
+        const conversationHistory = [];
+        const recentMessages = this.messages.slice(-10);
+        for (const msg of recentMessages) {
+            if (msg.role === 'user' || msg.role === 'assistant') {
+                const content = typeof msg.content === 'string' ? msg.content : '';
+                if (content.length > 0) {
+                    conversationHistory.push(`${msg.role}: ${content.slice(0, 500)}`);
+                }
+            }
+        }
+        // Trigger verification callback
+        this.callbacks.onVerificationNeeded(response, {
+            workingDirectory: this.workingDirectory,
+            conversationHistory,
+            provider: this.providerId,
+            model: this.modelId,
+        });
+    }
+    getHistory() {
+        return this.messages.map(cloneMessage);
+    }
+    loadHistory(history) {
+        this.messages.length = 0;
+        if (history.length === 0) {
+            if (this.baseSystemPrompt) {
+                this.messages.push({ role: 'system', content: this.baseSystemPrompt });
+            }
+            return;
+        }
+        for (const message of history) {
+            this.messages.push(cloneMessage(message));
+        }
+    }
+    clearHistory() {
+        this.messages.length = 0;
+        if (this.baseSystemPrompt) {
+            this.messages.push({ role: 'system', content: this.baseSystemPrompt });
+        }
+    }
+    /**
+     * Prune messages if approaching context limit
+     *
+     * This runs BEFORE each generation to ensure we stay within budget.
+     * If LLM summarization is available, it will create intelligent summaries
+     * instead of just removing old messages.
+     */
+    async pruneMessagesIfNeeded() {
+        if (!this.contextManager) {
+            return;
+        }
+        if (this.contextManager.isApproachingLimit(this.messages)) {
+            // Try LLM-based summarization first (preserves context better)
+            const result = await this.contextManager.pruneMessagesWithSummary(this.messages);
+            if (result.removed > 0) {
+                // Replace messages with pruned/summarized version
+                this.messages.length = 0;
+                this.messages.push(...result.pruned);
+                // Notify callback with enriched stats
+                const stats = this.contextManager.getStats(this.messages);
+                const enrichedStats = {
+                    ...stats,
+                    summarized: result.summarized,
+                    method: result.summarized ? 'llm-summary' : 'simple-prune',
+                };
+                this.callbacks.onContextPruned?.(result.removed, enrichedStats);
+                if (process.env['DEBUG_CONTEXT']) {
+                    console.warn(`[Context Manager] ${result.summarized ? 'Summarized' : 'Pruned'} ${result.removed} messages. ` +
+                        `Tokens: ${stats.totalTokens} (${stats.percentage}%)`);
+                }
+            }
+        }
+    }
+    /**
+     * Get current context statistics
+     */
+    getContextStats() {
+        if (!this.contextManager) {
+            return null;
+        }
+        return this.contextManager.getStats(this.messages);
+    }
+    /**
+     * Get context manager instance
+     */
+    getContextManager() {
+        return this.contextManager;
+    }
+    /**
+     * Auto-recover from context overflow errors by aggressively pruning messages.
+     *
+     * This is called when an API call fails due to context length exceeding limits.
+     * It performs increasingly aggressive pruning on each attempt:
+     * - Attempt 1: Remove 30% of oldest messages + truncate tool outputs to 5k
+     * - Attempt 2: Remove 50% of oldest messages + truncate tool outputs to 2k
+     * - Attempt 3: Remove 70% of oldest messages + truncate tool outputs to 500 chars
+     *
+     * @returns true if recovery was successful (context was reduced)
+     */
+    async recoverFromContextOverflow(attempt) {
+        // Calculate reduction percentage based on attempt
+        const reductionPercentages = [0.3, 0.5, 0.7];
+        const reductionPercent = reductionPercentages[attempt - 1] ?? 0.7;
+        // Increasingly aggressive tool output truncation limits
+        const toolOutputLimits = [5000, 2000, 500];
+        const toolOutputLimit = toolOutputLimits[attempt - 1] ?? 500;
+        // Notify UI about recovery attempt
+        const message = `Context overflow detected. Auto-squishing context (attempt ${attempt}/${MAX_CONTEXT_RECOVERY_ATTEMPTS}, removing ${Math.round(reductionPercent * 100)}% of history)...`;
+        this.callbacks.onContextRecovery?.(attempt, MAX_CONTEXT_RECOVERY_ATTEMPTS, message);
+        this.callbacks.onContextSquishing?.(message);
+        // Separate system messages from conversation
+        const systemMessages = [];
+        const conversationMessages = [];
+        for (const msg of this.messages) {
+            if (msg.role === 'system') {
+                systemMessages.push(msg);
+            }
+            else {
+                conversationMessages.push(msg);
+            }
+        }
+        // Calculate how many messages to remove (target)
+        const targetRemoveCount = Math.floor(conversationMessages.length * reductionPercent);
+        if (targetRemoveCount === 0 || conversationMessages.length <= 2) {
+            // Nothing to remove or too few messages - can't recover
+            return false;
+        }
+        // Group messages into conversation "turns" to maintain tool call/result pairing
+        // A turn is: [user] or [assistant + tool results] or [assistant without tools]
+        const turns = [];
+        let currentTurn = [];
+        for (let i = 0; i < conversationMessages.length; i++) {
+            const msg = conversationMessages[i];
+            if (msg.role === 'user') {
+                // User messages start a new turn
+                if (currentTurn.length > 0) {
+                    turns.push(currentTurn);
+                }
+                currentTurn = [msg];
+            }
+            else if (msg.role === 'assistant') {
+                // Assistant messages start a new turn (flush previous)
+                if (currentTurn.length > 0) {
+                    turns.push(currentTurn);
+                }
+                currentTurn = [msg];
+            }
+            else if (msg.role === 'tool') {
+                // Tool results belong to the current assistant turn
+                currentTurn.push(msg);
+            }
+        }
+        // Don't forget the last turn
+        if (currentTurn.length > 0) {
+            turns.push(currentTurn);
+        }
+        // Calculate how many turns to remove
+        const targetTurnsToRemove = Math.floor(turns.length * reductionPercent);
+        if (targetTurnsToRemove === 0 || turns.length <= 2) {
+            return false;
+        }
+        // Keep recent turns (remove from the beginning)
+        const keepTurns = turns.slice(targetTurnsToRemove);
+        // IMPORTANT: Ensure we don't start with orphaned tool messages
+        // The first kept turn must NOT be a tool-only turn
+        let startIndex = 0;
+        while (startIndex < keepTurns.length) {
+            const firstTurn = keepTurns[startIndex];
+            if (firstTurn && firstTurn.length > 0) {
+                const firstMsg = firstTurn[0];
+                // If first message is a tool result, skip this turn
+                if (firstMsg?.role === 'tool') {
+                    startIndex++;
+                    continue;
+                }
+                // If first message is an assistant with tool calls but we're missing results,
+                // check if all tool results are present
+                if (firstMsg?.role === 'assistant' && firstMsg.toolCalls && firstMsg.toolCalls.length > 0) {
+                    // PERF: Pre-compute tool call IDs as array, use direct Set lookup
+                    const toolCallIds = firstMsg.toolCalls.map(tc => tc.id);
+                    const presentToolResultIds = new Set(firstTurn.filter(m => m.role === 'tool').map(m => m.toolCallId));
+                    // PERF: Direct has() calls with early exit instead of spread + every()
+                    let allPresent = true;
+                    for (const id of toolCallIds) {
+                        if (!presentToolResultIds.has(id)) {
+                            allPresent = false;
+                            break;
+                        }
+                    }
+                    if (allPresent) {
+                        break;
+                    }
+                    // Otherwise skip this turn
+                    startIndex++;
+                    continue;
+                }
+            }
+            break;
+        }
+        const validTurns = keepTurns.slice(startIndex);
+        if (validTurns.length === 0) {
+            return false;
+        }
+        // Flatten valid turns back to messages
+        const keepMessages = validTurns.flat();
+        const actualRemoveCount = conversationMessages.length - keepMessages.length;
+        // Aggressively truncate tool outputs in remaining messages
+        let truncatedCount = 0;
+        for (const msg of keepMessages) {
+            if (msg.role === 'tool' && msg.content) {
+                const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+                if (content.length > toolOutputLimit) {
+                    // Truncate with smart ending
+                    const truncated = content.slice(0, toolOutputLimit);
+                    const lastNewline = truncated.lastIndexOf('\n');
+                    const cutPoint = lastNewline > toolOutputLimit * 0.7 ? lastNewline : toolOutputLimit;
+                    msg.content = truncated.slice(0, cutPoint) + `\n\n[... truncated ${content.length - cutPoint} chars for context recovery ...]`;
+                    truncatedCount++;
+                }
+            }
+            // Also truncate very long assistant messages
+            if (msg.role === 'assistant' && msg.content && msg.content.length > toolOutputLimit * 2) {
+                const content = msg.content;
+                const limit = toolOutputLimit * 2;
+                const truncated = content.slice(0, limit);
+                const lastNewline = truncated.lastIndexOf('\n');
+                const cutPoint = lastNewline > limit * 0.8 ? lastNewline : limit;
+                msg.content = truncated.slice(0, cutPoint) + `\n\n[... truncated for context recovery ...]`;
+                truncatedCount++;
+            }
+        }
+        // Also truncate system messages if they're huge (except first system prompt)
+        for (let i = 1; i < systemMessages.length; i++) {
+            const sys = systemMessages[i];
+            if (sys && sys.content && sys.content.length > toolOutputLimit) {
+                sys.content = sys.content.slice(0, toolOutputLimit) + '\n[... truncated ...]';
+                truncatedCount++;
+            }
+        }
+        // Rebuild message array
+        this.messages.length = 0;
+        // Add system messages
+        for (const sys of systemMessages) {
+            this.messages.push(sys);
+        }
+        // Add summary notice
+        this.messages.push({
+            role: 'system',
+            content: `[Auto Context Recovery] Removed ${actualRemoveCount} messages and truncated ${truncatedCount} large outputs to stay within token limits.`,
+        });
+        // Add remaining conversation (maintaining tool call/result pairing)
+        for (const msg of keepMessages) {
+            this.messages.push(msg);
+        }
+        // Notify about pruning
+        const stats = this.contextManager?.getStats(this.messages) ?? {};
+        this.callbacks.onContextPruned?.(actualRemoveCount, {
+            ...stats,
+            method: 'emergency-recovery',
+            attempt,
+            removedPercent: reductionPercent * 100,
+            turnsRemoved: targetTurnsToRemove + startIndex,
+            truncatedOutputs: truncatedCount,
+            toolOutputLimit,
+        });
+        // Check if we're still over limit after all reductions
+        const newStats = this.contextManager?.getStats(this.messages);
+        if (newStats && newStats.percentage > 100) {
+            // Still over limit - do one more aggressive pass
+            // Truncate ALL tool outputs to absolute minimum
+            const minLimit = 200;
+            for (const msg of this.messages) {
+                if (msg.role === 'tool' && msg.content) {
+                    const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+                    if (content.length > minLimit) {
+                        msg.content = content.slice(0, minLimit) + '\n[... severely truncated ...]';
+                    }
+                }
+            }
+        }
+        return true;
+    }
+}
+function cloneMessage(message) {
+    switch (message.role) {
+        case 'assistant':
+            const clone = {
+                role: 'assistant',
+                content: message.content,
+            };
+            if (message.toolCalls) {
+                clone.toolCalls = message.toolCalls.map(cloneToolCall);
+            }
+            return clone;
+        case 'tool':
+            return {
+                role: 'tool',
+                name: message.name,
+                content: message.content,
+                toolCallId: message.toolCallId,
+            };
+        case 'system':
+            return { role: 'system', content: message.content };
+        case 'user':
+        default:
+            return { role: 'user', content: message.content };
+    }
+}
+function cloneToolCall(call) {
+    return {
+        id: call.id,
+        name: call.name,
+        arguments: { ...(call.arguments ?? {}) },
+    };
+}
+//# sourceMappingURL=agent.js.map