@tencent-ai/agent-sdk 0.3.42 → 0.3.44

package/lib/acp/agent.js

@@ -1,887 +0,0 @@
-"use strict";
-/**
- * AcpAgent - Implementation of the official ACP Agent interface
- *
- * This class bridges the @agentclientprotocol/sdk Agent interface with
- * the Genie Session for handling ACP protocol requests.
- *
- * Usage: Create via session.asAcpAgent(connection)
- *
- * Architecture:
- *   Browser -> HTTP -> AcpHttpTransport -> AgentSideConnection -> AcpAgent -> Session
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AcpAgent = exports.ACP_EXT_METHOD_QUESTION = void 0;
-const converter_1 = require("./converter");
-// ============= ACP Extension Constants =============
-// These should stay in sync with @genie/agent-client-protocol types.ts
-/**
- * Extension method for tool input requests (e.g., AskUserQuestion).
- * Matches ExtensionMethod.QUESTION from agent-client-protocol.
- */
-exports.ACP_EXT_METHOD_QUESTION = '_codebuddy.ai/question';
-/**
- * AcpAgent - Implements the official ACP Agent interface
- *
- * Created via session.asAcpAgent(connection). The session must be
- * created and connected before creating the AcpAgent.
- *
- * @example
- * ```typescript
- * const session = createSession({ cwd: '/workspace' });
- * await session.connect();
- *
- * const connection = new AgentSideConnection(
- *     (conn) => session.asAcpAgent(conn),
- *     stream
- * );
- * ```
- */
-class AcpAgent {
-    /**
-     * Create an AcpAgent.
-     *
-     * @param connection - The AgentSideConnection for communication
-     * @param session - Optional default session. If provided, it will be returned by newSession().
-     *                  If null, onNewSession must be provided in options.
-     * @param options - Configuration options including optional onNewSession
-     */
-    constructor(connection, session, options = {}) {
-        var _a, _b;
-        this.sessions = new Map();
-        this.activePromptSessionId = null;
-        this.promptAbortController = null;
-        /** Per-session converters for proper state management */
-        this.sessionConverters = new Map();
-        /** Track session last activity time for LRU eviction */
-        this.sessionLastActivity = new Map();
-        /** Track in-progress session loading to prevent race conditions */
-        this.sessionLoadingPromises = new Map();
-        /** Track commands notification handlers per session for cleanup */
-        this.sessionCommandsHandlers = new Map();
-        this.connection = connection;
-        this.defaultSession = session;
-        this.options = {
-            protocolVersion: (_a = options.protocolVersion) !== null && _a !== void 0 ? _a : 1,
-            agentInfo: (_b = options.agentInfo) !== null && _b !== void 0 ? _b : {
-                name: 'codebuddy-code',
-                version: '1.0.0',
-            },
-            ...options,
-        };
-        // If a default session is provided, register it using its own sessionId
-        // Session now auto-generates sessionId, so we use that instead of generating a new one
-        if (session) {
-            const sessionId = session.sessionId;
-            this.registerSession(sessionId, session);
-        }
-        // Clean up when connection closes
-        // Note: connection.signal may not be available during construction
-        // (when called from AgentSideConnection factory), so we defer this
-        queueMicrotask(() => {
-            if (connection.signal) {
-                connection.signal.addEventListener('abort', () => {
-                    this.cleanup();
-                });
-            }
-        });
-    }
-    // ============= Required Agent Interface Methods =============
-    /**
-     * Initialize the connection with the client.
-     * Returns protocol version and agent capabilities.
-     */
-    async initialize(_params) {
-        const defaultCapabilities = {
-            // Always support loadSession - works for in-memory sessions,
-            // and for resuming sessions if onLoadSession is provided
-            loadSession: true,
-        };
-        return {
-            protocolVersion: this.options.protocolVersion,
-            agentCapabilities: {
-                ...defaultCapabilities,
-                ...this.options.capabilities,
-            },
-            agentInfo: this.options.agentInfo,
-        };
-    }
-    /**
-     * Authenticate the client.
-     * Currently a no-op as we don't require authentication.
-     */
-    async authenticate(_params) {
-        return {};
-    }
-    /**
-     * Create or return a session.
-     *
-     * Behavior depends on configuration:
-     * 1. If onNewSession is provided: Creates a new session via factory
-     * 2. If defaultSession is provided: Returns the first registered session
-     * 3. Otherwise: Throws an error
-     */
-    async newSession(params) {
-        // If we have a session factory, use it to create the session
-        // Session auto-generates sessionId, so we get it from the created session
-        if (this.options.onNewSession) {
-            // Pass params without sessionId - Session will auto-generate it
-            // sessionId is kept as optional parameter for backward compatibility
-            const session = await this.options.onNewSession(params);
-            const sessionId = session.sessionId; // Get the auto-generated sessionId
-            this.registerSession(sessionId, session);
-            // Subscribe to commands channel for available_commands_update (async, after return)
-            setTimeout(() => this.subscribeToCommands(sessionId, session), 0);
-            return {
-                sessionId,
-                modes: await this.getSessionModes(session),
-                models: await this.getSessionModels(session),
-            };
-        }
-        // If we have a default session, return the first registered sessionId
-        if (this.defaultSession && this.sessions.size > 0) {
-            const firstSessionId = this.sessions.keys().next().value;
-            // Subscribe to commands channel for available_commands_update (async, after return)
-            setTimeout(() => this.subscribeToCommands(firstSessionId, this.defaultSession), 0);
-            return {
-                sessionId: firstSessionId,
-                modes: await this.getSessionModes(this.defaultSession),
-                models: await this.getSessionModels(this.defaultSession),
-            };
-        }
-        throw new Error('No session available. Provide either a session or onNewSession.');
-    }
-    // 加载/恢复已有会话
-    // 根据 ACP 规范：Agent 必须先通过 session/update 流式传输所有历史消息，
-    // 然后才能发送 session/load 响应
-    // 参考：https://agentclientprotocol.com/protocol/session-setup#loading-a-session
-    async loadSession(params) {
-        const { sessionId } = params;
-        // If another loadSession is in progress for this sessionId, wait for it
-        const existingPromise = this.sessionLoadingPromises.get(sessionId);
-        if (existingPromise) {
-            const session = await existingPromise;
-            // Subscribe to commands channel for available_commands_update (async, after return)
-            setTimeout(() => this.subscribeToCommands(sessionId, session), 0);
-            return {
-                modes: await this.getSessionModes(session),
-                models: await this.getSessionModels(session),
-            };
-        }
-        // If we have a session loader, always use it to load/resume the session
-        // This supports multi-window scenarios where each window needs fresh history
-        if (this.options.onLoadSession) {
-            // Create the loading promise and track it BEFORE any async operations
-            // This prevents race conditions where concurrent requests see no session
-            const loadPromise = Promise.resolve(this.options.onLoadSession(params));
-            this.sessionLoadingPromises.set(sessionId, loadPromise);
-            try {
-                // Remove existing session if present (allows re-loading with fresh history)
-                // Do this AFTER setting the loading promise so concurrent requests wait
-                if (this.sessions.has(sessionId)) {
-                    this.removeSession(sessionId, false); // Don't close - onLoadSession handles this
-                }
-                const session = await loadPromise;
-                this.registerSession(sessionId, session);
-                // 根据 ACP 规范，必须先完成所有历史消息的流式传输，
-                // 然后才能发送 session/load 响应
-                // "When all the conversation entries have been streamed to the Client,
-                //  the Agent MUST respond to the original session/load request."
-                if (session.hasPendingHistory()) {
-                    try {
-                        // Collect all messages first
-                        const messages = [];
-                        for await (const message of session.stream()) {
-                            messages.push(message);
-                            if (message.type === 'result' || message.type === 'error') {
-                                break;
-                            }
-                        }
-                        // Filter: only keep the last topic message
-                        const filtered = this.filterHistoryMessages(messages);
-                        // Send updates
-                        for (const message of filtered) {
-                            await this.sendUpdates(sessionId, message, 'history');
-                        }
-                    }
-                    catch (_a) {
-                        // ignore streaming errors, still return response
-                    }
-                }
-                // Subscribe to commands channel for available_commands_update (async, after return)
-                setTimeout(() => this.subscribeToCommands(sessionId, session), 0);
-                return {
-                    modes: await this.getSessionModes(session),
-                    models: await this.getSessionModels(session),
-                };
-            }
-            finally {
-                this.sessionLoadingPromises.delete(sessionId);
-            }
-        }
-        // No session loader - check if session is already loaded
-        if (this.sessions.has(sessionId)) {
-            const session = this.sessions.get(sessionId);
-            // Subscribe to commands channel for available_commands_update (async, after return)
-            if (session) {
-                setTimeout(() => this.subscribeToCommands(sessionId, session), 0);
-            }
-            return {
-                modes: await this.getSessionModes(session),
-                models: await this.getSessionModels(session),
-            };
-        }
-        throw new Error(`Session not found: ${sessionId}. Provide onLoadSession to support resuming sessions from storage.`);
-    }
-    /**
-     * Process a prompt request.
-     * Sends the prompt to the session and streams updates back to the client.
-     */
-    async prompt(params) {
-        var _a;
-        const { sessionId, prompt } = params;
-        // Wait for any in-progress session loading to complete
-        // This prevents race conditions when prompt is called immediately after loadSession
-        const loadingPromise = this.sessionLoadingPromises.get(sessionId);
-        if (loadingPromise) {
-            await loadingPromise;
-        }
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            throw new Error(`Session not found: ${sessionId}`);
-        }
-        // Update session activity
-        this.touchSession(sessionId);
-        // Track active prompt for cancellation
-        this.activePromptSessionId = sessionId;
-        this.promptAbortController = new AbortController();
-        try {
-            // Send user message echo to client before processing
-            // This ensures the echo is sent immediately with the original ACP blocks
-            await this.sendUserMessageEcho(sessionId, prompt);
-            // Convert ACP content blocks to SDK format
-            const userMessage = this.convertAcpPromptToUserMessage(sessionId, prompt);
-            // Send prompt to session
-            await session.send(userMessage);
-            // Stream responses back to client
-            for await (const message of session.stream()) {
-                // Check for cancellation
-                if ((_a = this.promptAbortController) === null || _a === void 0 ? void 0 : _a.signal.aborted) {
-                    return { stopReason: 'cancelled' };
-                }
-                // Handle system init message - send custom notification with model/permissionMode
-                if (message.type === 'system' && message.subtype === 'init') {
-                    await this.sendSystemInfoNotification(sessionId, message);
-                }
-                // Skip user message from CLI stream (we already sent the echo)
-                if (message.type === 'user') {
-                    continue;
-                }
-                // Convert SDK message to ACP format and send updates (stream mode)
-                await this.sendUpdates(sessionId, message, 'stream');
-                // Check for result message (end of turn)
-                if (message.type === 'result') {
-                    return { stopReason: 'end_turn' };
-                }
-                // Check for error message
-                if (message.type === 'error') {
-                    return { stopReason: 'end_turn' };
-                }
-            }
-            return { stopReason: 'end_turn' };
-        }
-        finally {
-            this.activePromptSessionId = null;
-            this.promptAbortController = null;
-        }
-    }
-    /**
-     * Cancel an ongoing prompt.
-     */
-    async cancel(params) {
-        const { sessionId } = params;
-        if (this.activePromptSessionId === sessionId) {
-            // Abort local controller to break out of the prompt loop
-            if (this.promptAbortController) {
-                this.promptAbortController.abort();
-            }
-            // Send interrupt to the underlying session/CLI
-            const session = this.sessions.get(sessionId);
-            if (session) {
-                try {
-                    await session.interrupt();
-                }
-                catch (_a) {
-                    // Ignore interrupt errors
-                }
-            }
-        }
-    }
-    /**
-     * Set the operational mode for a session.
-     *
-     * Maps ACP SessionModeId to SDK PermissionMode and delegates to Session.setPermissionMode().
-     * Errors are silently ignored - the mode just won't take effect.
-     */
-    async setSessionMode(params) {
-        const { sessionId, modeId } = params;
-        // Wait for any in-progress session loading to complete
-        // This prevents race conditions when setSessionMode is called immediately after loadSession
-        const loadingPromise = this.sessionLoadingPromises.get(sessionId);
-        if (loadingPromise) {
-            await loadingPromise;
-        }
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            return {};
-        }
-        try {
-            // Map ACP modeId to SDK PermissionMode
-            await session.setPermissionMode(modeId);
-        }
-        catch (_a) {
-            // Silently ignore errors
-        }
-        return {};
-    }
-    /**
-     * Set the model for a session.
-     *
-     * Delegates to Session.setModel().
-     * Errors are silently ignored - the model just won't take effect.
-     *
-     * @experimental This capability is not part of the spec yet.
-     */
-    async unstable_setSessionModel(params) {
-        const { sessionId, modelId } = params;
-        // Wait for any in-progress session loading to complete
-        // This prevents race conditions when setSessionModel is called immediately after loadSession
-        const loadingPromise = this.sessionLoadingPromises.get(sessionId);
-        if (loadingPromise) {
-            await loadingPromise;
-        }
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            return {};
-        }
-        try {
-            await session.setModel(modelId);
-        }
-        catch (_a) {
-            // Silently ignore errors
-        }
-        return {};
-    }
-    // ============= Optional Agent Interface Methods =============
-    async extMethod(_method, _params) {
-        return { handled: false };
-    }
-    async extNotification(_method, _params) {
-        // Handle custom extension notifications if needed
-    }
-    // ============= Public Accessors =============
-    /**
-     * Get a session by ID, or the first session if no ID provided.
-     */
-    getSession(sessionId) {
-        if (sessionId) {
-            return this.sessions.get(sessionId);
-        }
-        // Return first session if no ID provided
-        return this.sessions.values().next().value;
-    }
-    /**
-     * Alias for getSession() for compatibility.
-     */
-    getCurrentSession() {
-        return this.getSession();
-    }
-    /**
-     * Get all session IDs.
-     */
-    getSessionIds() {
-        return Array.from(this.sessions.keys());
-    }
-    /**
-     * Get the number of active sessions.
-     */
-    getSessionCount() {
-        return this.sessions.size;
-    }
-    /**
-     * Remove a session by ID and free associated resources.
-     * @param sessionId - The session ID to remove
-     * @param closeSession - Whether to close the session (default: true)
-     * @returns true if the session was removed, false if not found
-     */
-    removeSession(sessionId, closeSession = true) {
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            return false;
-        }
-        // Close the session if requested
-        if (closeSession) {
-            try {
-                session.close();
-            }
-            catch (_a) {
-                // Ignore close errors
-            }
-        }
-        // Clean up commands notification handler if exists
-        // Must unsubscribe from session even if not closing, to prevent duplicate handlers
-        // when the same session is reused (e.g., in session/load with AcpServer)
-        const handler = this.sessionCommandsHandlers.get(sessionId);
-        if (handler) {
-            session.unsubscribeFromCommands(handler);
-            this.sessionCommandsHandlers.delete(sessionId);
-        }
-        // Clean up all associated resources
-        this.sessions.delete(sessionId);
-        this.sessionConverters.delete(sessionId);
-        this.sessionLastActivity.delete(sessionId);
-        return true;
-    }
-    /**
-     * Remove all sessions and free resources.
-     * @param closeSessions - Whether to close sessions (default: true)
-     */
-    removeAllSessions(closeSessions = true) {
-        for (const sessionId of this.sessions.keys()) {
-            this.removeSession(sessionId, closeSessions);
-        }
-    }
-    /**
-     * Get memory statistics for debugging.
-     */
-    getMemoryStats() {
-        let oldestTime = null;
-        for (const time of this.sessionLastActivity.values()) {
-            if (oldestTime === null || time < oldestTime) {
-                oldestTime = time;
-            }
-        }
-        return {
-            sessionCount: this.sessions.size,
-            converterCount: this.sessionConverters.size,
-            oldestSessionAge: oldestTime ? Date.now() - oldestTime : null,
-        };
-    }
-    // ============= Private Helper Methods =============
-    /**
-     * Register a session with memory management.
-     * Injects canUseTool handler for AskUserQuestion support.
-     */
-    registerSession(sessionId, session) {
-        // Enforce maxSessions limit if configured
-        if (this.options.maxSessions && this.sessions.size >= this.options.maxSessions) {
-            this.evictOldestSession();
-        }
-        // Get the original handler before wrapping (preserves user-configured handlers)
-        const originalHandler = session.getCanUseTool();
-        // Inject canUseTool handler for AskUserQuestion support
-        // This wraps any existing handler and intercepts AskUserQuestion requests
-        const wrappedHandler = this.createCanUseToolHandler(sessionId, originalHandler);
-        session.setCanUseTool(wrappedHandler);
-        this.sessions.set(sessionId, session);
-        this.sessionConverters.set(sessionId, new converter_1.AcpConverter());
-        this.sessionLastActivity.set(sessionId, Date.now());
-    }
-    /**
-     * Update session activity timestamp.
-     */
-    touchSession(sessionId) {
-        if (this.sessions.has(sessionId)) {
-            this.sessionLastActivity.set(sessionId, Date.now());
-        }
-    }
-    /**
-     * Evict the oldest inactive session (LRU).
-     */
-    evictOldestSession() {
-        let oldestId = null;
-        let oldestTime = Infinity;
-        for (const [id, time] of this.sessionLastActivity.entries()) {
-            // Don't evict the active prompt session
-            if (id === this.activePromptSessionId) {
-                continue;
-            }
-            if (time < oldestTime) {
-                oldestTime = time;
-                oldestId = id;
-            }
-        }
-        if (oldestId) {
-            this.removeSession(oldestId, true);
-        }
-    }
-    /**
-     * Get session modes configuration.
-     * Returns the available modes and current mode from the given session.
-     * @param session - Optional session to get current mode from. If not provided, uses default.
-     */
-    async getSessionModes(session) {
-        var _a, _b;
-        // Use configured modes or default basic set
-        const availableModes = (_a = this.options.availableModes) !== null && _a !== void 0 ? _a : (session ? await session.getAvailableModes().catch(() => []) : []);
-        // Get current mode from the provided session or fall back to default
-        const currentModeId = (_b = session === null || session === void 0 ? void 0 : session.getPermissionMode()) !== null && _b !== void 0 ? _b : 'default';
-        return {
-            availableModes,
-            currentModeId,
-        };
-    }
-    /**
-     * Get session models configuration.
-     * Returns the available models and current model from the given session.
-     * Fetches available models from the session if supported.
-     * Full raw model configurations are included in _meta['codebuddy.ai'].availableModels.
-     * @param session - Optional session to get current model and available models from.
-     */
-    async getSessionModels(session) {
-        var _a;
-        // Attempt to fetch available models from session
-        let availableModels = [];
-        let rawModels = [];
-        try {
-            if (session) {
-                // Fetch both simplified and raw models in parallel
-                const [models, rawModelsResult] = await Promise.all([
-                    session.getAvailableModels(),
-                    session.getAvailableModelsRaw().catch(() => []),
-                ]);
-                rawModels = rawModelsResult;
-                availableModels = models.map(m => ({
-                    modelId: m.modelId,
-                    name: m.name,
-                    description: m.description,
-                }));
-            }
-        }
-        catch (_b) {
-            // CLI may not support getAvailableModels, silently fall back to empty array
-        }
-        // Get current model from the provided session
-        // If no model is set, use undefined (no default fallback)
-        const currentModelId = (_a = session === null || session === void 0 ? void 0 : session.getModel()) !== null && _a !== void 0 ? _a : undefined;
-        return {
-            availableModels,
-            currentModelId: currentModelId,
-            // Include full raw model configs in _meta under codebuddy.ai namespace
-            _meta: rawModels.length > 0
-                ? { 'codebuddy.ai': { availableModels: rawModels } }
-                : undefined,
-        };
-    }
-    /**
-     * Subscribe to commands channel and forward all updates to ACP client.
-     * Sets up a persistent listener that sends available_commands_update for each notification.
-     * This ensures no updates are missed when commands change multiple times.
-     * @param sessionId - The session ID to send the updates for
-     * @param session - The session to subscribe to commands channel
-     */
-    async subscribeToCommands(sessionId, session) {
-        try {
-            // Clean up existing handler if present (e.g., when session/load is called multiple times)
-            // This prevents duplicate handlers from accumulating on the transport
-            const existingHandler = this.sessionCommandsHandlers.get(sessionId);
-            if (existingHandler) {
-                session.unsubscribeFromCommands(existingHandler);
-                this.sessionCommandsHandlers.delete(sessionId);
-            }
-            // Create handler that forwards all commands notifications to ACP client
-            const handler = (notification) => {
-                const data = notification.data;
-                const commands = data.commands.map(cmd => {
-                    const result = {
-                        // Remove leading '/' from command name if present
-                        name: cmd.name.startsWith('/') ? cmd.name.substring(1) : cmd.name,
-                        description: cmd.description || '',
-                    };
-                    if (cmd.argumentHint) {
-                        result.input = { hint: cmd.argumentHint };
-                    }
-                    return result;
-                });
-                // Send update to ACP client (fire-and-forget)
-                this.connection.sessionUpdate({
-                    sessionId,
-                    update: {
-                        sessionUpdate: 'available_commands_update',
-                        availableCommands: commands,
-                    },
-                }).catch(error => {
-                    console.error('[AcpAgent] Failed to send available commands update:', error);
-                });
-            };
-            // Store handler for cleanup
-            this.sessionCommandsHandlers.set(sessionId, handler);
-            // Subscribe to commands channel via session's subscribeToCommands method
-            await session.subscribeToCommands(handler);
-        }
-        catch (error) {
-            // Silently ignore errors - available commands are optional
-            console.error('[AcpAgent] Failed to subscribe to commands channel:', error);
-        }
-    }
-    /**
-     * Convert ACP ContentBlock[] to SDK UserMessage.
-     * Delegates to AcpConverter for the actual content block conversion.
-     */
-    convertAcpPromptToUserMessage(sessionId, prompt) {
-        const sdkContent = converter_1.AcpConverter.convertAcpPromptToSdk(prompt);
-        return {
-            type: 'user',
-            session_id: sessionId,
-            message: {
-                role: 'user',
-                content: sdkContent,
-            },
-            parent_tool_use_id: null,
-        };
-    }
-    /**
-     * Get or create a converter for a session.
-     */
-    getSessionConverter(sessionId) {
-        let converter = this.sessionConverters.get(sessionId);
-        if (!converter) {
-            converter = new converter_1.AcpConverter();
-            this.sessionConverters.set(sessionId, converter);
-        }
-        return converter;
-    }
-    /**
-     * Send session updates to the client via AgentSideConnection.
-     *
-     * @param sessionId - Session ID
-     * @param message - SDK message to convert and send
-     * @param mode - Conversion mode: 'stream' for prompt(), 'history' for loadSession()
-     */
-    async sendUpdates(sessionId, message, mode = 'stream') {
-        var _a, _b;
-        const converter = this.getSessionConverter(sessionId);
-        const updates = converter.convertToUpdates(message, { mode });
-        for (const { update, _meta } of updates) {
-            const meta = {
-                mode,
-                toolName: (_a = _meta === null || _meta === void 0 ? void 0 : _meta['codebuddy.ai']) === null || _a === void 0 ? void 0 : _a.toolName,
-                requestId: (_b = _meta === null || _meta === void 0 ? void 0 : _meta['codebuddy.ai']) === null || _b === void 0 ? void 0 : _b.requestId,
-            };
-            // If onSessionUpdate callback is provided, call it for broadcasting
-            if (this.options.onSessionUpdate) {
-                this.options.onSessionUpdate(sessionId, update, meta);
-            }
-            // Always send to own connection
-            try {
-                await this.connection.sessionUpdate({
-                    sessionId,
-                    update,
-                    _meta: {
-                        ..._meta,
-                        // Mark message mode for router layer to decide whether to broadcast
-                        'codebuddy.ai': {
-                            ...((_meta === null || _meta === void 0 ? void 0 : _meta['codebuddy.ai']) || {}),
-                            mode,
-                        },
-                    },
-                });
-            }
-            catch (error) {
-                console.error('[AcpAgent] Error sending session update:', error);
-            }
-        }
-    }
-    /**
-     * Send system info notification when CLI reports model/permissionMode.
-     * Uses custom notification '_codebuddy.ai/system_init' with model and permissionMode.
-     */
-    async sendSystemInfoNotification(sessionId, sysMsg) {
-        try {
-            await this.connection.extNotification('_codebuddy.ai/system_init', {
-                sessionId,
-                model: sysMsg.model,
-                permissionMode: sysMsg.permissionMode,
-            });
-        }
-        catch (_a) {
-            // Silently ignore notification errors
-        }
-    }
-    /**
-     * Send user message echo to client.
-     *
-     * This sends user_message_chunk updates for the original ACP prompt blocks.
-     * The text is formatted as @{uri} for resource_link blocks.
-     * The original blocks are preserved in _meta['codebuddy.ai'].sourceContentBlocks.
-     *
-     * @param sessionId - The session ID
-     * @param prompt - The original ACP content blocks from the prompt
-     */
-    async sendUserMessageEcho(sessionId, prompt) {
-        try {
-            // Convert ACP blocks to echo text format
-            const echoText = converter_1.AcpConverter.convertAcpPromptToEchoText(prompt);
-            // Send user_message_chunk with echo text and sourceContentBlocks
-            await this.connection.sessionUpdate({
-                sessionId,
-                update: {
-                    sessionUpdate: 'user_message_chunk',
-                    content: { type: 'text', text: echoText },
-                },
-                _meta: {
-                    'codebuddy.ai': {
-                        sourceContentBlocks: prompt,
-                        mode: 'stream',
-                    },
-                },
-            });
-        }
-        catch (error) {
-            console.error('[AcpAgent] Error sending user message echo:', error);
-        }
-    }
-    /**
-     * Filter history messages: only keep the last topic message.
-     */
-    filterHistoryMessages(messages) {
-        const result = [];
-        let foundLastTopic = false;
-        for (let i = messages.length - 1; i >= 0; i--) {
-            const msg = messages[i];
-            if ('type' in msg && msg.type === 'topic') {
-                if (foundLastTopic) {
-                    continue; // Skip earlier topic messages
-                }
-                foundLastTopic = true;
-            }
-            result.unshift(msg);
-        }
-        return result;
-    }
-    // ============= AskUserQuestion Support =============
-    /**
-     * Create a canUseTool handler that wraps the original handler
-     * and intercepts AskUserQuestion requests.
-     *
-     * @param sessionId - The session ID for this handler
-     * @param originalHandler - Optional original canUseTool handler to delegate to
-     * @returns A wrapped canUseTool handler
-     */
-    createCanUseToolHandler(sessionId, originalHandler) {
-        return async (toolName, input, options) => {
-            // Intercept AskUserQuestion tool
-            if (toolName === 'AskUserQuestion') {
-                return this.handleAskUserQuestion(sessionId, input, options);
-            }
-            // Delegate other tools to original handler
-            if (originalHandler) {
-                return originalHandler(toolName, input, options);
-            }
-            // Default: allow if no handler
-            return { behavior: 'allow', updatedInput: input };
-        };
-    }
-    /**
-     * Handle AskUserQuestion tool requests.
-     *
-     * If onAskUserQuestion is provided, uses that handler.
-     * Otherwise, sends the request to the client via ACP extMethod (_codebuddy.ai/question).
-     *
-     * @param sessionId - The session ID
-     * @param input - The tool input (AskUserQuestionInput)
-     * @param options - Permission options including toolUseID
-     * @returns Permission result with answers or denial
-     */
-    async handleAskUserQuestion(sessionId, input, options) {
-        var _a;
-        const askInput = input;
-        // Build high-level request for custom handler
-        const askRequest = {
-            sessionId,
-            toolUseId: options.toolUseID,
-            questions: askInput.questions,
-        };
-        try {
-            let answers = null;
-            // Use custom handler if provided
-            if (this.options.onAskUserQuestion) {
-                const response = await this.options.onAskUserQuestion(askRequest);
-                answers = (_a = response === null || response === void 0 ? void 0 : response.answers) !== null && _a !== void 0 ? _a : null;
-            }
-            else {
-                // Build ToolInputRequest for ACP protocol
-                const toolInputRequest = {
-                    sessionId,
-                    toolCallId: options.toolUseID,
-                    inputType: 'question',
-                    schema: {
-                        questions: askInput.questions.map((q, idx) => ({
-                            id: `q_${idx}`,
-                            question: q.question,
-                            header: q.header,
-                            options: q.options,
-                            multiSelect: q.multiSelect,
-                        })),
-                    },
-                };
-                // Send to client via ACP extMethod
-                const result = await this.connection.extMethod(exports.ACP_EXT_METHOD_QUESTION, toolInputRequest);
-                // Parse ToolInputResponse
-                const toolInputResponse = result;
-                if (toolInputResponse.outcome.outcome === 'submitted') {
-                    // Convert QuestionInputData answers to simple Record<string, string>
-                    const data = toolInputResponse.outcome.data;
-                    answers = {};
-                    // Build id -> question text mapping for better model readability
-                    const questionMap = new Map(askInput.questions.map((q, idx) => [`q_${idx}`, q.question]));
-                    for (const [key, value] of Object.entries(data.answers)) {
-                        // Map q_0, q_1... back to actual question text
-                        const questionText = questionMap.get(key) || key;
-                        // Handle both string and string[] answers
-                        answers[questionText] = Array.isArray(value) ? value.join(', ') : value;
-                    }
-                }
-            }
-            // Check for valid answers
-            if (answers && Object.keys(answers).length > 0) {
-                return {
-                    behavior: 'allow',
-                    updatedInput: {
-                        questions: askInput.questions,
-                        answers,
-                    },
-                };
-            }
-            else {
-                // User declined or no answers provided
-                return {
-                    behavior: 'deny',
-                    message: 'User declined to answer questions',
-                };
-            }
-        }
-        catch (error) {
-            // Handle errors (e.g., client doesn't support extMethod)
-            return {
-                behavior: 'deny',
-                message: error instanceof Error
-                    ? error.message
-                    : 'Failed to get user answers',
-            };
-        }
-    }
-    /**
-     * Clean up when the connection closes.
-     * Removes all sessions and frees memory.
-     */
-    cleanup() {
-        this.activePromptSessionId = null;
-        this.promptAbortController = null;
-        // Clean up all sessions when connection closes
-        // closeSession=true to properly release resources
-        this.removeAllSessions(true);
-    }
-}
-exports.AcpAgent = AcpAgent;
-//# sourceMappingURL=agent.js.map