@openma/common 0.0.0-stage → 0.9.1

package/dist/acp-runtime/session.js

@@ -0,0 +1,1071 @@
+import { ClientSideConnection, RequestError, ndJsonStream, } from "@agentclientprotocol/sdk";
+import { preserveAcpNotificationContext } from "../session-events/acp.js";
+import { isAuthenticationRequiredError } from "./errors.js";
+import { acpForkRequestMeta, forkSupport as forkSupportOf, } from "./fork-support.js";
+export { acpForkRequestMeta } from "./fork-support.js";
+const LEGACY_MODEL_META_KEY = "openma.dev/legacy-model-state";
+export class AcpSessionImpl {
+    id;
+    options;
+    #child;
+    #stdout;
+    #childExit = null;
+    #agent;
+    #legacyModels = null;
+    #disposePromise;
+    #sessionId;
+    #disposed = false;
+    #acceptOutOfBandUpdates = false;
+    #activePromptCount = 0;
+    #pendingEvents = [];
+    #waiters = [];
+    #authMethods = [];
+    #protocolVersion = null;
+    #agentInfo = null;
+    #agentCapabilities = {};
+    #initializeMeta = null;
+    #sessionSetupMeta = null;
+    #configOptions = [];
+    #modes = null;
+    #promptCapabilities = {};
+    #supportsSessionFork = false;
+    #supportsSessionList = false;
+    #supportsSessionDelete = false;
+    #supportsSessionResume = false;
+    #supportsSessionClose = false;
+    #supportsAdditionalDirectories = false;
+    #supportsLogout = false;
+    #supportsProviders = false;
+    #supportsNes = false;
+    #nesCapabilities = null;
+    #positionEncoding = null;
+    #supportsSteering = false;
+    #nextClientRequestId = 1;
+    #outstandingUrlElicitations = new Set();
+    constructor(deps) {
+        this.id = deps.id;
+        this.options = deps.options;
+        this.#child = deps.child;
+        this.#stdout = observeLegacyModels(deps.child.stdout, (models) => {
+            if (this.#legacyModels === null)
+                this.#legacyModels = models;
+        });
+        void deps.child.exited.then((result) => {
+            this.#childExit = result;
+        });
+    }
+    get acpSessionId() {
+        return this.#sessionId ?? "";
+    }
+    get authMethods() {
+        return this.#authMethods;
+    }
+    get protocolVersion() {
+        return this.#protocolVersion;
+    }
+    get agentInfo() {
+        return this.#agentInfo;
+    }
+    get agentCapabilities() {
+        return this.#agentCapabilities;
+    }
+    get initializeMeta() {
+        return this.#initializeMeta;
+    }
+    get sessionSetupMeta() {
+        return this.#sessionSetupMeta;
+    }
+    get configOptions() {
+        return this.#configOptions;
+    }
+    get legacyModels() {
+        return this.#legacyModels;
+    }
+    get modes() {
+        return this.#modes;
+    }
+    get promptCapabilities() {
+        return this.#promptCapabilities;
+    }
+    get supportsSessionFork() {
+        return this.#supportsSessionFork;
+    }
+    get forkSupport() {
+        return forkSupportOf(this);
+    }
+    get supportsSessionList() {
+        return this.#supportsSessionList;
+    }
+    get supportsSessionDelete() {
+        return this.#supportsSessionDelete;
+    }
+    get supportsSessionResume() {
+        return this.#supportsSessionResume;
+    }
+    get supportsSessionClose() {
+        return this.#supportsSessionClose;
+    }
+    get supportsAdditionalDirectories() {
+        return this.#supportsAdditionalDirectories;
+    }
+    get supportsLogout() {
+        return this.#supportsLogout;
+    }
+    get supportsProviders() {
+        return this.#supportsProviders;
+    }
+    get supportsNes() {
+        return this.#supportsNes;
+    }
+    get nesCapabilities() {
+        return this.#nesCapabilities;
+    }
+    get positionEncoding() {
+        return this.#positionEncoding;
+    }
+    get supportsSteering() {
+        return this.#supportsSteering;
+    }
+    async init() {
+        const initStartedAt = Date.now();
+        const callbacks = this.options.clientCallbacks ?? {};
+        const requestedElicitationCapabilities = this.options.clientElicitationCapabilities
+            ?? (callbacks.createElicitation
+                ? {
+                    form: {},
+                    ...(callbacks.completeElicitation ? { url: {} } : {}),
+                }
+                : undefined);
+        const elicitationCapabilities = callbacks.createElicitation
+            && requestedElicitationCapabilities
+            && (requestedElicitationCapabilities.form != null
+                || requestedElicitationCapabilities.url != null)
+            ? requestedElicitationCapabilities
+            : undefined;
+        const connection = new ClientSideConnection(() => this.#createClient(callbacks, elicitationCapabilities?.url != null), ndJsonStream(this.#child.stdin, this.#stdout));
+        this.#agent = connection;
+        if (this.options.forkPoint && !this.options.forkFromAcpSessionId) {
+            throw new Error("forkPoint can only be used together with forkFromAcpSessionId");
+        }
+        const clientCapabilities = {
+            // The existing OpenMA controls render both boolean config options and
+            // structured/markdown plans. Advertising these capabilities prevents
+            // agents such as codex-acp from degrading them to plain transcript
+            // text even though the canonical event and GUI projections exist.
+            session: {
+                configOptions: {
+                    boolean: {},
+                },
+            },
+            plan: {},
+            // Claude Agent ACP uses this ACP-reserved extension capability to
+            // forward nested subagent text, thinking, and tool updates. It is
+            // harmless for agents that do not implement the extension: ACP
+            // clients and agents must treat unknown `_meta` keys as optional.
+            _meta: {
+                "subagent-transcript": true,
+                // claude-agent-acp and codex-acp use this negotiated extension to
+                // send terminal snapshots instead of forcing clients to reconstruct
+                // them from provider-specific delta notifications.
+                terminal_output: true,
+            },
+            fs: {
+                readTextFile: Boolean(callbacks.readTextFile),
+                writeTextFile: Boolean(callbacks.writeTextFile),
+            },
+            terminal: Boolean(callbacks.createTerminal),
+            ...(elicitationCapabilities
+                ? { elicitation: elicitationCapabilities }
+                : {}),
+            ...(this.options.clientNesCapabilities
+                ? { nes: this.options.clientNesCapabilities }
+                : {}),
+            ...(this.options.positionEncodings?.length
+                ? { positionEncodings: this.options.positionEncodings }
+                : {}),
+        };
+        const overlay = this.options.clientCapabilityOverlay;
+        const initialized = await this.#agent.initialize({
+            protocolVersion: 1,
+            clientCapabilities: overlay
+                ? mergeClientCapabilities(clientCapabilities, overlay)
+                : clientCapabilities,
+        });
+        const initializedAt = Date.now();
+        this.#authMethods = initialized.authMethods ?? [];
+        this.#protocolVersion = initialized.protocolVersion;
+        this.#agentInfo = initialized.agentInfo ?? null;
+        this.#agentCapabilities = initialized.agentCapabilities ?? {};
+        this.#initializeMeta = initialized._meta ?? null;
+        this.#promptCapabilities = this.#agentCapabilities.promptCapabilities ?? {};
+        this.#supportsSessionFork =
+            initialized.agentCapabilities?.sessionCapabilities?.fork != null;
+        this.#supportsSessionList =
+            initialized.agentCapabilities?.sessionCapabilities?.list != null;
+        this.#supportsSessionDelete =
+            initialized.agentCapabilities?.sessionCapabilities?.delete != null;
+        this.#supportsSessionResume =
+            initialized.agentCapabilities?.sessionCapabilities?.resume != null;
+        this.#supportsSessionClose =
+            initialized.agentCapabilities?.sessionCapabilities?.close != null;
+        this.#supportsAdditionalDirectories =
+            initialized.agentCapabilities?.sessionCapabilities?.additionalDirectories != null;
+        this.#supportsLogout = initialized.agentCapabilities?.auth?.logout != null;
+        this.#supportsProviders = initialized.agentCapabilities?.providers != null;
+        this.#nesCapabilities = initialized.agentCapabilities?.nes ?? null;
+        this.#supportsNes = this.#nesCapabilities != null;
+        this.#positionEncoding = initialized.agentCapabilities?.positionEncoding ?? null;
+        this.#supportsSteering =
+            initialized._meta
+                ?.steering?.supported === true;
+        const cwd = this.options.agent.cwd ?? process.cwd();
+        const mcpCapabilities = this.#agentCapabilities.mcpCapabilities;
+        const mcpServers = (this.options.mcpServers ?? []).filter((server) => {
+            const transport = server.type;
+            if (transport === "http")
+                return mcpCapabilities?.http === true;
+            if (transport === "sse")
+                return mcpCapabilities?.sse === true;
+            return true;
+        });
+        const requestedAdditionalDirectories = this.options.additionalDirectories ?? [];
+        if (requestedAdditionalDirectories.length > 0 &&
+            !this.#supportsAdditionalDirectories) {
+            throw new Error("ACP agent does not support additional workspace directories");
+        }
+        const additionalDirectories = requestedAdditionalDirectories;
+        const requestMeta = this.options.sessionRequestMeta;
+        if (this.options.forkFromAcpSessionId) {
+            const support = forkSupportOf(initialized);
+            const wantsMessageFork = this.options.forkPoint != null
+                || sessionRequestDeclaresAirFork(requestMeta);
+            if (wantsMessageFork && support.level !== "message") {
+                throw new Error(`ACP agent does not support message-level fork (${support.reason}): ${support.message}`);
+            }
+            if (!this.#supportsSessionFork || !this.#agent.unstable_forkSession) {
+                throw new Error("ACP agent does not support unstable session/fork");
+            }
+            const forkRequestMeta = this.options.forkPoint
+                ? mergeSessionRequestMeta(requestMeta, acpForkRequestMeta(this.options.forkPoint))
+                : requestMeta;
+            const forked = await this.#agent.unstable_forkSession({
+                sessionId: this.options.forkFromAcpSessionId,
+                cwd,
+                mcpServers,
+                ...(additionalDirectories.length > 0 ? { additionalDirectories } : {}),
+                ...(forkRequestMeta ? { _meta: forkRequestMeta } : {}),
+            });
+            this.#sessionId = forked.sessionId;
+            this.#configOptions = forked.configOptions ?? [];
+            this.#modes = forked.modes ?? null;
+            this.#sessionSetupMeta = forked._meta ?? null;
+            this.#acceptOutOfBandUpdates = true;
+            this.#logInit("fork", initStartedAt, initializedAt);
+            return;
+        }
+        if (this.options.resumeAcpSessionId &&
+            this.#supportsSessionResume &&
+            this.#agent.resumeSession) {
+            try {
+                const resumed = await this.#withAuthenticationRetry(() => this.#agent.resumeSession({
+                    sessionId: this.options.resumeAcpSessionId,
+                    cwd,
+                    mcpServers,
+                    ...(additionalDirectories.length > 0 ? { additionalDirectories } : {}),
+                    ...(requestMeta ? { _meta: requestMeta } : {}),
+                }));
+                this.#sessionId = this.options.resumeAcpSessionId;
+                this.#configOptions = resumed.configOptions ?? [];
+                this.#modes = resumed.modes ?? null;
+                this.#sessionSetupMeta = resumed._meta ?? null;
+                this.#acceptOutOfBandUpdates = true;
+                this.#logInit("resume", initStartedAt, initializedAt);
+                return;
+            }
+            catch (error) {
+                console.error(`[acp] session/resume(${this.options.resumeAcpSessionId}) failed, falling back to load/new:`, error);
+            }
+        }
+        if (this.options.resumeAcpSessionId &&
+            initialized.agentCapabilities?.loadSession === true &&
+            this.#agent.loadSession) {
+            try {
+                const loaded = await this.#withAuthenticationRetry(() => this.#agent.loadSession({
+                    sessionId: this.options.resumeAcpSessionId,
+                    cwd,
+                    mcpServers,
+                    ...(additionalDirectories.length > 0 ? { additionalDirectories } : {}),
+                    ...(requestMeta ? { _meta: requestMeta } : {}),
+                }));
+                this.#sessionId = this.options.resumeAcpSessionId;
+                this.#configOptions = loaded?.configOptions ?? [];
+                this.#modes = loaded?.modes ?? null;
+                this.#sessionSetupMeta = loaded?._meta ?? null;
+                this.#acceptOutOfBandUpdates = true;
+                this.#logInit("load", initStartedAt, initializedAt);
+                return;
+            }
+            catch (error) {
+                console.error(`[acp] session/load(${this.options.resumeAcpSessionId}) failed, falling back to new:`, error);
+            }
+        }
+        const created = await this.#withAuthenticationRetry(() => this.#agent.newSession({
+            cwd,
+            mcpServers,
+            ...(additionalDirectories.length > 0 ? { additionalDirectories } : {}),
+            ...(requestMeta ? { _meta: requestMeta } : {}),
+        }));
+        this.#sessionId = created.sessionId;
+        this.#configOptions = created.configOptions ?? [];
+        this.#modes = created.modes ?? null;
+        this.#sessionSetupMeta = created._meta ?? null;
+        this.#acceptOutOfBandUpdates = true;
+        this.#logInit("new", initStartedAt, initializedAt);
+    }
+    #createClient(callbacks, supportsUrlElicitation) {
+        return {
+            sessionUpdate: async (params) => {
+                const update = preserveAcpNotificationContext(params);
+                this.#receiveInboundEvent(update, isIdleSessionUpdate(update));
+            },
+            requestPermission: async (params) => {
+                return this.#runClientRequest("session/request_permission", params, async () => {
+                    if (!callbacks.requestPermission) {
+                        return { outcome: { outcome: "cancelled" } };
+                    }
+                    try {
+                        return await callbacks.requestPermission(params);
+                    }
+                    catch (error) {
+                        this.#pushEvent({ type: "requestPermissionError", error: String(error) });
+                        return { outcome: { outcome: "cancelled" } };
+                    }
+                });
+            },
+            readTextFile: callbacks.readTextFile
+                ? async (params) => this.#runClientRequest("fs/read_text_file", params, () => callbacks.readTextFile(params))
+                : undefined,
+            writeTextFile: callbacks.writeTextFile
+                ? async (params) => this.#runClientRequest("fs/write_text_file", params, () => callbacks.writeTextFile(params))
+                : undefined,
+            createTerminal: callbacks.createTerminal
+                ? async (params) => this.#runClientRequest("terminal/create", params, () => callbacks.createTerminal(params))
+                : undefined,
+            terminalOutput: callbacks.terminalOutput
+                ? async (params) => this.#runClientRequest("terminal/output", params, () => callbacks.terminalOutput(params))
+                : undefined,
+            releaseTerminal: callbacks.releaseTerminal
+                ? async (params) => this.#runClientRequest("terminal/release", params, () => callbacks.releaseTerminal(params))
+                : undefined,
+            waitForTerminalExit: callbacks.waitForTerminalExit
+                ? async (params) => this.#runClientRequest("terminal/wait_for_exit", params, () => callbacks.waitForTerminalExit(params))
+                : undefined,
+            killTerminal: callbacks.killTerminal
+                ? async (params) => this.#runClientRequest("terminal/kill", params, () => callbacks.killTerminal(params))
+                : undefined,
+            unstable_createElicitation: callbacks.createElicitation
+                ? async (params) => {
+                    const response = await this.#runClientRequest("elicitation/create", params, () => callbacks.createElicitation(params));
+                    if (params.mode === "url"
+                        && response.action === "accept"
+                        && typeof params.elicitationId === "string") {
+                        this.#outstandingUrlElicitations.add(params.elicitationId);
+                    }
+                    return response;
+                }
+                : undefined,
+            unstable_completeElicitation: supportsUrlElicitation
+                ? async (params) => {
+                    if (!this.#outstandingUrlElicitations.delete(params.elicitationId))
+                        return;
+                    this.#receiveClientNotification("elicitation/complete", params);
+                    await callbacks.completeElicitation?.(params);
+                    this.#receiveInboundEvent({
+                        type: "acp.elicitation_complete",
+                        method: "elicitation/complete",
+                        params,
+                    });
+                }
+                : undefined,
+            extMethod: async (method, params) => this.#runClientRequest(method, params, async () => {
+                if (method === "mcp/connect" && callbacks.connectMcp) {
+                    return callbacks.connectMcp(params);
+                }
+                if (method === "mcp/message" && callbacks.messageMcp) {
+                    return await callbacks.messageMcp(params);
+                }
+                if (method === "mcp/disconnect" && callbacks.disconnectMcp) {
+                    return (await callbacks.disconnectMcp(params)) ?? {};
+                }
+                this.#receiveInboundEvent({
+                    type: "acp.extension_request",
+                    method,
+                    params,
+                });
+                if (callbacks.extensionRequest) {
+                    return callbacks.extensionRequest(method, params);
+                }
+                throw RequestError.methodNotFound(method);
+            }),
+            extNotification: async (method, params) => {
+                this.#receiveClientNotification(method, params);
+                try {
+                    if (method === "mcp/message" && callbacks.notifyMcp) {
+                        await callbacks.notifyMcp(params);
+                        this.#receiveInboundEvent({
+                            type: "acp.mcp_notification",
+                            method,
+                            params,
+                        });
+                        return;
+                    }
+                    await callbacks.extensionNotification?.(method, params);
+                }
+                catch (error) {
+                    console.error("[acp] extension notification callback failed:", error);
+                }
+                this.#receiveInboundEvent({
+                    type: "acp.extension_notification",
+                    method,
+                    params,
+                });
+            },
+        };
+    }
+    async #runClientRequest(method, params, invoke) {
+        const requestId = `client-request-${this.#nextClientRequestId++}`;
+        this.#receiveInboundEvent({
+            type: "acp.client_request",
+            requestId,
+            method,
+            params,
+        });
+        try {
+            const result = await invoke();
+            this.#receiveInboundEvent({
+                type: "acp.client_response",
+                requestId,
+                method,
+                result,
+            });
+            return result;
+        }
+        catch (error) {
+            this.#receiveInboundEvent({
+                type: "acp.client_error",
+                requestId,
+                method,
+                error: clientCallbackError(error),
+            });
+            throw error;
+        }
+    }
+    #receiveClientNotification(method, params) {
+        this.#receiveInboundEvent({
+            type: "acp.client_notification",
+            method,
+            params,
+        });
+    }
+    #receiveInboundEvent(event, allowedBeforeSessionReady = false) {
+        this.#applySessionStateUpdate(event);
+        if (this.#activePromptCount === 0) {
+            if (!this.#acceptOutOfBandUpdates && !allowedBeforeSessionReady)
+                return;
+            if (this.#acceptOutOfBandUpdates && this.options.onOutOfBandSessionUpdate) {
+                try {
+                    this.options.onOutOfBandSessionUpdate(event);
+                }
+                catch (error) {
+                    console.error("[acp] out-of-band session update callback failed:", error);
+                }
+                return;
+            }
+        }
+        this.#pushEvent(event);
+    }
+    #applySessionStateUpdate(event) {
+        if (!event || typeof event !== "object")
+            return;
+        const update = event;
+        if (update.sessionUpdate === "config_option_update"
+            && Array.isArray(update.configOptions)) {
+            this.#configOptions = update.configOptions;
+            return;
+        }
+        if (update.sessionUpdate === "current_mode_update"
+            && typeof update.currentModeId === "string"
+            && this.#modes) {
+            this.#modes = { ...this.#modes, currentModeId: update.currentModeId };
+        }
+    }
+    #logInit(mode, startedAt, initializedAt) {
+        if (process.env.NODE_ENV === "test")
+            return;
+        const completedAt = Date.now();
+        process.stderr.write(`[acp-init] id=${this.id} mode=${mode} initialize_ms=${initializedAt - startedAt} session_open_ms=${completedAt - initializedAt} total_ms=${completedAt - startedAt}\n`);
+    }
+    async #withAuthenticationRetry(open) {
+        try {
+            return await open();
+        }
+        catch (error) {
+            if (!isAuthenticationRequiredError(error))
+                throw error;
+            const method = this.#authMethods.find((candidate) => authMethodType(candidate) === "agent");
+            if (!method)
+                throw error;
+            await this.#agent.authenticate({ methodId: method.id });
+            return await open();
+        }
+    }
+    async authenticate(methodId) {
+        if (!this.#agent)
+            throw new Error("AcpSession not initialized");
+        await this.#agent.authenticate({ methodId });
+    }
+    async setMode(modeId) {
+        if (!this.#agent || !this.#sessionId)
+            throw new Error("AcpSession not initialized");
+        const setSessionMode = this.#agent.setSessionMode;
+        if (typeof setSessionMode !== "function")
+            return;
+        try {
+            await setSessionMode.call(this.#agent, { sessionId: this.#sessionId, modeId });
+            if (this.#modes)
+                this.#modes = { ...this.#modes, currentModeId: modeId };
+        }
+        catch (error) {
+            console.warn(`[acp] setSessionMode("${modeId}") failed:`, error);
+        }
+    }
+    async setConfigOption(configId, value) {
+        if (!this.#agent || !this.#sessionId)
+            throw new Error("AcpSession not initialized");
+        const setSessionConfigOption = this.#agent.setSessionConfigOption;
+        if (typeof setSessionConfigOption !== "function") {
+            throw new Error("ACP agent does not support session config options");
+        }
+        const response = await setSessionConfigOption.call(this.#agent, {
+            sessionId: this.#sessionId,
+            configId,
+            ...(typeof value === "boolean" ? { type: "boolean", value } : { value }),
+        });
+        this.#configOptions = response.configOptions ?? [];
+        return this.#configOptions;
+    }
+    async listSessions(params = {}) {
+        if (!this.#supportsSessionList || !this.#agent?.listSessions) {
+            throw new Error("ACP agent does not support session/list");
+        }
+        return this.#agent.listSessions(params);
+    }
+    async deleteSession(sessionId) {
+        if (!this.#supportsSessionDelete || !this.#agent?.deleteSession) {
+            throw new Error("ACP agent does not support session/delete");
+        }
+        await this.#agent.deleteSession({ sessionId });
+    }
+    async logout() {
+        if (!this.#supportsLogout || !this.#agent?.logout) {
+            throw new Error("ACP agent does not support logout");
+        }
+        await this.#agent.logout({});
+    }
+    async listProviders() {
+        if (!this.#supportsProviders || !this.#agent?.unstable_listProviders) {
+            throw new Error("ACP agent does not support providers/list");
+        }
+        return this.#agent.unstable_listProviders({});
+    }
+    async setProvider(params) {
+        if (!this.#supportsProviders || !this.#agent?.unstable_setProvider) {
+            throw new Error("ACP agent does not support providers/set");
+        }
+        await this.#agent.unstable_setProvider(params);
+    }
+    async disableProvider(providerId) {
+        if (!this.#supportsProviders || !this.#agent?.unstable_disableProvider) {
+            throw new Error("ACP agent does not support providers/disable");
+        }
+        await this.#agent.unstable_disableProvider({ providerId });
+    }
+    async requestExtension(method, params = {}) {
+        if (!this.#agent?.extMethod) {
+            throw new Error("ACP connection does not support extension requests");
+        }
+        return this.#agent.extMethod(method, params);
+    }
+    async notifyExtension(method, params = {}) {
+        if (!this.#agent?.extNotification) {
+            throw new Error("ACP connection does not support extension notifications");
+        }
+        await this.#agent.extNotification(method, params);
+    }
+    async startNes(params) {
+        this.#assertNesMethod(this.#agent?.unstable_startNes, "nes/start");
+        return this.#agent.unstable_startNes(params);
+    }
+    async suggestNes(params) {
+        this.#assertNesMethod(this.#agent?.unstable_suggestNes, "nes/suggest");
+        return this.#agent.unstable_suggestNes(params);
+    }
+    async closeNes(params) {
+        this.#assertNesMethod(this.#agent?.unstable_closeNes, "nes/close");
+        return this.#agent.unstable_closeNes(params);
+    }
+    async didOpenDocument(params) {
+        this.#assertNesDocumentEvent("didOpen", this.#agent?.unstable_didOpenDocument);
+        await this.#agent.unstable_didOpenDocument(params);
+    }
+    async didChangeDocument(params) {
+        this.#assertNesDocumentEvent("didChange", this.#agent?.unstable_didChangeDocument);
+        await this.#agent.unstable_didChangeDocument(params);
+    }
+    async didCloseDocument(params) {
+        this.#assertNesDocumentEvent("didClose", this.#agent?.unstable_didCloseDocument);
+        await this.#agent.unstable_didCloseDocument(params);
+    }
+    async didSaveDocument(params) {
+        this.#assertNesDocumentEvent("didSave", this.#agent?.unstable_didSaveDocument);
+        await this.#agent.unstable_didSaveDocument(params);
+    }
+    async didFocusDocument(params) {
+        this.#assertNesDocumentEvent("didFocus", this.#agent?.unstable_didFocusDocument);
+        await this.#agent.unstable_didFocusDocument(params);
+    }
+    async acceptNes(params) {
+        this.#assertNesMethod(this.#agent?.unstable_acceptNes, "nes/accept");
+        await this.#agent.unstable_acceptNes(params);
+    }
+    async rejectNes(params) {
+        this.#assertNesMethod(this.#agent?.unstable_rejectNes, "nes/reject");
+        await this.#agent.unstable_rejectNes(params);
+    }
+    #assertNesMethod(method, name) {
+        if (!this.#supportsNes || typeof method !== "function") {
+            throw new Error(`ACP agent does not support ${name}`);
+        }
+    }
+    #assertNesDocumentEvent(event, method) {
+        const capability = this.#nesCapabilities?.events?.document?.[event];
+        if (capability == null || typeof method !== "function") {
+            throw new Error(`ACP agent does not support document/${event}`);
+        }
+    }
+    prompt(input, options) {
+        if (this.#disposed)
+            throw new Error(`AcpSession ${this.id} is disposed`);
+        return this.#guardPrompt(this.#prompt(input, options));
+    }
+    async *#guardPrompt(stream) {
+        try {
+            yield* stream;
+        }
+        catch (error) {
+            const exit = this.#childExit ?? await settledChildExit(this.#child.exited);
+            if (exit || isBrokenPipe(error)) {
+                throw agentProcessExitError(this.options.agent.command, exit, error);
+            }
+            throw error;
+        }
+    }
+    async steer(input) {
+        if (!this.#agent || !this.#sessionId)
+            throw new Error("AcpSession not initialized");
+        if (!this.#supportsSteering) {
+            throw new Error("ACP agent did not negotiate _session/steering");
+        }
+        if (!this.#agent.extMethod)
+            throw new Error("ACP connection does not support extensions");
+        const prompt = typeof input === "string"
+            ? [{ type: "text", text: input }]
+            : [...input];
+        const response = await this.#agent.extMethod("_session/steering", {
+            sessionId: this.#sessionId,
+            prompt,
+            _meta: { steering: { idleBehavior: "promptRequired" } },
+        });
+        const outcome = response.outcome;
+        if (outcome !== "injected"
+            && outcome !== "promptRequired"
+            && outcome !== "startedNewTurn"
+            && outcome !== "failed") {
+            throw new Error(`Invalid _session/steering outcome: ${String(outcome)}`);
+        }
+        return outcome;
+    }
+    async cancelCurrentTurn() {
+        if (!this.#agent || !this.#sessionId)
+            throw new Error("AcpSession not initialized");
+        await this.#agent.cancel({ sessionId: this.#sessionId });
+    }
+    async provideToolResult(toolCallId, result) {
+        void toolCallId;
+        void result;
+        throw new Error("provideToolResult not implemented; ACP tools use client callbacks");
+    }
+    drainPendingEvents() {
+        return this.#pendingEvents.splice(0);
+    }
+    async *#prompt(input, options) {
+        const turnAbort = new AbortController();
+        const onAbort = () => {
+            Promise.resolve(this.#agent.cancel({ sessionId: this.#sessionId }))
+                .catch(() => { });
+        };
+        const abortTurn = () => turnAbort.abort();
+        const timeoutMs = this.options.perTurnTimeoutMs;
+        let timer;
+        let turnFinished = false;
+        const finishTurn = () => {
+            if (turnFinished)
+                return;
+            turnFinished = true;
+            this.#activePromptCount = Math.max(0, this.#activePromptCount - 1);
+            if (timer)
+                clearTimeout(timer);
+            options?.abortSignal?.removeEventListener("abort", abortTurn);
+        };
+        options?.abortSignal?.addEventListener("abort", abortTurn, { once: true });
+        turnAbort.signal.addEventListener("abort", onAbort, { once: true });
+        if (options?.abortSignal?.aborted)
+            turnAbort.abort();
+        this.#activePromptCount += 1;
+        const prompt = typeof input === "string" ? [{ type: "text", text: input }] : [...input];
+        const done = Promise.resolve(this.#agent.prompt({ sessionId: this.#sessionId, prompt }))
+            .finally(finishTurn);
+        let ended = false;
+        let timedOut = false;
+        if (timeoutMs) {
+            timer = setTimeout(() => {
+                if (ended)
+                    return;
+                timedOut = true;
+                ended = true;
+                turnAbort.abort();
+                const message = `ACP prompt timed out after ${timeoutMs}ms`;
+                this.#pushEvent({
+                    type: "promptError",
+                    error: `Error: ${message}`,
+                    errorDetails: { message },
+                });
+                this.#endStream();
+                finishTurn();
+            }, timeoutMs);
+        }
+        void done.then((response) => {
+            if (timedOut || ended)
+                return;
+            ended = true;
+            this.#pushEvent({ type: "promptComplete", response });
+            this.#endStream();
+        }, (error) => {
+            if (timedOut || ended)
+                return;
+            ended = true;
+            // Keep the legacy display string, but retain the JSON-RPC evidence
+            // so hosts can classify failures without interpreting message text.
+            const rpcError = error !== null && typeof error === "object"
+                ? error
+                : undefined;
+            this.#pushEvent({
+                type: "promptError",
+                error: String(error),
+                errorDetails: {
+                    message: typeof rpcError?.message === "string"
+                        ? rpcError.message
+                        : String(error),
+                    ...(typeof rpcError?.code === "number" ? { code: rpcError.code } : {}),
+                    ...(rpcError?.data !== undefined ? { data: rpcError.data } : {}),
+                },
+            });
+            this.#endStream();
+        });
+        while (true) {
+            if (this.#pendingEvents.length > 0) {
+                yield this.#pendingEvents.shift();
+            }
+            else if (ended) {
+                break;
+            }
+            else {
+                await new Promise((resolve) => {
+                    this.#waiters.push(() => resolve());
+                });
+            }
+        }
+        if (!timedOut)
+            await done;
+    }
+    isAlive() {
+        return !this.#disposed && this.#childExit === null;
+    }
+    dispose() {
+        this.#disposePromise ??= this.#disposeOnce();
+        return this.#disposePromise;
+    }
+    async #disposeOnce() {
+        if (this.#supportsSessionClose && this.#sessionId && this.#agent?.closeSession) {
+            try {
+                await this.#agent.closeSession({ sessionId: this.#sessionId });
+            }
+            catch (error) {
+                console.warn(`[acp] session/close(${this.#sessionId}) failed:`, error);
+            }
+        }
+        this.#disposed = true;
+        this.#outstandingUrlElicitations.clear();
+        this.#endStream();
+        await this.#child.kill("SIGTERM").catch(() => { });
+    }
+    #pushEvent(event) {
+        this.#pendingEvents.push(event);
+        this.#waiters.shift()?.({ value: undefined, done: false });
+    }
+    #endStream() {
+        while (this.#waiters.length > 0) {
+            this.#waiters.shift()?.({ value: undefined, done: true });
+        }
+    }
+}
+async function settledChildExit(exited) {
+    let timer;
+    try {
+        return await Promise.race([
+            exited,
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve(null), 25);
+                timer.unref?.();
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+function isBrokenPipe(error) {
+    const code = error && typeof error === "object" && "code" in error
+        ? String(error.code ?? "")
+        : "";
+    const message = error instanceof Error ? error.message : String(error);
+    return (code === "EPIPE"
+        || code === "ERR_STREAM_DESTROYED"
+        || /\bEPIPE\b|broken pipe|stream (?:is )?(?:closed|destroyed)/i.test(message));
+}
+function agentProcessExitError(command, exit, cause) {
+    const status = exit?.signal
+        ? `signal ${exit.signal}`
+        : exit?.code != null
+            ? `exit code ${exit.code}`
+            : "no exit status";
+    return new Error(`The agent process exited before it could accept the prompt (${command}, ${status}). `
+        + "Reopen the task to restart it, or check this agent's setup and sign-in.", { cause });
+}
+function clientCallbackError(error) {
+    const code = error !== null
+        && typeof error === "object"
+        && typeof error.code === "number"
+        ? error.code
+        : undefined;
+    const message = code === -32601
+        ? "Method not found"
+        : error instanceof Error
+            ? error.message
+            : String(error);
+    return {
+        message,
+        ...(code !== undefined ? { code } : {}),
+    };
+}
+const IDLE_SESSION_UPDATES = new Set([
+    "available_commands_update",
+    "current_mode_update",
+    "config_option_update",
+    "session_info_update",
+]);
+function isIdleSessionUpdate(update) {
+    const tag = update?.sessionUpdate;
+    return typeof tag === "string" && IDLE_SESSION_UPDATES.has(tag);
+}
+function authMethodType(method) {
+    return typeof method.type === "string" && method.type.length > 0 ? method.type : "agent";
+}
+function sessionRequestDeclaresAirFork(meta) {
+    if (!meta || !isPlainRecord(meta.jetbrains) || !isPlainRecord(meta.jetbrains.air))
+        return false;
+    return Object.hasOwn(meta.jetbrains.air, "fork");
+}
+function mergeSessionRequestMeta(base, extra) {
+    const merged = { ...(base ?? {}) };
+    for (const [key, value] of Object.entries(extra)) {
+        const current = merged[key];
+        if (isPlainRecord(current) && isPlainRecord(value)) {
+            merged[key] = mergeSessionRequestMeta(current, value);
+        }
+        else {
+            merged[key] = value;
+        }
+    }
+    return merged;
+}
+function isPlainRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Clone `configOptions` from a session-setup response. When the response
+ * still carries the retired `models` catalog and no option already has
+ * category or id `model`, append a select marked as legacy model state. */
+export function sessionConfigOptionsFromResponse(value) {
+    const responseConfigOptions = value && typeof value === "object"
+        ? value.configOptions
+        : undefined;
+    const configOptions = Array.isArray(responseConfigOptions)
+        ? responseConfigOptions.map((option) => structuredClone(option))
+        : [];
+    const legacyModels = legacyModelStateFromResponse(value);
+    if (legacyModels && !configOptions.some(isModelConfigOption)) {
+        configOptions.push(legacyModelConfigOption(legacyModels));
+    }
+    return configOptions;
+}
+function legacyModelStateFromResponse(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const models = value.models;
+    if (!models || typeof models !== "object")
+        return null;
+    const currentModelId = models.currentModelId;
+    const availableModels = models.availableModels;
+    if (typeof currentModelId !== "string" || !Array.isArray(availableModels))
+        return null;
+    const normalized = availableModels.flatMap((model) => {
+        if (!model || typeof model !== "object")
+            return [];
+        const candidate = model;
+        if (typeof candidate.modelId !== "string" || typeof candidate.name !== "string")
+            return [];
+        return [{
+                modelId: candidate.modelId,
+                name: candidate.name,
+                ...(typeof candidate.description === "string"
+                    ? { description: candidate.description }
+                    : {}),
+            }];
+    });
+    if (normalized.length === 0)
+        return null;
+    return { currentModelId, availableModels: normalized };
+}
+function isModelConfigOption(option) {
+    return option?.category === "model" || option?.id === "model";
+}
+function legacyModelConfigOption(state) {
+    return {
+        id: "model",
+        name: "Model",
+        category: "model",
+        type: "select",
+        currentValue: state.currentModelId,
+        options: state.availableModels.map((model) => ({
+            value: model.modelId,
+            name: model.name,
+            ...(model.description ? { description: model.description } : {}),
+        })),
+        _meta: { [LEGACY_MODEL_META_KEY]: true },
+    };
+}
+/** Merge a host capability overlay into the runtime's initialize advertisement.
+ * `fs` and `session.configOptions` merge one level. `auth._meta` and top-level
+ * `_meta` merge key by key. Overlay values win. */
+export function mergeClientCapabilities(base, extra) {
+    const left = base ?? {};
+    const leftSession = left.session;
+    const rightSession = extra.session;
+    const leftAuth = left.auth;
+    const rightAuth = extra.auth;
+    return {
+        ...left,
+        ...extra,
+        ...(left.fs || extra.fs ? { fs: { ...left.fs, ...extra.fs } } : {}),
+        ...(leftSession || rightSession
+            ? {
+                session: {
+                    ...(leftSession ?? {}),
+                    ...(rightSession ?? {}),
+                    ...(leftSession?.configOptions || rightSession?.configOptions
+                        ? {
+                            configOptions: {
+                                ...(leftSession?.configOptions ?? {}),
+                                ...(rightSession?.configOptions ?? {}),
+                            },
+                        }
+                        : {}),
+                },
+            }
+            : {}),
+        ...(leftAuth || rightAuth
+            ? {
+                auth: {
+                    ...(leftAuth ?? {}),
+                    ...(rightAuth ?? {}),
+                    ...(leftAuth?._meta || rightAuth?._meta
+                        ? { _meta: { ...(leftAuth?._meta ?? {}), ...(rightAuth?._meta ?? {}) } }
+                        : {}),
+                },
+            }
+            : {}),
+        ...(left._meta || extra._meta
+            ? { _meta: { ...(left._meta ?? {}), ...(extra._meta ?? {}) } }
+            : {}),
+    };
+}
+function observeLegacyModels(source, onModels) {
+    const decoder = new TextDecoder();
+    let pending = "";
+    let found = false;
+    return source.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            if (!found) {
+                pending += decoder.decode(chunk, { stream: true });
+                let end = pending.indexOf("\n");
+                while (end >= 0) {
+                    const line = pending.slice(0, end);
+                    pending = pending.slice(end + 1);
+                    const models = legacyModelsFromLine(line);
+                    if (models) {
+                        found = true;
+                        onModels(models);
+                        break;
+                    }
+                    end = pending.indexOf("\n");
+                }
+            }
+            controller.enqueue(chunk);
+        },
+    }));
+}
+function legacyModelsFromLine(line) {
+    try {
+        const models = JSON.parse(line)?.result?.models;
+        if (!models
+            || typeof models.currentModelId !== "string"
+            || !Array.isArray(models.availableModels)) {
+            return null;
+        }
+        const availableModels = [];
+        for (const model of models.availableModels) {
+            if (!model
+                || typeof model.modelId !== "string"
+                || typeof model.name !== "string") {
+                return null;
+            }
+            availableModels.push({ modelId: model.modelId, name: model.name });
+        }
+        return { currentModelId: models.currentModelId, availableModels };
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=session.js.map