@qodo/sdk 0.13.4 → 2.0.0-next.0

package/dist/api/agent.js

@@ -1,963 +0,0 @@
-import { v4 as uuid } from "uuid";
-import { EventEmitter } from "events";
-import { MCPManager } from "../mcp/index.js";
-import { SERVER_ERROR_MESSAGE } from "../constants/errors.js";
-import { getUserData, getCurrentGitSha1 } from "./utils.js";
-import { EndNode, UserResponse } from "../constants/tools.js";
-import { SessionContext } from "../session/index.js";
-import { TaskTracker } from "./taskTracking.js";
-import { ToolProcessorManager } from "../mcp/index.js";
-import process from "node:process";
-import { ServerData } from "../session/index.js";
-import { httpRequest } from "./http.js";
-import { WebSocketClient, ConnectionState } from "./websocket.js";
-import { getCurrentEnvironment } from "../session/index.js";
-// Enhanced configuration with robust defaults
-const CONFIG = {
-    REQUEST_TIMEOUT: 210000,
-    DELIMITER: "\n\n",
-    RECONNECT_ATTEMPTS: 5, // Increased from 3
-    INITIAL_RECONNECT_DELAY: 1000,
-    MAX_RECONNECT_DELAY: 30000, // Maximum 30 seconds
-    RECONNECT_BACKOFF_FACTOR: 1.5, // Exponential backoff multiplier
-    HEARTBEAT_INTERVAL: 30000,
-    HEARTBEAT_TIMEOUT: 60000, // 2x heartbeat interval
-    CONNECTION_TIMEOUT: 15000, // Increased from 10s
-    MESSAGE_QUEUE_MAX_SIZE: 1000,
-    MAX_PENDING_TOOLS: 50,
-    CIRCUIT_BREAKER_THRESHOLD: 5, // Failures before opening circuit
-    CIRCUIT_BREAKER_TIMEOUT: 60000, // 1 minute before trying again
-    IDLE_TIMEOUT: 60000, // 1 minute idle timeout before disconnecting
-    SUMMARIZATION_PREFETCH_TIMEOUT: 60000, // 60 seconds for summarization prefetch
-};
-export class AgentAPI extends EventEmitter {
-    sessionContext;
-    wsClient;
-    shouldDebugLog() {
-        const env = getCurrentEnvironment();
-        if (env?.sdkMode) {
-            return !!env.sdkDebug || process.env.QODO_DEBUG === 'true';
-        }
-        return this.sessionContext?.isDebugMode?.() || process.env.QODO_DEBUG === 'true';
-    }
-    debug(...args) {
-        if (this.shouldDebugLog()) {
-            // eslint-disable-next-line no-console
-            console.debug(...args);
-        }
-    }
-    currentSession;
-    pendingToolRequests = new Map();
-    // Tracks tool executions that are currently running (mainly relevant for auto-approved tools).
-    // Without this, the backend "Ready" signal can be misinterpreted as end-of-turn and we may
-    // emit forceStop early, which causes the CLI loading spinner to disappear while tools are still running.
-    inFlightToolCalls = new Set();
-    // Tracks tool_call_ids whose `IDERetrievalAnswer` has already been sent (or at
-    // least queued to the outbox). Used to dedupe backend re-emits of the same
-    // `ToolRequested` on Resume: if the original envelope survived the drop, the
-    // client already executed the tool; re-executing a non-idempotent MCP tool
-    // (e.g. `create_pull_request`) a second time would be a real bug.
-    answeredToolCalls = new Set();
-    latestSessionId = "";
-    lastToolId = "";
-    mcpManager;
-    taskTracker;
-    pendingResumeError = null;
-    userHasControl = false; // Track if user has control (editor is shown)
-    // Tracks the current message processing promise to avoid race conditions between
-    // message processing and Ready signal handling. Without this, the Ready signal can
-    // trigger finalization before structured_output messages are fully processed.
-    currentMessageProcessing = null;
-    constructor(sessionContext) {
-        super();
-        this.sessionContext = sessionContext;
-        this.sessionContext = sessionContext || SessionContext.getInstance();
-        // MCPManager may not be initialized when MCP is disabled via config (tools = []).
-        // In that case, gracefully operate without tools by leaving mcpManager undefined.
-        try {
-            this.mcpManager = MCPManager.getInstance();
-        }
-        catch {
-            this.mcpManager = undefined;
-        }
-        this.taskTracker = new TaskTracker(this.sessionContext, this.mcpManager);
-        // Initialize WebSocket client
-        this.wsClient = new WebSocketClient();
-        this.setupWebSocketHandlers();
-        // Don't pre-fetch session ID - use the session ID provided by operations
-        // Listen for network connectivity changes if available
-        this.setupNetworkListeners();
-    }
-    async ensureConnected(sessionId, requestId) {
-        try {
-            let finalSessionId = sessionId;
-            // Only fetch a session ID from server if none is provided
-            if (!finalSessionId) {
-                if (!this.latestSessionId) {
-                    const serverData = ServerData.getInstance();
-                    this.latestSessionId = await serverData.fetchNewSessionId();
-                    this.debug(`Fetched new session ID from server: ${this.latestSessionId}`);
-                }
-                finalSessionId = this.latestSessionId;
-            }
-            else {
-                // Update stored session ID with the provided one
-                this.latestSessionId = sessionId;
-            }
-            await this.wsClient.connect(finalSessionId, requestId);
-            this.debug('WebSocket connected for session:', finalSessionId);
-        }
-        catch (error) {
-            this.debug('WebSocket connection failed:', error);
-            throw error;
-        }
-    }
-    setupWebSocketHandlers() {
-        // Handle incoming messages
-        // IMPORTANT: Track the promise to ensure message processing completes before
-        // Ready signal triggers finalization. This prevents race conditions where
-        // structured_output messages are received but not yet processed when Ready arrives.
-        this.wsClient.on('message', (message) => {
-            this.currentMessageProcessing = this.handleWebSocketMessage(message).finally(() => {
-                this.currentMessageProcessing = null;
-            });
-        });
-        // Handle connection state changes
-        this.wsClient.on('stateChanged', (newState) => {
-            this.debug('WebSocket state changed to:', newState);
-            this.emit('connectionStateChanged', newState);
-        });
-        this.wsClient.on('disconnected', (info) => {
-            this.debug('WebSocket disconnected:', info.reason);
-            // Handle pending operations
-            if (info.reason !== 'idle' && info.reason !== 'normal') {
-                this.handleUnexpectedDisconnection();
-            }
-        });
-        this.wsClient.on('error', (error) => {
-            this.debug('WebSocket error:', error);
-            this.handleWebSocketError(error);
-        });
-        // Handle Ready protocol events
-        this.wsClient.on('readyReceived', async (checkpointId, previousReadyState) => {
-            this.debug('[AgentAPI] Server ready for next message', checkpointId ? `| Checkpoint: ${checkpointId.substring(0, 8)}` : '');
-            // IMPORTANT:
-            // Some backend flows may not emit an explicit EndNode/forceStop message.
-            // Historically we treated the WebSocket "Ready" signal as an end-of-turn indicator.
-            // However, during tool-use the backend may send "Ready" to signal it is ready to receive
-            // tool answers (IDERetrievalAnswer) rather than the assistant being done producing output.
-            //
-            // To avoid prematurely finalizing runs (especially with YOLO/always where tools are auto-approved),
-            // we apply a stricter heuristic:
-            // - only finalize when Ready arrives after a UserQuery (MESSAGE_SENT)
-            // - AND there are no approval prompts pending
-            // - AND there are no tool executions currently in-flight (auto-approved tools)
-            // - AND the WebSocket client has observed at least one non-Ready response since the UserQuery
-            //   (otherwise this Ready can be part of an intermediate tool handshake)
-            try {
-                // Wait for any in-flight message processing to complete before checking finalization.
-                // This prevents race conditions where structured_output messages are received but
-                // haven't been processed yet when the Ready signal arrives.
-                if (this.currentMessageProcessing) {
-                    this.debug('[AgentAPI] Waiting for in-flight message processing before handling Ready');
-                    await this.currentMessageProcessing;
-                }
-                // After awaiting in-flight processing, re-check the WebSocket ready state.
-                // If a tool response (IDERetrievalAnswer) was sent while we waited, the state
-                // will have transitioned back to MESSAGE_SENT — meaning we're now waiting for
-                // the backend to process the tool result and should NOT finalize.
-                const currentReadyState = this.wsClient.getReadyState?.();
-                if (currentReadyState === 'MESSAGE_SENT') {
-                    this.debug('[AgentAPI] Tool response sent during wait — skipping finalization, awaiting backend response');
-                    return;
-                }
-                const hasResponses = this.wsClient.hasReceivedResponsesSinceLastMessage?.() === true;
-                if (this.currentSession?.waitingForResponse &&
-                    this.pendingToolRequests.size === 0 &&
-                    this.inFlightToolCalls.size === 0 &&
-                    previousReadyState === 'MESSAGE_SENT' &&
-                    hasResponses) {
-                    this.currentSession.waitingForResponse = false;
-                    await this.responseCallback({ forceStop: true });
-                }
-            }
-            catch (readyErr) {
-                this.debug('[AgentAPI] Error during Ready handler finalization check:', readyErr);
-            }
-        });
-        this.wsClient.on('checkpointRecovery', (info) => {
-            this.debug('[AgentAPI] Checkpoint recovery initiated', `| Reason: ${info.reason}`, info.checkpoint ? `| Checkpoint: ${info.checkpoint.substring(0, 8)}` : '');
-        });
-        this.wsClient.on('readyStateChanged', (info) => {
-            if (this.sessionContext?.isDebugMode()) {
-                this.debug('[AgentAPI] Ready state changed:', info);
-            }
-        });
-    }
-    setupNetworkListeners() {
-        // Node.js doesn't have built-in network change detection
-        // This could be enhanced with platform-specific implementations
-        if (typeof window !== 'undefined') {
-            window.addEventListener('online', () => this.handleNetworkOnline());
-            window.addEventListener('offline', () => this.handleNetworkOffline());
-        }
-    }
-    handleNetworkOnline() {
-        this.debug('Network connectivity restored');
-        if (this.wsClient.getState() === ConnectionState.FAILED && this.currentSession) {
-            // WebSocket client will handle reconnection automatically
-            this.debug('Network restored, WebSocket client will auto-reconnect');
-        }
-    }
-    handleNetworkOffline() {
-        this.debug('Network connectivity lost');
-        // WebSocket client will detect and handle the disconnection
-    }
-    getConnectionState() {
-        return this.wsClient.getState();
-    }
-    onConnectionStateChange(callback) {
-        this.on('connectionStateChanged', callback);
-        return () => this.off('connectionStateChanged', callback);
-    }
-    /**
-     * Protocol-v2 transport metrics. Delegates to the underlying WebSocket client.
-     * Safe to call at any time; values are a point-in-time snapshot.
-     */
-    getTransportMetrics() {
-        try {
-            return { ...(this.wsClient.getMetrics?.() ?? {}) };
-        }
-        catch {
-            return {};
-        }
-    }
-    /**
-     * Subscribe to protocol-v2 transport lifecycle events.
-     *
-     * The SDK's own stream layer uses this to surface `Reconnecting`,
-     * `Reconnected`, `ResumeReconciled`, `ReconcileFailed`, and `StallDetected`
-     * events with proper envelopes. External callers can also subscribe for
-     * fine-grained observability without touching the WebSocketClient directly.
-     */
-    onTransportEvent(handlers) {
-        const cleanups = [];
-        const bind = (name, fn) => {
-            if (!fn)
-                return;
-            const wrapped = (...args) => { try {
-                fn(...args);
-            }
-            catch { /* listener errors must not bubble */ } };
-            this.wsClient.on(name, wrapped);
-            cleanups.push(() => this.wsClient.off(name, wrapped));
-        };
-        bind('reconnecting', handlers.reconnecting);
-        bind('reconnected', handlers.reconnected);
-        bind('resumeAck', handlers.resumeAck);
-        bind('reconcileFailed', handlers.reconcileFailed);
-        bind('stallDetected', handlers.stallDetected);
-        return () => { for (const c of cleanups)
-            c(); };
-    }
-    handleWebSocketError(error) {
-        // Handle WebSocket errors
-        this.debug('WebSocket error handled:', error);
-        // Forward all errors during an active session - including connection failures
-        // during initial handshake (before waitingForResponse is set)
-        if (this.currentSession) {
-            this.handleError(error);
-        }
-    }
-    async handleUnexpectedDisconnection() {
-        try {
-            // If a tool approval is pending, keep the approval prompt active and do nothing here
-            if (this.pendingToolRequests.size > 0) {
-                return;
-            }
-            if (this.currentSession?.waitingForResponse) {
-                this.currentSession.waitingForResponse = false;
-                // Finish task when returning control due to WebSocket close
-                await this.taskTracker.trackTaskFinish(false);
-                await this.responseCallback({ forceStop: true });
-            }
-        }
-        catch (e) {
-            // Best-effort; ignore errors here
-        }
-    }
-    setUserHasControl(hasControl) {
-        const previousControl = this.userHasControl;
-        this.userHasControl = hasControl;
-        if (hasControl && !previousControl) {
-            // User is getting control back - finish the current task only if there's an active tracking
-            if (this.taskTracker.hasActiveTracking()) {
-                this.taskTracker.trackTaskFinish(false).catch(error => {
-                    this.debug('Error finishing task:', error);
-                });
-            }
-            // Keep WebSocket alive when user has control
-            this.wsClient.keepAlive();
-        }
-    }
-    resetActivityTimer() {
-        // Public method to keep the connection alive when user is active
-        this.wsClient.keepAlive();
-    }
-    async toolApproval(identifier, approved) {
-        const pendingToolData = this.pendingToolRequests.get(identifier);
-        if (!pendingToolData) {
-            return;
-        }
-        // Check pending tool limits
-        if (this.pendingToolRequests.size > CONFIG.MAX_PENDING_TOOLS) {
-            this.debug(`Too many pending tools (${this.pendingToolRequests.size}), cleaning up oldest`);
-            this.cleanupOldestPendingTools();
-        }
-        this.currentSession = pendingToolData.agentSession;
-        this.currentSession.abortController = new AbortController();
-        if (approved) {
-            await this.callTool(pendingToolData.toolData);
-        }
-        else {
-            await this.handleToolDecline(pendingToolData.toolData);
-        }
-        this.pendingToolRequests.delete(identifier);
-    }
-    cleanupOldestPendingTools() {
-        // Remove oldest pending tools if we exceed the limit
-        const entries = Array.from(this.pendingToolRequests.entries());
-        const toRemove = entries.slice(0, entries.length - CONFIG.MAX_PENDING_TOOLS + 10); // Remove 10 extra
-        for (const [id] of toRemove) {
-            this.pendingToolRequests.delete(id);
-        }
-    }
-    async tryPrefetchSummarization(sessionIds, taskFocus) {
-        const summaries = {};
-        try {
-            if (!Array.isArray(sessionIds) || sessionIds.length === 0) {
-                return summaries;
-            }
-            await Promise.allSettled(sessionIds.map(async (sid) => {
-                try {
-                    const res = await httpRequest({
-                        method: "POST",
-                        url: "v2/agentic/get-session-summarization",
-                        data: { session_id: sid, request_id: uuid(), agent_type: "sdk", ...(taskFocus ? { task_focus: taskFocus } : {}) },
-                        timeout: CONFIG.SUMMARIZATION_PREFETCH_TIMEOUT * 2
-                    });
-                    const summary = typeof res?.summary === 'string' ? res.summary.trim() : '';
-                    if (summary) {
-                        summaries[sid] = summary;
-                    }
-                }
-                catch (e) {
-                    if (this.sessionContext?.isDebugMode()) {
-                        this.debug('Summarization prefetch failed for', sid, e instanceof Error ? e.message : e);
-                    }
-                }
-            }));
-            return summaries;
-        }
-        catch (e) {
-            if (this.sessionContext?.isDebugMode()) {
-                this.debug('Summarization prefetch failed:', e instanceof Error ? e.message : e);
-            }
-            return summaries;
-        }
-    }
-    async resumeTask(agentSession) {
-        try {
-            this.latestSessionId = agentSession.sessionId;
-            await this.initializeTask(agentSession);
-            // Ensure connected with correct session ID
-            await this.ensureConnected(agentSession.sessionId, agentSession.requestId);
-            await this.sendUserQuery();
-        }
-        catch (error) {
-            await this.handleError(error);
-        }
-    }
-    async startTask(agentSession) {
-        try {
-            // Reset idle timer when starting a new task
-            this.resetActivityTimer();
-            this.latestSessionId = agentSession.sessionId;
-            await this.initializeTask(agentSession);
-            // Ensure connected with correct session ID
-            await this.ensureConnected(agentSession.sessionId, agentSession.requestId);
-            // Send the task request
-            await this.sendUserQuery();
-        }
-        catch (error) {
-            await this.handleError(error);
-        }
-    }
-    async finishCurrentTask(isError = false) {
-        await this.taskTracker.trackTaskFinish(isError);
-    }
-    collectBaseData() {
-        // Get accessible paths from session context
-        const accessiblePaths = this.sessionContext.getAccessiblePaths();
-        const command = this.currentSession?.command || this.sessionContext.getCommand();
-        const execCwd = this.sessionContext?.getExecutionCwd?.();
-        const baseData = {
-            projects_root_path: accessiblePaths,
-            cwd: execCwd || accessiblePaths[0],
-        };
-        const prev = this.sessionContext.getPreviousSessionsSummarization();
-        if (prev && prev.length > 0) {
-            const sections = prev.map((item, i) => {
-                const sessionId = typeof item === 'string' ? String(i + 1) : item.sessionId;
-                const summary = typeof item === 'string' ? item : item.summary;
-                return `### Session ${sessionId}\n${(summary || '').trim()}`;
-            });
-            baseData.previous_sessions_summarization = sections.join('\n\n---\n\n');
-        }
-        if (command.instructions || this.sessionContext.getGeneralInstructions()) {
-            baseData.instructions = command.instructions || this.sessionContext.getGeneralInstructions();
-        }
-        if (this.sessionContext.getSystemPrompt()) {
-            baseData.system_prompt = this.sessionContext.getSystemPrompt();
-        }
-        return baseData;
-    }
-    async initializeTask(agentSession) {
-        this.currentSession = agentSession;
-        this.currentSession.abortController = new AbortController();
-    }
-    cancelCurrentSession() {
-        this.requestCancellation();
-    }
-    requestCancellation() {
-        this.debug('requestCancellation called - aborting session and disconnecting WebSocket');
-        // Use AbortController for atomic cancellation state management
-        if (this.currentSession?.abortController && !this.currentSession?.abortController.signal.aborted) {
-            this.currentSession?.abortController.abort();
-            this.debug('AbortController signal sent');
-        }
-        // Disconnect and reconnect WebSocket to stop any ongoing communication
-        this.disconnectAndReconnect();
-    }
-    disconnectAndReconnect() {
-        try {
-            this.debug('Disconnecting and reconnecting WebSocket due to cancellation');
-            this.wsClient.disconnect();
-            // Reconnect will happen automatically when the next request is made
-        }
-        catch (error) {
-            this.debug('Error during disconnect/reconnect:', error);
-        }
-    }
-    async checkCancellation() {
-        // Use AbortController signal for atomic cancellation state checking
-        if (this.currentSession?.abortController?.signal.aborted) {
-            await this.handleCancellation();
-            return true;
-        }
-        return false;
-    }
-    async handleCancellation() {
-        // Finish task tracking before sending stop signal
-        await this.taskTracker.trackTaskFinish(true);
-        // Send stop signal
-        await this.responseCallback({
-            forceStop: true
-        });
-        // WebSocket stays connected for potential new requests
-    }
-    async sendUserQuery() {
-        if (!this.currentSession)
-            return;
-        const data = this.currentSession.data || {};
-        // Track task start when actually sending user request to backend
-        if (this.taskTracker.shouldTrackUserRequest(data)) {
-            // Initialize tracking for this user turn
-            this.taskTracker.initializeTaskTracking(this.currentSession);
-        }
-        // Prepare base data first so we can merge/inject instructions properly
-        const baseData = this.collectBaseData();
-        const command = this.currentSession.command || this.sessionContext.getCommand();
-        if (command?.output_schema) {
-            data.output_schema = command.output_schema;
-        }
-        const flags = this.sessionContext.getFlags();
-        if (flags?.max_iterations) {
-            data.max_iterations = flags.max_iterations;
-        }
-        if (this.sessionContext.getExecutionStrategy()) {
-            data.execution_strategy = this.sessionContext.getExecutionStrategy();
-        }
-        if (this.sessionContext.getQodoMd()) {
-            data.qodomd = this.sessionContext.getQodoMd();
-        }
-        data.custom_model = this.sessionContext.getModel();
-        const enabledToolsMap = this.mcpManager?.getEnabledTools(this.sessionContext.getAvailableTools(), this.sessionContext.getIgnoreTools());
-        // SDK client always uses agent_type: "sdk"
-        // Interactive mode is opt-in via flags
-        const interactiveMode = flags?.interactiveMode === true;
-        const requestData = {
-            agent_type: "sdk",
-            session_id: this.currentSession.sessionId,
-            user_data: getUserData(),
-            git_sha1: await getCurrentGitSha1(),
-            tools: this.mcpManager && enabledToolsMap ? Object.fromEntries(enabledToolsMap) : {},
-            permissions: this.sessionContext.getPermissions(),
-            interactive_mode: interactiveMode,
-            ...baseData,
-            ...data,
-        };
-        // Debug snapshot for UserQuery tools
-        try {
-            const perServerCounts = Object.fromEntries(Object.entries(requestData.tools || {}).map(([srv, arr]) => [srv, Array.isArray(arr) ? arr.length : 0]));
-            const totalTools = Object.values(requestData.tools || {}).reduce((acc, v) => acc + (Array.isArray(v) ? v.length : 0), 0);
-            this.debug('[AgentAPI] UserQuery tools snapshot:', { servers: Object.keys(requestData.tools || {}), perServerCounts, totalTools });
-        }
-        catch (e) {
-            this.debug('[AgentAPI] Failed to log UserQuery tools snapshot:', e instanceof Error ? e.message : e);
-        }
-        this.currentSession.waitingForResponse = true;
-        this.currentSession.lastPacketTimestamp = Date.now();
-        // Send via WebSocket client with new protocol format
-        try {
-            await this.wsClient.sendMessage('UserQuery', requestData);
-        }
-        catch (error) {
-            console.error('Error sending UserQuery message:', error);
-            await this.handleError(error);
-        }
-    }
-    async handleWebSocketMessage(message) {
-        try {
-            await this.processMessage(message);
-        }
-        catch (error) {
-            console.error('Error processing WebSocket message:', error);
-            await this.handleError(error);
-        }
-    }
-    async processMessage(message) {
-        if (await this.checkCancellation()) {
-            return;
-        }
-        // Update last packet timestamp
-        if (this.currentSession) {
-            this.currentSession.lastPacketTimestamp = Date.now();
-        }
-        try {
-            const data = JSON.parse(message);
-            // Handle backend error envelope: { error: string, message: string }
-            if (data && typeof data === 'object' && 'error' in data && 'message' in data) {
-                try {
-                    await this.responseCallback({ error: String(data.message) });
-                    // Only force return to input if no tool approvals are pending
-                    if (this.pendingToolRequests.size === 0) {
-                        await this.taskTracker.trackTaskFinish(true);
-                        await this.responseCallback({ forceStop: true });
-                    }
-                }
-                catch (e) {
-                    console.error('Error handling backend error message:', e);
-                }
-                return;
-            }
-            this.wsClient.startReadyTimer();
-            await this.handleTaskResponse(data);
-        }
-        catch (error) {
-            // Don't process errors if we have a pending resume error
-            if (this.pendingResumeError) {
-                return;
-            }
-            throw new Error("Failed to process message");
-        }
-    }
-    async handleTaskResponseError(response) {
-        if (response.type === "error" && this.currentSession) {
-            // Extract error message from either response.message or response.data.tool_args.content
-            let errorMessage;
-            if (response.message) {
-                errorMessage = response.message;
-            }
-            else if (response.data && typeof response.data === 'object') {
-                const data = response.data;
-                if (data.tool === "UserResponse" && data.tool_args?.content) {
-                    errorMessage = data.tool_args.content;
-                }
-            }
-            if (errorMessage) {
-                // Check if this is a "resume" error that should be retried
-                if (errorMessage.toLowerCase().includes("resume")) {
-                    // Store the error to be thrown after stream completes
-                    this.pendingResumeError = new Error(errorMessage);
-                    return true;
-                }
-                // Send the error message
-                await this.responseCallback({
-                    error: errorMessage,
-                });
-                // Track task finish with error before sending stop signal
-                await this.taskTracker.trackTaskFinish(true);
-                // Send stop signal
-                await this.responseCallback({
-                    forceStop: true,
-                });
-                return true;
-            }
-        }
-        return false;
-    }
-    async handleTaskResponse(response) {
-        // Check for cancellation at the start of processing each response
-        this.debug("Processing task response:", response);
-        if (await this.checkCancellation()) {
-            return;
-        }
-        if (await this.handleTaskResponseError(response)) {
-            return;
-        }
-        if (!this.isValidTaskResponse(response)) {
-            return;
-        }
-        const toolData = response.data;
-        // Ensure identifier is always set
-        if (!toolData.identifier) {
-            if (toolData.tool === UserResponse && this.lastToolId) {
-                toolData.identifier = this.lastToolId;
-            }
-            else {
-                const newId = uuid();
-                toolData.identifier = newId;
-                if (toolData.tool === UserResponse) {
-                    this.lastToolId = newId;
-                }
-            }
-        }
-        else if (toolData.tool !== UserResponse) {
-            this.lastToolId = "";
-        }
-        switch (toolData.tool) {
-            case UserResponse:
-                await this.responseCallback({ toolData });
-                break;
-            case EndNode:
-                await this.handleEndNode();
-                break;
-            default:
-                await this.handleToolExecution(toolData);
-        }
-    }
-    isValidTaskResponse(response) {
-        return Boolean(response?.session_id && response?.data && response.data?.tool);
-    }
-    async responseCallback(response) {
-        if (!this.currentSession) {
-            return;
-        }
-        try {
-            this.currentSession.userEngagementCallback(response);
-        }
-        catch (error) {
-            console.error("Error in responseCallback:", error);
-        }
-    }
-    async handleEndNode() {
-        // Track task finish before sending stop signal
-        await this.taskTracker.trackTaskFinish(false);
-        // Notify UI layer to finalize any accumulated responses
-        await this.responseCallback({
-            forceStop: true
-        });
-        // Don't automatically start idle timer here - it will be started when user gets control
-        // This allows the connection to stay open for potential new requests
-    }
-    async handleToolExecution(toolData) {
-        // Check for cancellation before executing tools
-        if (await this.checkCancellation()) {
-            return;
-        }
-        if (!toolData.server_name) {
-            return;
-        }
-        // Ensure identifier is set for all tool executions
-        toolData.identifier ??= uuid();
-        toolData.session_id ??= this.currentSession?.sessionId || "";
-        if (toolData.tool_result) {
-            await this.processToolResponse(toolData, toolData.tool_result);
-            return;
-        }
-        // Dedupe against backend re-emits of the same ToolRequested on Resume.
-        // The backend replays the pending tool call on reconnect so clients that
-        // missed the original streamed event can still execute it. If the original
-        // did survive, running it a second time would double-fire non-idempotent
-        // MCP tools. `pendingToolRequests` covers manual-approval tools waiting
-        // for user input, `inFlightToolCalls` covers auto-approved tools mid-exec,
-        // and `answeredToolCalls` covers tools whose result has already been sent.
-        const id = toolData.identifier;
-        if (this.pendingToolRequests.has(id) || this.inFlightToolCalls.has(id) || this.answeredToolCalls.has(id)) {
-            this.debug('[AgentAPI] Duplicate ToolRequested ignored (already pending/in-flight/answered):', id);
-            return;
-        }
-        const { tool_reasoning, ...restArgs } = toolData.tool_args;
-        toolData.tool_args = restArgs;
-        toolData.tool_reasoning = tool_reasoning ? tool_reasoning : "";
-        try {
-            // If MCP is disabled entirely, decline tool execution immediately with a friendly message.
-            if (!this.mcpManager) {
-                await this.handleToolDecline(toolData, 'This agent was configured with `tools = []`, so no MCP tools are available.');
-                return;
-            }
-            const isAutoApprovedTool = this.mcpManager.isAutoApprovedTool(toolData.server_name, toolData.tool, toolData.tool_args);
-            const processedToolData = await ToolProcessorManager.getInstance().preProcessTool(toolData, this.sessionContext);
-            await this.processToolReasoning(processedToolData, isAutoApprovedTool);
-            // Dry run: simulate tool execution without side effects
-            if (this.sessionContext?.isDryRun()) {
-                const dryResult = await ToolProcessorManager.getInstance().dryRunTool(processedToolData, this.sessionContext);
-                await this.processToolResponse(processedToolData, dryResult);
-                await this.sendToolResponse(processedToolData, dryResult);
-            }
-            else if (isAutoApprovedTool) {
-                await this.callTool(processedToolData);
-            }
-            else {
-                this.setUserHasControl(true);
-                this.pendingToolRequests.set(processedToolData.identifier, {
-                    agentSession: this.currentSession,
-                    toolData: processedToolData,
-                });
-            }
-        }
-        catch (error) {
-            console.error("Error in tool execution:", error);
-        }
-    }
-    async handleToolDecline(toolData, reason = 'User declined tool execution') {
-        const answer = {
-            isError: true,
-            content: [{ type: "text", text: reason }],
-        };
-        if (this.currentSession) {
-            await this.processToolResponse(toolData, answer);
-            // Send tool response via WebSocket
-            await this.sendToolResponse(toolData, answer);
-        }
-    }
-    async callTool(toolData) {
-        // Check for cancellation before calling tool
-        if (await this.checkCancellation()) {
-            return;
-        }
-        const toolCallId = toolData.identifier ?? uuid();
-        toolData.identifier = toolCallId;
-        this.inFlightToolCalls.add(toolCallId);
-        try {
-            this.debug("Calling tool:", toolData.tool, "on server:", toolData.server_name);
-            // Track the tool execution
-            this.taskTracker.trackToolExecution(toolData.server_name, toolData.tool);
-            // If shell_execute or ripgrep_search without cwd, default to session execution CWD if configured.
-            // Also, for git tools, default repo_path to execution CWD when not provided. This gives
-            // in-process SDK sessions (which set an explicit cwd) consistent behavior across built-ins.
-            let patchedArgs = toolData.tool_args;
-            try {
-                const execCwd = this.sessionContext?.getExecutionCwd?.();
-                if (execCwd) {
-                    const hasCwd = patchedArgs && typeof patchedArgs === 'object' && 'cwd' in patchedArgs && patchedArgs.cwd;
-                    const isShell = toolData.server_name === 'shell' && toolData.tool === 'shell_execute';
-                    const isRipgrep = toolData.server_name === 'ripgrep' && toolData.tool === 'ripgrep_search';
-                    if (!hasCwd && (isShell || isRipgrep)) {
-                        patchedArgs = { ...(patchedArgs || {}), cwd: execCwd };
-                    }
-                    // Git tools expect a repo_path; when omitted, treat the execution CWD as the repo root.
-                    const needsRepoPath = toolData.server_name === 'git'
-                        && (!patchedArgs || typeof patchedArgs.repo_path !== 'string' || !patchedArgs.repo_path);
-                    if (needsRepoPath) {
-                        patchedArgs = { ...(patchedArgs || {}), repo_path: execCwd };
-                    }
-                }
-            }
-            catch { /* best-effort: tool arg patching should not block tool execution */ }
-            if (!this.mcpManager) {
-                // Should not be reachable because we guard earlier, but keep a safe fallback
-                // that gracefully declines the tool call instead of throwing.
-                await this.handleToolDecline(toolData, 'This agent was configured with `tools = []`, so no MCP tools are available.');
-                return;
-            }
-            const result = await this.mcpManager.callTool(toolData.server_name, toolData.tool, patchedArgs);
-            this.debug("Tool execution result:", result?.isError ? "Error" : "Success");
-            // Track code blocks for filesystem modifications
-            if (toolData.server_name.toLowerCase() === "filesystem" && result && !result.isError) {
-                this.taskTracker.trackFileSystemChanges(toolData.tool, toolData.tool_args, result);
-            }
-            if (result && this.currentSession) {
-                try {
-                    const response = result
-                        ? result
-                        : { isError: true, content: [{ type: "text", text: "Unknown error occurred" }] };
-                    if (await this.checkCancellation()) {
-                        return;
-                    }
-                    // Post-process the tool result
-                    const processedResponse = await ToolProcessorManager.getInstance().postProcessTool(toolData, response);
-                    await this.processToolResponse(toolData, processedResponse);
-                    // Send tool response via WebSocket
-                    await this.sendToolResponse(toolData, processedResponse);
-                }
-                catch (error) {
-                    const errorResponse = {
-                        isError: true,
-                        content: [{ type: "text", text: "Unknown error occurred" }],
-                    };
-                    await this.processToolResponse(toolData, errorResponse);
-                    await this.sendToolResponse(toolData, errorResponse);
-                }
-            }
-        }
-        catch (error) {
-            this.debug("Error in tool execution:", error);
-            const errorResponse = {
-                isError: true,
-                content: [{ type: "text", text: error instanceof Error ? error.message : "Unknown error occurred" }],
-            };
-            await this.processToolResponse(toolData, errorResponse);
-            await this.sendToolResponse(toolData, errorResponse);
-        }
-        finally {
-            this.inFlightToolCalls.delete(toolCallId);
-        }
-    }
-    async sendToolResponse(toolData, response) {
-        try {
-            if (!this.currentSession) {
-                console.error('No current session available for tool response');
-                return;
-            }
-            this.setUserHasControl(false);
-            // Create IDERetrievalAnswer format - SDK client always uses agent_type: "sdk"
-            const ideAnswer = {
-                tool: toolData.tool,
-                tool_id: toolData.identifier,
-                answer: response,
-                tools: this.convertToolsForIDE(),
-                user_data: getUserData(),
-                agent_type: "sdk"
-            };
-            // Debug snapshot for IDERetrievalAnswer tools
-            try {
-                const toolsAny = ideAnswer.tools;
-                if (Array.isArray(toolsAny?.IDETool)) {
-                    const arr = toolsAny.IDETool;
-                    const sample = arr.slice(0, 3).map((t) => t?.name || t?.tool || '[unknown]');
-                    this.debug('[AgentAPI] IDERetrievalAnswer tools snapshot (array form):', { count: arr.length, sample });
-                }
-                else if (toolsAny && typeof toolsAny === 'object') {
-                    const perServerCounts = Object.fromEntries(Object.entries(toolsAny).map(([srv, arr]) => [srv, Array.isArray(arr) ? arr.length : 0]));
-                    const totalTools = Object.values(toolsAny).reduce((acc, v) => acc + (Array.isArray(v) ? v.length : 0), 0);
-                    this.debug('[AgentAPI] IDERetrievalAnswer tools snapshot (map form):', { servers: Object.keys(toolsAny), perServerCounts, totalTools });
-                }
-                else {
-                    this.debug('[AgentAPI] IDERetrievalAnswer tools snapshot: tools is empty or invalid');
-                }
-            }
-            catch (e) {
-                this.debug('[AgentAPI] Failed to log IDERetrievalAnswer tools snapshot:', e instanceof Error ? e.message : e);
-            }
-            // Send via WebSocket client with new protocol format
-            await this.wsClient.sendMessage('IDERetrievalAnswer', ideAnswer);
-            // Record the answered tool_call so a backend Resume-time re-emit of
-            // the same ToolRequested doesn't trigger a second execution.
-            if (toolData.identifier) {
-                this.answeredToolCalls.add(toolData.identifier);
-            }
-            this.debug('Tool response sent via WebSocket client');
-        }
-        catch (error) {
-            console.error('Error sending tool response:', error);
-            // Only handle error if we're not already in an error state
-            if (this.currentSession?.waitingForResponse) {
-                await this.handleError(error);
-            }
-        }
-    }
-    convertToolsForIDE() {
-        // For IDERetrievalAnswer the backend expects a ToolType-keyed dict.
-        // Use 'IDETool' with a flat array of tools.
-        const enabledTools = this.mcpManager?.getEnabledTools(this.sessionContext.getAvailableTools(), this.sessionContext.getIgnoreTools());
-        // Debug: inspect enabled tools map content before conversion
-        try {
-            const isMap = enabledTools instanceof Map;
-            const serverCount = isMap ? enabledTools.size : 0;
-            const serverNames = isMap ? Array.from(enabledTools.keys()) : [];
-            const perServerCounts = isMap ? Object.fromEntries(Array.from(enabledTools.entries()).map(([k, v]) => [k, Array.isArray(v) ? v.length : 0])) : {};
-            const flattenedCount = isMap ? Array.from(enabledTools.values()).flat().length : 0;
-            this.debug('[AgentAPI] convertToolsForIDE (to IDETool array):', { isMap, serverCount, serverNames, perServerCounts, flattenedCount });
-        }
-        catch (e) {
-            this.debug('[AgentAPI] convertToolsForIDE: failed to log enabled tools map:', e instanceof Error ? e.message : e);
-        }
-        const ideTools = enabledTools ? Array.from(enabledTools.values()).flat() : [];
-        return { IDETool: ideTools };
-    }
-    async processToolReasoning(toolData, isAutoApprovedTool) {
-        if (!this.currentSession) {
-            return;
-        }
-        await this.responseCallback({
-            toolData: {
-                ...toolData,
-                ...(!isAutoApprovedTool ? { pending_approval: true } : {}),
-            }
-        });
-    }
-    async processToolResponse(toolData, toolResult) {
-        await this.responseCallback({
-            toolData: { ...toolData, tool_result: toolResult },
-        });
-    }
-    async handleError(error) {
-        if (this.currentSession) {
-            this.currentSession.waitingForResponse = false;
-        }
-        let message = error instanceof Error ? error.message : "Unknown error occurred";
-        // Handle different types of cancellation/abort errors
-        if (error instanceof Error) {
-            if (error.name === "AbortError" || error.name === "CanceledError") {
-                // Check if this was a user-initiated cancellation vs timeout
-                if (this.currentSession?.abortController?.signal.aborted) {
-                    return;
-                }
-                else {
-                    message = "Request Timeout";
-                }
-            }
-        }
-        await this.responseCallback({
-            error: message || SERVER_ERROR_MESSAGE,
-        });
-        // Finish task tracking before terminating session
-        await this.taskTracker.trackTaskFinish(true);
-        // Terminate session after error
-        await this.responseCallback({
-            forceStop: true,
-        });
-    }
-    // Enhanced cleanup method with comprehensive resource management
-    cleanupConnections() {
-        this.wsClient.cleanup();
-    }
-    // Complete cleanup method
-    cleanup() {
-        try {
-            this.cleanupConnections();
-        }
-        catch { /* cleanup: connection teardown must not throw */ }
-        this.pendingToolRequests.clear();
-        this.answeredToolCalls.clear();
-        this.currentSession = undefined;
-        this.latestSessionId = "";
-    }
-    // Get the task tracker instance
-    getTaskTracker() {
-        return this.taskTracker;
-    }
-}
-//# sourceMappingURL=agent.js.map