@compass-ai/nova 1.0.73 → 1.0.74

package/dist/acp/agent.js

@@ -0,0 +1,795 @@
+/**
+ * ACP Agent - Core implementation of the Agent Client Protocol.
+ *
+ * Implements the ACP protocol methods including session management,
+ * prompt handling, and model/mode switching.
+ */
+import { logger } from '../utils/logger.js';
+import { getACPSessionManager } from './session-manager.js';
+import { createACPToolBridge } from './tool-bridge.js';
+import { createACPEventAdapter } from './event-adapter.js';
+import { runSDKQuery } from '../services/sdk-runner.js';
+import { getConfigManager } from '../services/config-manager.js';
+import { getCredentialStore } from '../services/credential-store.js';
+import { getCompassAuthService } from '../services/compass-auth-service.js';
+import { getAvailableModels } from '../constants/models.js';
+import { getModeConfig, getAvailableModes } from './modes.js';
+const log = logger.child('ACPAgent');
+/**
+ * Protocol version supported by this implementation.
+ */
+const PROTOCOL_VERSION = 1;
+/**
+ * Agent information.
+ */
+const AGENT_INFO = {
+    name: 'kore-cli',
+    version: '1.0.0',
+};
+/**
+ * Build terminal auth args based on how the process was invoked.
+ *
+ * When JetBrains triggers terminal auth it runs: `<command> <auth-args>`
+ * where `command` comes from acp.json. If command is `npx`, we need the
+ * package specifier before "setup" so that `npx @compass-ai/nova@x.y.z setup`
+ * is executed instead of the broken `npx setup`.
+ */
+function buildTerminalAuthArgs() {
+    // npm sets npm_command=exec when running via npx
+    if (process.env.npm_command === 'exec') {
+        const pkg = process.env.npm_package_name ?? '@compass-ai/nova';
+        const ver = process.env.npm_package_version;
+        const specifier = ver ? `${pkg}@${ver}` : pkg;
+        return [specifier, 'setup'];
+    }
+    return ['setup'];
+}
+/**
+ * Default terminal auth method advertised to ACP clients.
+ * JetBrains renders a native "Nova Setup" button from this.
+ *
+ * - `type: "terminal"` → JetBrains spawns the agent binary with `args` in a terminal
+ * - `args` are built dynamically to handle both direct invocation and npx
+ * - Returned both in `initialize` response and in `session/new` error.data
+ */
+const TERMINAL_AUTH_METHOD = {
+    id: 'kore-terminal-auth',
+    type: 'terminal',
+    name: 'Nova Setup',
+    description: 'Complete interactive setup in the terminal to configure API keys',
+    args: buildTerminalAuthArgs(),
+    env: {},
+};
+/**
+ * Classifies an error message into a machine-readable error code and optional metadata.
+ * Used to send structured ACP error session updates instead of plain text.
+ */
+function classifyError(error) {
+    // Token limit errors (aggregate or per-model)
+    const tokenLimitMatch = error.match(/(?:Aggregate t|T)oken limit exceeded.*?Used ([\d\s\u00a0,]+)\s*\/\s*([\d\s\u00a0,]+)/i);
+    if (tokenLimitMatch) {
+        const used = parseInt(tokenLimitMatch[1].replace(/[\s\u00a0,]/g, ''), 10);
+        const limit = parseInt(tokenLimitMatch[2].replace(/[\s\u00a0,]/g, ''), 10);
+        return {
+            errorCode: 'TOKEN_LIMIT_EXCEEDED',
+            metadata: { used, limit, windowHours: 6 },
+        };
+    }
+    // Model disabled / unavailable
+    if (error.includes('not available') || error.includes('not enabled') || error.includes('disabled')) {
+        return { errorCode: 'MODEL_UNAVAILABLE' };
+    }
+    // Auth errors
+    if (error.includes('Authentication') || error.includes('API key') || error.includes('unauthorized')) {
+        return { errorCode: 'AUTH_ERROR' };
+    }
+    return { errorCode: 'INTERNAL_ERROR' };
+}
+/**
+ * ACP Agent class.
+ * Implements the Agent Client Protocol for integration with ACP clients.
+ */
+export class ACPAgent {
+    /** ACP connection */
+    connection = null;
+    /** Configuration */
+    config;
+    /** Session manager */
+    sessionManager;
+    /** Tool bridges per session */
+    toolBridges = new Map();
+    /** Event adapters per session */
+    eventAdapters = new Map();
+    /** Abort controllers per session */
+    abortControllers = new Map();
+    /** Whether the client has successfully authenticated */
+    authenticated = false;
+    /**
+     * Checks credentials and throws an ACP auth error if none are configured.
+     *
+     * IMPORTANT (JetBrains ACP integration):
+     * - This MUST gate `session/new` (not just `prompt`). JetBrains only renders
+     *   the "Nova Setup" button when session creation fails with an auth error
+     *   containing `data.authMethods`. It does NOT check prompt-level errors.
+     * - The `authMethods` array must be placed inside `error.data` (JSON-RPC 2.0
+     *   compliant), not as a top-level sibling of `code`/`message`.
+     * - The auth method `type` must be `"terminal"` for JetBrains to show the
+     *   native terminal setup button.
+     */
+    async ensureAuthenticated() {
+        if (this.authenticated)
+            return;
+        const credentialStore = await getCredentialStore();
+        if (await credentialStore.hasApiKey()) {
+            this.authenticated = true;
+            return;
+        }
+        log.warn('Request rejected: no credentials configured');
+        const error = new Error('Click Nova Setup to configure your API keys');
+        error.code = -32000;
+        error.authMethods = [TERMINAL_AUTH_METHOD];
+        throw error;
+    }
+    /**
+     * Creates a new ACPAgent instance.
+     *
+     * @param config - Agent configuration
+     * @param sessionManager - Optional custom session manager
+     */
+    constructor(config, sessionManager) {
+        this.config = config;
+        this.sessionManager = sessionManager ?? getACPSessionManager();
+    }
+    /**
+     * Sets the ACP connection.
+     *
+     * @param connection - ACP connection
+     */
+    setConnection(connection) {
+        this.connection = connection;
+    }
+    /**
+     * Handles the initialize request.
+     *
+     * @param params - Initialize request parameters
+     * @returns Initialize response
+     */
+    async initialize(params) {
+        log.info('Initialize', {
+            protocolVersion: params.protocolVersion,
+            clientAuthTerminal: params.clientCapabilities?.auth?.terminal,
+        });
+        // Check if user has valid credentials
+        const credentialStore = await getCredentialStore();
+        const hasCredentials = await credentialStore.hasApiKey();
+        // Advertise auth methods when credentials are missing or explicitly required.
+        // Note: JetBrains renders the setup button from initialize authMethods but does
+        // NOT declare auth.terminal in clientCapabilities, so we advertise unconditionally.
+        const requireAuth = process.env.ACP_REQUIRE_AUTH === 'true';
+        const shouldAdvertiseAuth = requireAuth || !hasCredentials;
+        const authMethods = [];
+        if (shouldAdvertiseAuth) {
+            authMethods.push(TERMINAL_AUTH_METHOD);
+        }
+        return {
+            protocolVersion: PROTOCOL_VERSION,
+            agentCapabilities: {
+                loadSession: true,
+                mcpCapabilities: {
+                    http: true,
+                    sse: true,
+                },
+                promptCapabilities: {
+                    embeddedContext: true,
+                    image: true,
+                },
+                sessionCapabilities: {
+                    fork: {},
+                    list: {},
+                    resume: {},
+                },
+            },
+            authMethods,
+            agentInfo: AGENT_INFO,
+        };
+    }
+    /**
+     * Handles authentication request.
+     * Currently stubbed for MVP.
+     *
+     * @param params - Authentication request
+     * @returns Authentication response
+     */
+    async authenticate(params) {
+        log.info('Authenticate request', { methodId: params.methodId });
+        // Check if user has valid credentials in the credential store
+        const credentialStore = await getCredentialStore();
+        const hasCredentials = await credentialStore.hasApiKey();
+        // Development mode bypass (for testing without auth)
+        if (process.env.ACP_REQUIRE_AUTH !== 'true' && hasCredentials) {
+            // Validate Compass API key to populate plan status, plan type, and super-user flag.
+            // Without this, CompassAuthService defaults to 'no_subscription' and enforces
+            // the 150k token limit even for Enterprise subscribers.
+            try {
+                const compassKey = await credentialStore.getCompassApiKey();
+                if (compassKey) {
+                    const compassAuth = getCompassAuthService();
+                    await compassAuth.validateApiKey(compassKey);
+                    log.info('Compass API key validated', {
+                        planStatus: compassAuth.getPlanStatus(),
+                        planType: compassAuth.getPlanType(),
+                        superUser: compassAuth.isSuperUser(),
+                    });
+                }
+            }
+            catch (compassError) {
+                log.warn('Failed to validate Compass API key, continuing with default limits', compassError);
+                // Non-fatal — proceed with no_subscription limits
+            }
+            log.info('Authentication successful (credentials found)');
+            this.authenticated = true;
+            return {
+                success: true,
+                message: 'Authentication successful',
+            };
+        }
+        // If no credentials and auth is required, return AUTH_REQUIRED with terminal config
+        if (!hasCredentials) {
+            log.info('No credentials found, returning AUTH_REQUIRED');
+            return {
+                success: false,
+                error: 'Authentication required. Please run setup to configure API keys.',
+                errorCode: 'AUTH_REQUIRED',
+            };
+        }
+        // If API key provided in request, validate it
+        const apiKey = params.credentials?.apiKey;
+        if (apiKey) {
+            // Store the provided API key
+            const isValidFormat = credentialStore.validateApiKeyFormat(apiKey);
+            if (!isValidFormat) {
+                return {
+                    success: false,
+                    error: 'Invalid API key format',
+                    errorCode: 'INVALID_CREDENTIALS',
+                };
+            }
+            // Store the key for future use
+            await credentialStore.setApiKey(apiKey);
+            log.info('API key stored successfully');
+            this.authenticated = true;
+            return {
+                success: true,
+                message: 'Authentication successful - API key stored',
+            };
+        }
+        // Credentials exist in store
+        this.authenticated = true;
+        return {
+            success: true,
+            message: 'Authentication successful',
+        };
+    }
+    /**
+     * Creates a new session.
+     *
+     * @param params - New session request
+     * @returns New session response
+     */
+    async newSession(params) {
+        const { cwd, mcpServers } = params;
+        log.info('Creating new session', { cwd, mcpServers: mcpServers.length });
+        // Gate session creation on credentials — see ensureAuthenticated() for why
+        // this must happen here and not just in prompt()
+        await this.ensureAuthenticated();
+        // Create session
+        const session = await this.sessionManager.create(cwd, this.config.defaultModel, mcpServers);
+        // Initialize tool bridge and event adapter for this session
+        this.initializeSessionComponents(session);
+        // Load session capabilities
+        const capabilities = await this.loadSessionCapabilities(session);
+        return {
+            sessionId: session.id,
+            models: capabilities.models,
+            modes: capabilities.modes,
+            _meta: {},
+        };
+    }
+    /**
+     * Loads an existing session.
+     *
+     * @param params - Load session request
+     * @returns Session response with models and modes
+     */
+    async loadSession(params) {
+        const { sessionId, cwd, mcpServers } = params;
+        log.info('Loading session', { sessionId, cwd, mcpServers: mcpServers.length });
+        // Gate session loading on credentials (consistent with newSession)
+        // Enabling this code breaks JetBrains session loading flow because JetBrains does not check prompt-level errors.
+        //await this.ensureAuthenticated();
+        // Load session
+        const session = await this.sessionManager.load(sessionId, cwd, mcpServers, this.config.defaultModel);
+        // Initialize components
+        this.initializeSessionComponents(session);
+        // Load capabilities
+        const capabilities = await this.loadSessionCapabilities(session);
+        // Replay session history AFTER returning the response to avoid deadlock:
+        // replaySessionHistory awaits writes to stdout, but the client may not read
+        // those notifications until it receives the loadSession response. If stdout
+        // buffers fill up, both sides block forever.
+        if (session.conversationHistory && session.conversationHistory.length > 0) {
+            const sessionCopy = session;
+            setImmediate(() => {
+                this.replaySessionHistory(sessionCopy).catch((err) => {
+                    log.error('Failed to replay session history', { error: err });
+                });
+            });
+        }
+        return {
+            sessionId: session.id,
+            models: capabilities.models,
+            modes: capabilities.modes,
+            _meta: {},
+        };
+    }
+    /**
+     * Lists available sessions.
+     *
+     * @param params - List sessions request
+     * @returns List of sessions
+     */
+    async listSessions(params) {
+        const sessions = await this.sessionManager.list(params.cwd);
+        const limit = 100;
+        // Parse cursor for pagination
+        let startIndex = 0;
+        if (params.cursor) {
+            startIndex = parseInt(params.cursor, 10) || 0;
+        }
+        const page = sessions.slice(startIndex, startIndex + limit);
+        const entries = page.map(session => ({
+            sessionId: session.id,
+            cwd: session.workingDir,
+            title: `Session ${session.id.substring(0, 8)}`,
+            updatedAt: session.lastActivity.toISOString(),
+        }));
+        const response = {
+            sessions: entries,
+        };
+        if (startIndex + limit < sessions.length) {
+            response.nextCursor = String(startIndex + limit);
+        }
+        return response;
+    }
+    /**
+     * Forks an existing session.
+     *
+     * @param params - Fork session request
+     * @returns Forked session response
+     */
+    async forkSession(params) {
+        const { sessionId, cwd, mcpServers = [] } = params;
+        log.info('Forking session', { sessionId, cwd });
+        // Fork session
+        const forked = await this.sessionManager.fork(sessionId, cwd, mcpServers);
+        // Initialize components
+        this.initializeSessionComponents(forked);
+        // Load capabilities
+        const capabilities = await this.loadSessionCapabilities(forked);
+        // Replay history after returning the response (same deadlock prevention as loadSession)
+        if (forked.conversationHistory && forked.conversationHistory.length > 0) {
+            const forkedCopy = forked;
+            setImmediate(() => {
+                this.replaySessionHistory(forkedCopy).catch((err) => {
+                    log.error('Failed to replay forked session history', { error: err });
+                });
+            });
+        }
+        return {
+            sessionId: forked.id,
+            models: capabilities.models,
+            modes: capabilities.modes,
+            _meta: {},
+        };
+    }
+    /**
+     * Resumes a session without replaying history.
+     *
+     * @param params - Resume session request
+     * @returns Session response
+     */
+    async resumeSession(params) {
+        const { sessionId, cwd, mcpServers = [] } = params;
+        log.info('Resuming session', { sessionId, cwd });
+        // Load session without replay
+        const session = await this.sessionManager.load(sessionId, cwd, mcpServers, this.config.defaultModel);
+        // Initialize components
+        this.initializeSessionComponents(session);
+        // Load capabilities
+        const capabilities = await this.loadSessionCapabilities(session);
+        return {
+            sessionId: session.id,
+            models: capabilities.models,
+            modes: capabilities.modes,
+            _meta: {},
+        };
+    }
+    /**
+     * Handles a prompt request.
+     * Uses the SDK runner to leverage existing CLI functionality including tools,
+     * system prompt, and agentic loop.
+     *
+     * @param params - Prompt request
+     * @returns Prompt response
+     */
+    async prompt(params) {
+        const { sessionId, prompt } = params;
+        log.info('Processing prompt', { sessionId, parts: prompt.length });
+        const session = this.sessionManager.get(sessionId);
+        const eventAdapter = this.eventAdapters.get(sessionId);
+        // Check credentials before processing prompt
+        await this.ensureAuthenticated();
+        // Convert ACP prompt parts to text content
+        const textParts = [];
+        for (const part of prompt) {
+            switch (part.type) {
+                case 'text':
+                    if (part.text) {
+                        textParts.push(part.text);
+                    }
+                    break;
+                case 'image':
+                    // Image parts require embedded data or a resolvable URI.
+                    // When neither is present, surface a clear error instead of
+                    // silently sending an empty query to the model.
+                    if (part.data) {
+                        textParts.push(`[Image: base64 data, mime=${part.mimeType ?? 'unknown'}]`);
+                    }
+                    else if (part.uri) {
+                        textParts.push(`[Image: ${part.uri}]`);
+                    }
+                    break;
+                case 'resource_link':
+                    if (part.uri) {
+                        textParts.push(`[Resource: ${part.name ?? part.uri}]`);
+                    }
+                    break;
+                case 'resource':
+                    if (part.resource?.text) {
+                        textParts.push(part.resource.text);
+                    }
+                    else if (part.resource?.uri) {
+                        textParts.push(`[Resource: ${part.resource.uri}]`);
+                    }
+                    break;
+                default:
+                    log.warn('Unknown prompt part type, skipping', { type: part.type });
+                    break;
+            }
+        }
+        const textContent = textParts.join('\n').trim();
+        if (!textContent) {
+            log.warn('Prompt has no usable text content', { sessionId, parts: prompt.length });
+            throw new Error('Prompt is empty: no text content could be extracted from the provided parts');
+        }
+        // Check for slash command
+        if (textContent.startsWith('/')) {
+            const [cmdName, ...rest] = textContent.slice(1).split(/\s+/);
+            const cmdArgs = rest.join(' ').trim();
+            // Handle built-in commands
+            const handled = await this.handleSlashCommand(session, cmdName, cmdArgs);
+            if (handled) {
+                return {
+                    stopReason: 'end_turn',
+                    _meta: {},
+                };
+            }
+        }
+        // Create abort controller for this prompt
+        const abortController = new AbortController();
+        this.abortControllers.set(sessionId, abortController);
+        // Track stop reason - always 'end_turn' since tools are executed within the agentic loop
+        const stopReason = 'end_turn';
+        // Create SDK runner callbacks that bridge to ACP event adapter
+        const callbacks = {
+            onTextChunk: (chunk) => {
+                if (eventAdapter) {
+                    eventAdapter.sendAgentMessageChunk(chunk).catch((err) => {
+                        log.error('Error sending text chunk', { error: err });
+                    });
+                }
+            },
+            onToolStart: (toolName, toolId, input) => {
+                // Note: Tool events are also captured by the event adapter's setupOutboundMappings
+                // via the kore event emitter, but we log here for debugging
+                log.debug('Tool started', { toolName, toolId, input });
+            },
+            onToolComplete: (toolName, toolId, _result, success, error) => {
+                // Note: Tool completion events are handled by the event adapter
+                log.debug('Tool completed', { toolName, toolId, success, error });
+            },
+            onStatusUpdate: (status) => {
+                log.debug('Status update', { status });
+            },
+            onComplete: (_response, _usage, _cost) => {
+                log.debug('SDK runner completed');
+            },
+            onError: (error) => {
+                log.error('SDK runner error', { error });
+                if (eventAdapter) {
+                    const { errorCode, metadata } = classifyError(error);
+                    eventAdapter.sendError(errorCode, error, metadata).catch((err) => {
+                        log.error('Error sending error message', { error: err });
+                    });
+                }
+            },
+            onIterationStart: (iteration, maxIterations) => {
+                log.debug('Iteration start', { iteration, maxIterations });
+            },
+        };
+        try {
+            // Get mode configuration for the session
+            const modeConfig = getModeConfig(session.modeId);
+            log.debug('Using mode config', { modeId: session.modeId, autoApprove: modeConfig.autoApprove, forcePlanMode: modeConfig.forcePlanMode });
+            // CLI --unleash flag takes priority; fall back to project config
+            const configManager = getConfigManager();
+            const unleash = this.config.unleash === true
+                || configManager.getConfig().session.unleash === true;
+            if (unleash) {
+                log.info('Unleash mode enabled', { source: this.config.unleash ? 'cli-flag' : 'project-config' });
+            }
+            // Run the SDK query with existing CLI infrastructure
+            const result = await runSDKQuery({
+                query: textContent,
+                projectRoot: session.workingDir,
+                continueSession: true, // Continue from existing session for context
+                autoApprove: modeConfig.autoApprove, // Mode-specific approval setting
+                callbacks,
+                silent: true, // Use callbacks instead of stdout
+                systemPromptAddition: modeConfig.systemPromptAddition, // Mode-specific instructions
+                forcePlanMode: modeConfig.forcePlanMode, // Force plan mode if configured
+                model: session.model, // Propagate ACP session model to SDK runner
+                unguardedMode: unleash, // Explicit — no singleton mutation needed
+            });
+            if (!result.success) {
+                log.error('SDK query failed', { error: result.error });
+                if (eventAdapter && result.error) {
+                    const { errorCode, metadata } = classifyError(result.error);
+                    await eventAdapter.sendError(errorCode, result.error, metadata);
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                log.info('Prompt cancelled', { sessionId });
+                if (eventAdapter) {
+                    await eventAdapter.sendAgentMessageChunk('\n\n[Cancelled]');
+                }
+            }
+            else {
+                log.error('Error running SDK query', { error });
+                if (eventAdapter) {
+                    const errorMsg = error instanceof Error ? error.message : String(error);
+                    const { errorCode, metadata } = classifyError(errorMsg);
+                    await eventAdapter.sendError(errorCode, errorMsg, metadata);
+                }
+            }
+        }
+        // Update session activity
+        this.sessionManager.touch(sessionId);
+        return {
+            stopReason,
+            _meta: {},
+        };
+    }
+    /**
+     * Sets the model for a session.
+     *
+     * @param params - Set model request
+     */
+    async setSessionModel(params) {
+        const { sessionId, modelId } = params;
+        log.info('Setting session model', { sessionId, modelId });
+        // Parse model ID (format: providerId/modelId)
+        const [providerId, modelIdPart] = modelId.split('/');
+        this.sessionManager.setModel(sessionId, {
+            providerId: providerId || 'anthropic',
+            modelId: modelIdPart || modelId,
+        });
+        return { _meta: {} };
+    }
+    /**
+     * Sets the mode/agent for a session.
+     *
+     * @param params - Set mode request
+     */
+    async setSessionMode(params) {
+        const { sessionId, modeId } = params;
+        log.info('Setting session mode', { sessionId, modeId });
+        this.sessionManager.setMode(sessionId, modeId);
+        return { _meta: {} };
+    }
+    /**
+     * Cancels an ongoing operation.
+     *
+     * @param params - Cancel notification
+     */
+    async cancel(params) {
+        const { sessionId } = params;
+        log.info('Cancelling session operation', { sessionId });
+        const controller = this.abortControllers.get(sessionId);
+        if (controller) {
+            controller.abort();
+            this.abortControllers.delete(sessionId);
+        }
+    }
+    /**
+     * Gracefully shuts down the agent.
+     */
+    async shutdown() {
+        log.info('Shutting down ACP agent');
+        // Abort all pending operations
+        for (const controller of this.abortControllers.values()) {
+            controller.abort();
+        }
+        this.abortControllers.clear();
+        // Dispose event adapters
+        for (const adapter of this.eventAdapters.values()) {
+            adapter.dispose();
+        }
+        this.eventAdapters.clear();
+        // Clear tool bridges
+        this.toolBridges.clear();
+        // Shutdown session manager
+        await this.sessionManager.shutdown();
+        log.info('ACP agent shutdown complete');
+    }
+    /**
+     * Initializes tool bridge and event adapter for a session.
+     */
+    initializeSessionComponents(session) {
+        // Dispose previous event adapter to remove stale event listeners
+        const oldAdapter = this.eventAdapters.get(session.id);
+        if (oldAdapter) {
+            oldAdapter.dispose();
+        }
+        // Create tool bridge
+        const toolBridge = createACPToolBridge(session.workingDir);
+        this.toolBridges.set(session.id, toolBridge);
+        // Create event adapter
+        const eventAdapter = createACPEventAdapter();
+        if (this.connection) {
+            eventAdapter.initialize(this.connection, session.id, toolBridge);
+        }
+        this.eventAdapters.set(session.id, eventAdapter);
+        // Create abort controller
+        this.abortControllers.set(session.id, new AbortController());
+    }
+    /**
+     * Loads available models, modes, and commands for a session.
+     * Filters models to only include those from providers with configured API keys.
+     */
+    async loadSessionCapabilities(session) {
+        // Get configured providers (those with API keys set)
+        const credentialStore = await getCredentialStore();
+        const configuredProviders = await credentialStore.getConfiguredProviders();
+        log.debug('Configured providers', { providers: configuredProviders });
+        // Get all models and filter by configured providers
+        const allModels = getAvailableModels();
+        const availableModels = allModels
+            .filter(model => {
+            const provider = (model.provider || 'anthropic');
+            return configuredProviders.includes(provider);
+        })
+            .map(model => ({
+            modelId: `${model.provider}/${model.id}`,
+            name: model.name,
+        }));
+        log.debug('Available models for ACP', { count: availableModels.length, models: availableModels });
+        // Get available modes from mode configurations
+        const availableModes = getAvailableModes();
+        // Available commands
+        const commands = [
+            { name: 'compact', description: 'Compact the session history' },
+            { name: 'clear', description: 'Clear the session' },
+            { name: 'help', description: 'Show available commands' },
+            { name: 'model', description: 'Switch model' },
+            { name: 'exit', description: 'Exit the session' },
+        ];
+        return {
+            models: {
+                currentModelId: `${session.model.providerId}/${session.model.modelId}`,
+                availableModels,
+            },
+            modes: {
+                currentModeId: session.modeId,
+                availableModes,
+            },
+            commands,
+        };
+    }
+    /**
+     * Replays session history to ACP client.
+     */
+    async replaySessionHistory(session) {
+        if (!this.connection || !session.conversationHistory)
+            return;
+        const eventAdapter = this.eventAdapters.get(session.id);
+        if (!eventAdapter)
+            return;
+        log.debug('Replaying session history', {
+            sessionId: session.id,
+            messageCount: session.conversationHistory.length,
+        });
+        for (const message of session.conversationHistory) {
+            for (const part of message.parts) {
+                if (part.type === 'text' && part.text) {
+                    if (message.role === 'user') {
+                        await eventAdapter.sendUserMessageChunk(part.text);
+                    }
+                    else if (message.role === 'assistant') {
+                        await eventAdapter.sendAgentMessageChunk(part.text);
+                    }
+                }
+                else if (part.type === 'reasoning' && part.text) {
+                    await eventAdapter.sendAgentThoughtChunk(part.text);
+                }
+                // Tool parts would need full tool state replay which is complex
+            }
+        }
+    }
+    /**
+     * Handles slash commands.
+     */
+    async handleSlashCommand(session, command, args) {
+        const eventAdapter = this.eventAdapters.get(session.id);
+        switch (command.toLowerCase()) {
+            case 'compact':
+                if (eventAdapter) {
+                    await eventAdapter.sendAgentMessageChunk('[ACP] Session compaction requested');
+                }
+                // TODO: Implement actual compaction
+                return true;
+            case 'clear':
+                session.conversationHistory = [];
+                if (eventAdapter) {
+                    await eventAdapter.sendAgentMessageChunk('[ACP] Session cleared');
+                }
+                return true;
+            case 'help':
+                if (eventAdapter) {
+                    await eventAdapter.sendAgentMessageChunk('Available commands:\n' +
+                        '- /compact - Compact session history\n' +
+                        '- /clear - Clear session\n' +
+                        '- /model <id> - Switch model\n' +
+                        '- /help - Show this help');
+                }
+                return true;
+            case 'model':
+                if (args) {
+                    const [providerId, modelId] = args.split('/');
+                    session.model = {
+                        providerId: providerId || 'anthropic',
+                        modelId: modelId || args,
+                    };
+                    if (eventAdapter) {
+                        await eventAdapter.sendAgentMessageChunk(`[ACP] Model switched to ${args}`);
+                    }
+                }
+                return true;
+            default:
+                return false;
+        }
+    }
+}
+/**
+ * Creates a new ACPAgent instance.
+ *
+ * @param config - Agent configuration
+ * @param sessionManager - Optional custom session manager
+ * @returns A new ACPAgent instance
+ */
+export function createACPAgent(config, sessionManager) {
+    return new ACPAgent(config, sessionManager);
+}
+//# sourceMappingURL=agent.js.map