erosolar-cli 1.7.413 → 1.7.414

package/dist/core/agent.js

@@ -1,881 +0,0 @@
-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