@qodo/sdk 0.1.0

package/dist/api/agent.js

@@ -0,0 +1,1034 @@
+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();
+    latestSessionId = "";
+    lastToolId = "";
+    mcpManager;
+    taskTracker;
+    pendingResumeError = null;
+    hotStartInProgress = false;
+    userHasControl = false; // Track if user has control (editor is shown)
+    // IPC bridge for sub-process orchestration
+    ipcBridge = 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();
+        // In subprocess mode, set up IPC bridge for tool approvals and inherited approvals
+        if (process.env.QODO_SUBPROCESS_MODE === 'true') {
+            try {
+                // Dynamic import without await (constructor cannot be async)
+                // @ts-ignore
+                import('../orchestrator/subprocessIpcBridge.js').then((mod) => {
+                    try {
+                        this.ipcBridge = new mod.SubprocessIpcBridge(this.mcpManager);
+                    }
+                    catch { }
+                }).catch(() => { });
+            }
+            catch { }
+        }
+    }
+    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
+        this.wsClient.on('message', (message) => {
+            this.handleWebSocketMessage(message);
+        });
+        // 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 {
+                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 { }
+        });
+        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);
+    }
+    handleWebSocketError(error) {
+        // Handle WebSocket errors
+        this.debug('WebSocket error handled:', error);
+        // The WebSocketClient will handle reconnection, we just need to handle the business logic
+        if (this.currentSession?.waitingForResponse) {
+            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: "cli", ...(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 startHotTask(agentSession) {
+        try {
+            this.debug("Starting hot task with session:", agentSession.sessionId);
+            // Reset idle timer when starting a hot task
+            this.resetActivityTimer();
+            await this.initializeTask(agentSession);
+            // Ensure connected (will update session ID if needed)
+            await this.ensureConnected(agentSession.sessionId, agentSession.requestId);
+            this.hotStartInProgress = true;
+            this.debug('Hot task initialized, waiting for user input');
+        }
+        catch (error) {
+            await this.handleError(error);
+        }
+    }
+    async sendHotStartUserRequest(userRequest, images) {
+        if (this.wsClient.getState() !== ConnectionState.CONNECTED) {
+            // Try to connect if not connected
+            await this.ensureConnected();
+        }
+        try {
+            // Reset idle timer when sending user request
+            this.resetActivityTimer();
+            this.setUserHasControl(false);
+            // Update current session with the user request
+            if (this.currentSession) {
+                this.currentSession.abortController = new AbortController();
+                this.currentSession.data = {
+                    ...this.currentSession.data,
+                    user_request: userRequest,
+                    answer: undefined,
+                    ...(images && images.length > 0 && { images })
+                };
+                this.latestSessionId = this.currentSession.sessionId;
+            }
+            // Mark hot start as complete and send the full request data
+            this.hotStartInProgress = false;
+            await this.sendUserQuery();
+        }
+        catch (error) {
+            console.error('Error sending hot start user request:', error);
+            await this.handleError(error);
+        }
+    }
+    async finishCurrentTask(isError = false) {
+        await this.taskTracker.trackTaskFinish(isError);
+    }
+    collectBaseData() {
+        // Get project root paths from session context
+        const projectRootPaths = this.sessionContext.getProjectRootPaths();
+        const command = this.currentSession?.command || this.sessionContext.getCommand();
+        const execCwd = this.sessionContext?.getExecutionCwd?.();
+        const baseData = {
+            projects_root_path: projectRootPaths,
+            cwd: execCwd || (Array.isArray(projectRootPaths) && projectRootPaths.length > 0 ? projectRootPaths[0] : process.cwd()),
+        };
+        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();
+        // Inject special instruction for subprocess user input when enabled
+        try {
+            if (process.env.QODO_SUBPROCESS_MODE === 'true') {
+                const inject = [
+                    '## IMPORTANT NOTE ##',
+                    'You are running in CI, which means you are not allowed, and cannot ask the user any questions, and you must not wait for user input. You must complete the task without any user interaction.',
+                    "Try to make educated guesses based on the information you have, and use the tools available to you to gather more information.",
+                    "If you cannot complete the task, you must return an error message that explains why you cannot complete the task. Do that as a last resort, after trying all the tools available to you.",
+                    "## END IMPORTANT NOTE ##",
+                ].join('\n');
+                const currentInstructions = data.instructions ?? baseData.instructions ?? '';
+                data.instructions = currentInstructions
+                    ? `${currentInstructions}\n\n${inject}`
+                    : inject;
+            }
+        }
+        catch { }
+        const enabledToolsMap = this.mcpManager?.getEnabledTools(this.sessionContext.getAvailableTools(), this.sessionContext.getIgnoreTools());
+        const requestData = {
+            agent_type: "cli",
+            session_id: this.currentSession.sessionId,
+            user_data: getUserData(),
+            git_sha1: getCurrentGitSha1(),
+            tools: this.mcpManager && enabledToolsMap ? Object.fromEntries(enabledToolsMap) : {},
+            permissions: this.sessionContext.getPermissions(),
+            ...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;
+                }
+                if (response.error === "Timeout" && this.hotStartInProgress) {
+                    this.hotStartInProgress = false;
+                    this.latestSessionId = "";
+                    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
+        });
+        // In subprocess mode, proactively inform parent about completion with the last AI message via IPC bridge
+        if (process.env.QODO_SUBPROCESS_MODE === 'true') {
+            try {
+                // Dynamically import to avoid any potential circular deps during construction
+                // @ts-ignore
+                const { MessageManager } = await import('../context/messageManager.js');
+                const mm = MessageManager.getInstance();
+                // Prefer structured output if present
+                const lastStructured = mm.getLastAIStructuredOutputMessage();
+                const lastPlain = mm.getLastAIMessage();
+                const chosen = lastStructured || lastPlain;
+                let text;
+                if (chosen) {
+                    const content = chosen.content;
+                    text = typeof content === 'string' ? content : JSON.stringify(content);
+                }
+                try {
+                    this.ipcBridge?.notifyCompletion(true, text || '', undefined, this.currentSession?.sessionId || this.latestSessionId || undefined);
+                }
+                catch { }
+            }
+            catch { }
+            // Ensure WebSocket is cleaned up before exiting the subprocess
+            try {
+                this.wsClient.cleanup();
+            }
+            catch { }
+            // Terminate the subprocess to reliably trigger parent's child.on('exit')
+            process.exit(0);
+        }
+        // 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;
+        }
+        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);
+            // Dry run tools if configured
+            const processedToolData = await toolProcessorManager.preProcessTool(toolData, this.sessionContext);
+            await this.processToolReasoning(processedToolData, isAutoApprovedTool);
+            if (isAutoApprovedTool) {
+                // In subprocess mode, also surface non-approval tool calls to parent for UI visibility
+                try {
+                    this.ipcBridge?.notifyToolCall(processedToolData);
+                }
+                catch { }
+                await this.callTool(processedToolData);
+            }
+            else {
+                // In subprocess mode, forward approval to orchestrator via IPC, otherwise use normal pending flow
+                if (process.env.QODO_SUBPROCESS_MODE === 'true' && typeof process.send === 'function') {
+                    const approved = await (this.ipcBridge?.requestApproval(processedToolData) ?? Promise.resolve(false));
+                    if (approved) {
+                        await this.callTool(processedToolData);
+                    }
+                    else {
+                        await this.handleToolDecline(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 { }
+            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.postProcessTool(toolData, response);
+                    await this.processToolResponse(toolData, processedResponse);
+                    // Also forward tool result to parent orchestrator in subprocess mode (for UI rendering)
+                    try {
+                        this.ipcBridge?.notifyToolResult(toolData, processedResponse);
+                    }
+                    catch { }
+                    // 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);
+            // Also forward error tool result to parent orchestrator in subprocess mode
+            try {
+                this.ipcBridge?.notifyToolResult(toolData, errorResponse);
+            }
+            catch { }
+            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
+            const ideAnswer = {
+                tool: toolData.tool,
+                tool_id: toolData.identifier,
+                answer: response,
+                tools: this.convertToolsForIDE(),
+                user_data: getUserData(),
+                agent_type: "cli"
+            };
+            // 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);
+            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,
+        });
+        // In subprocess mode, proactively inform parent about failure and exit via IPC bridge
+        if (process.env.QODO_SUBPROCESS_MODE === 'true') {
+            try {
+                // Dynamically import to avoid early init issues
+                // @ts-ignore
+                const { MessageManager } = await import('../context/messageManager.js');
+                const mm = MessageManager.getInstance();
+                const lastStructured = mm.getLastAIStructuredOutputMessage();
+                const lastPlain = mm.getLastAIMessage();
+                const chosen = lastStructured || lastPlain;
+                let text;
+                if (chosen) {
+                    const content = chosen.content;
+                    text = typeof content === 'string' ? content : JSON.stringify(content);
+                }
+                try {
+                    this.ipcBridge?.notifyCompletion(false, text || '', message || '', this.currentSession?.sessionId || this.latestSessionId || undefined);
+                }
+                catch { }
+            }
+            catch { }
+            try {
+                this.wsClient.cleanup();
+            }
+            catch { }
+            process.exit(1);
+        }
+    }
+    // Enhanced cleanup method with comprehensive resource management
+    cleanupConnections() {
+        this.wsClient.cleanup();
+    }
+    // Complete cleanup method
+    cleanup() {
+        try {
+            this.cleanupConnections();
+        }
+        catch { }
+        this.pendingToolRequests.clear();
+        this.currentSession = undefined;
+        this.latestSessionId = "";
+        try {
+            this.ipcBridge?.dispose?.();
+        }
+        catch { }
+        this.ipcBridge = null;
+    }
+    // Get the task tracker instance
+    getTaskTracker() {
+        return this.taskTracker;
+    }
+}
+//# sourceMappingURL=agent.js.map