@moxt-ai/mobius 0.0.2 → 0.0.4

package/dist/acp/session-manager.js

@@ -1,13 +1,44 @@
 import { spawn } from "node:child_process";
 import { once } from "node:events";
 import { methods, ndJsonStream, PROTOCOL_VERSION, } from "@agentclientprotocol/sdk";
-import { AcpActivityTracker, isProgressMessage, } from "./activity.js";
+import { AGENT_CONTENT_KIND, MOBIUS_PROTOCOL_VERSION, SESSION_COMMANDS_UPDATED_KIND, SESSION_CONFIG_UPDATED_KIND, SESSION_ELICITATION_REQUESTED_KIND, SESSION_ELICITATION_RESOLVED_KIND, SESSION_INFO_UPDATED_KIND, SESSION_PERMISSION_REQUESTED_KIND, SESSION_PERMISSION_RESOLVED_KIND, SESSION_USAGE_UPDATED_KIND, } from "@moxt-ai/mobius-protocol";
+import { AcpActivityTracker, isProgressMessage, normalizeContentBlock, } from "./activity.js";
 import { createAcpClient } from "./create-client.js";
+import { AcpStoredSession, FoundAcpStoredSession, MemoryAcpSessionStore, } from "./session-store.js";
 const PROCESS_STOP_TIMEOUT_MILLISECONDS = 1_000;
+const SESSION_CONTROL_COMMAND_ID = "session-control";
+export class NullAcpSessionObserver {
+    onCommands = () => Promise.resolve();
+    onConfig = () => Promise.resolve();
+    onContent = () => Promise.resolve();
+    onElicitation = () => Promise.resolve();
+    onElicitationResolved = () => Promise.resolve();
+    onInfo = () => Promise.resolve();
+    onPermission = () => Promise.resolve();
+    onPermissionResolved = () => Promise.resolve();
+    onUsage = () => Promise.resolve();
+}
+export class AcpPreparedSession {
+    agentName;
+    agentVersion;
+    capabilities;
+    commands;
+    configOptions;
+    restored;
+    constructor(agentName, agentVersion, capabilities, commands, configOptions, restored) {
+        this.agentName = agentName;
+        this.agentVersion = agentVersion;
+        this.capabilities = capabilities;
+        this.commands = commands;
+        this.configOptions = configOptions;
+        this.restored = restored;
+    }
+}
 export class AcpExecutionError extends Error {
-    code = "acp_execution_failed";
-    constructor(message, options = {}) {
+    code;
+    constructor(message, options = {}, code = "acp_execution_failed") {
         super(message, options);
+        this.code = code;
         this.name = "AcpExecutionError";
     }
 }
@@ -46,15 +77,40 @@ function readableWebStream(input) {
         },
     });
 }
-function writableWebStream(output) {
+export function createWritableAcpStream(output) {
+    let outputFailure;
+    const pendingWriteFailures = new Set();
+    const fail = (error) => {
+        outputFailure = error;
+        for (const reject of pendingWriteFailures) {
+            reject(error);
+        }
+        pendingWriteFailures.clear();
+    };
+    output.on("error", fail);
+    output.once("close", () => {
+        if (outputFailure === undefined) {
+            fail(new Error("ACP process input closed"));
+        }
+    });
     return new WritableStream({
         write(chunk) {
+            if (outputFailure !== undefined) {
+                return Promise.reject(outputFailure);
+            }
             return new Promise((resolve, reject) => {
+                pendingWriteFailures.add(reject);
                 output.write(chunk, (error) => {
+                    pendingWriteFailures.delete(reject);
                     if (error) {
+                        outputFailure = error;
                         reject(error);
                         return;
                     }
+                    if (outputFailure !== undefined) {
+                        reject(outputFailure);
+                        return;
+                    }
                     resolve();
                 });
             });
@@ -75,176 +131,1199 @@ async function stopAgentProcess(child) {
     catch {
         if (child.exitCode === null) {
             child.kill("SIGKILL");
-            await once(child, "exit");
+            try {
+                await once(child, "exit", {
+                    signal: AbortSignal.timeout(PROCESS_STOP_TIMEOUT_MILLISECONDS),
+                });
+            }
+            catch {
+                // Teardown must not wait forever for a process the OS did not reap.
+            }
         }
     }
 }
-function rejectWhenAborted(signal) {
-    return new Promise((_resolve, reject) => {
-        const rejectAbort = () => {
-            reject(signal.reason ?? new Error("ACP request was cancelled"));
-        };
-        signal.addEventListener("abort", rejectAbort, { once: true });
-        if (signal.aborted) {
-            rejectAbort();
+function truncate(value, maximumLength) {
+    return value.length <= maximumLength
+        ? value
+        : `${value.slice(0, Math.max(0, maximumLength - 1))}…`;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value, fallback = "") {
+    return typeof value === "string" ? value : fallback;
+}
+function readBoolean(value, fallback = false) {
+    return typeof value === "boolean" ? value : fallback;
+}
+function arraysEqual(left, right) {
+    return (left.length === right.length &&
+        left.every((value, index) => value === right[index]));
+}
+function normalizeConfigValue(option, groupId = "", groupName = "") {
+    return {
+        description: truncate(readString(option["description"]), 500),
+        groupId: truncate(groupId, 128),
+        groupName: truncate(groupName, 255),
+        name: truncate(readString(option["name"], readString(option["value"])), 255),
+        value: truncate(readString(option["value"]), 500),
+    };
+}
+function normalizeConfigValues(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const normalized = [];
+    for (const entry of value) {
+        if (!isRecord(entry)) {
+            continue;
         }
-    });
+        const groupedOptions = entry["options"];
+        if (Array.isArray(groupedOptions)) {
+            const groupId = readString(entry["group"]);
+            const groupName = readString(entry["name"]);
+            for (const groupedOption of groupedOptions) {
+                if (isRecord(groupedOption)) {
+                    normalized.push(normalizeConfigValue(groupedOption, groupId, groupName));
+                }
+            }
+            continue;
+        }
+        normalized.push(normalizeConfigValue(entry));
+    }
+    return normalized.filter((entry) => entry.value.length > 0).slice(0, 500);
+}
+function normalizeConfigOptions(value, modes) {
+    const normalized = [];
+    if (Array.isArray(value)) {
+        for (const option of value) {
+            if (!isRecord(option)) {
+                continue;
+            }
+            const id = truncate(readString(option["id"]), 128);
+            const name = truncate(readString(option["name"], id), 255);
+            if (id.length === 0 || name.length === 0) {
+                continue;
+            }
+            if (option["type"] === "boolean") {
+                normalized.push({
+                    booleanValue: readBoolean(option["currentValue"]),
+                    category: truncate(readString(option["category"]), 128),
+                    currentValue: "",
+                    description: truncate(readString(option["description"]), 500),
+                    id,
+                    name,
+                    type: "boolean",
+                    values: [],
+                });
+                continue;
+            }
+            if (option["type"] === "select") {
+                const values = normalizeConfigValues(option["options"]);
+                const currentValue = truncate(readString(option["currentValue"]), 500);
+                if (currentValue.length > 0 &&
+                    values.some((entry) => entry.value === currentValue)) {
+                    normalized.push({
+                        booleanValue: false,
+                        category: truncate(readString(option["category"]), 128),
+                        currentValue,
+                        description: truncate(readString(option["description"]), 500),
+                        id,
+                        name,
+                        type: "select",
+                        values,
+                    });
+                }
+            }
+        }
+    }
+    if (isRecord(modes)) {
+        const values = [];
+        const availableModes = modes["availableModes"];
+        if (Array.isArray(availableModes)) {
+            for (const mode of availableModes) {
+                if (!isRecord(mode)) {
+                    continue;
+                }
+                const id = truncate(readString(mode["id"]), 500);
+                if (id.length === 0) {
+                    continue;
+                }
+                values.push({
+                    description: truncate(readString(mode["description"]), 500),
+                    groupId: "",
+                    groupName: "",
+                    name: truncate(readString(mode["name"], id), 255),
+                    value: id,
+                });
+            }
+        }
+        const currentValue = truncate(readString(modes["currentModeId"]), 500);
+        if (currentValue.length > 0 &&
+            values.some((entry) => entry.value === currentValue) &&
+            !normalized.some((entry) => entry.category === "mode")) {
+            normalized.unshift({
+                booleanValue: false,
+                category: "mode",
+                currentValue,
+                description: "Agent session mode",
+                id: "mode",
+                name: "Mode",
+                type: "select",
+                values,
+            });
+        }
+    }
+    return normalized.slice(0, 100);
+}
+function replaceConfigOptionsKeepingMode(current, value) {
+    const next = normalizeConfigOptions(value, undefined);
+    if (next.some((option) => option.category === "mode")) {
+        return next;
+    }
+    return [
+        ...current.filter((option) => option.category === "mode"),
+        ...next,
+    ].slice(0, 100);
+}
+function normalizeCapabilities(capabilities) {
+    const session = capabilities.sessionCapabilities;
+    const prompt = capabilities.promptCapabilities;
+    return {
+        additionalDirectories: session?.additionalDirectories != null,
+        audioPrompt: prompt?.audio === true,
+        closeSession: session?.close != null,
+        deleteSession: session?.delete != null,
+        embeddedContextPrompt: prompt?.embeddedContext === true,
+        imagePrompt: prompt?.image === true,
+        listSessions: session?.list != null,
+        loadSession: capabilities.loadSession === true,
+        resumeSession: session?.resume != null,
+    };
+}
+function elicitationFieldType(value) {
+    if (value === "boolean") {
+        return "boolean";
+    }
+    if (value === "integer") {
+        return "integer";
+    }
+    if (value === "number") {
+        return "number";
+    }
+    if (value === "array") {
+        return "multiselect";
+    }
+    return "string";
+}
+function normalizeElicitationOptions(schema) {
+    const normalized = [];
+    const oneOf = schema["oneOf"];
+    if (Array.isArray(oneOf)) {
+        for (const option of oneOf) {
+            if (isRecord(option) && typeof option["const"] === "string") {
+                normalized.push({
+                    description: truncate(readString(option["description"]), 500),
+                    label: truncate(readString(option["title"], option["const"]), 255),
+                    value: truncate(option["const"], 500),
+                });
+            }
+        }
+        return normalized.slice(0, 200);
+    }
+    const enumValues = schema["enum"];
+    if (Array.isArray(enumValues)) {
+        for (const entry of enumValues) {
+            if (typeof entry === "string") {
+                normalized.push({ description: "", label: entry, value: entry });
+            }
+        }
+        return normalized.slice(0, 200);
+    }
+    const items = schema["items"];
+    if (!isRecord(items)) {
+        return normalized;
+    }
+    const anyOf = items["anyOf"];
+    if (Array.isArray(anyOf)) {
+        return normalizeElicitationOptions({ oneOf: anyOf });
+    }
+    return normalizeElicitationOptions({ enum: items["enum"] });
+}
+function numericString(value) {
+    return typeof value === "number" && Number.isFinite(value)
+        ? value.toString()
+        : "";
+}
+function normalizeElicitationFields(requestedSchema) {
+    if (!isRecord(requestedSchema) || !isRecord(requestedSchema["properties"])) {
+        return [];
+    }
+    const properties = requestedSchema["properties"];
+    const requiredValues = requestedSchema["required"];
+    const required = new Set(Array.isArray(requiredValues)
+        ? requiredValues.filter((entry) => typeof entry === "string")
+        : []);
+    const normalized = [];
+    for (const [name, property] of Object.entries(properties)) {
+        if (!isRecord(property)) {
+            continue;
+        }
+        const type = elicitationFieldType(property["type"]);
+        const options = normalizeElicitationOptions(property);
+        const normalizedType = type === "string" && options.length > 0 ? "select" : type;
+        const defaultValue = property["default"];
+        normalized.push({
+            defaultBooleanValue: typeof defaultValue === "boolean" ? defaultValue : false,
+            defaultNumberValue: typeof defaultValue === "number" && Number.isFinite(defaultValue)
+                ? defaultValue
+                : 0,
+            defaultStringValue: typeof defaultValue === "string"
+                ? truncate(defaultValue, 10_000)
+                : Array.isArray(defaultValue)
+                    ? truncate(JSON.stringify(defaultValue), 10_000)
+                    : "",
+            description: truncate(readString(property["description"]), 500),
+            format: truncate(readString(property["format"]), 64),
+            hasDefaultValue: defaultValue !== undefined && defaultValue !== null,
+            maximum: numericString(property["maximum"]),
+            maximumLength: numericString(property["maxLength"] ?? property["maxItems"]),
+            minimum: numericString(property["minimum"]),
+            minimumLength: numericString(property["minLength"] ?? property["minItems"]),
+            name: truncate(name, 128),
+            options,
+            pattern: truncate(readString(property["pattern"]), 500),
+            required: required.has(name),
+            title: truncate(readString(property["title"], name), 255),
+            type: normalizedType,
+        });
+    }
+    return normalized.slice(0, 100);
+}
+function validateStringValue(name, value, schema) {
+    const minimum = schema["minLength"];
+    const maximum = schema["maxLength"];
+    if (typeof minimum === "number" && value.length < minimum) {
+        throw new AcpExecutionError(`Elicitation field ${name} is shorter than allowed`, {}, "invalid_elicitation_response");
+    }
+    if (typeof maximum === "number" && value.length > maximum) {
+        throw new AcpExecutionError(`Elicitation field ${name} is longer than allowed`, {}, "invalid_elicitation_response");
+    }
+    const pattern = schema["pattern"];
+    if (typeof pattern === "string" && !new RegExp(pattern, "u").test(value)) {
+        throw new AcpExecutionError(`Elicitation field ${name} does not match the required format`, {}, "invalid_elicitation_response");
+    }
+    const allowed = normalizeElicitationOptions(schema);
+    if (allowed.length > 0 && !allowed.some((entry) => entry.value === value)) {
+        throw new AcpExecutionError(`Elicitation field ${name} is not an allowed value`, {}, "invalid_elicitation_response");
+    }
+}
+function validateNumericValue(name, value, schema, integer) {
+    if (!Number.isFinite(value) || (integer && !Number.isInteger(value))) {
+        throw new AcpExecutionError(`Elicitation field ${name} is not a valid number`, {}, "invalid_elicitation_response");
+    }
+    const minimum = schema["minimum"];
+    const maximum = schema["maximum"];
+    if ((typeof minimum === "number" && value < minimum) ||
+        (typeof maximum === "number" && value > maximum)) {
+        throw new AcpExecutionError(`Elicitation field ${name} is outside the allowed range`, {}, "invalid_elicitation_response");
+    }
+}
+function validateElicitationContent(encoded, requestedSchema) {
+    let decoded;
+    try {
+        decoded = JSON.parse(encoded);
+    }
+    catch (error) {
+        throw new AcpExecutionError("Elicitation response is not valid JSON", { cause: error }, "invalid_elicitation_response");
+    }
+    if (!isRecord(decoded) ||
+        !isRecord(requestedSchema) ||
+        !isRecord(requestedSchema["properties"])) {
+        throw new AcpExecutionError("Elicitation response does not match the requested form", {}, "invalid_elicitation_response");
+    }
+    const properties = requestedSchema["properties"];
+    const requiredValue = requestedSchema["required"];
+    const required = new Set(Array.isArray(requiredValue)
+        ? requiredValue.filter((entry) => typeof entry === "string")
+        : []);
+    for (const name of required) {
+        if (!(name in decoded)) {
+            throw new AcpExecutionError(`Elicitation field ${name} is required`, {}, "invalid_elicitation_response");
+        }
+    }
+    const validated = {};
+    for (const [name, value] of Object.entries(decoded)) {
+        const property = properties[name];
+        if (!isRecord(property)) {
+            throw new AcpExecutionError(`Elicitation field ${name} was not requested`, {}, "invalid_elicitation_response");
+        }
+        if (property["type"] === "string" && typeof value === "string") {
+            validateStringValue(name, value, property);
+            validated[name] = value;
+            continue;
+        }
+        if (property["type"] === "number" && typeof value === "number") {
+            validateNumericValue(name, value, property, false);
+            validated[name] = value;
+            continue;
+        }
+        if (property["type"] === "integer" && typeof value === "number") {
+            validateNumericValue(name, value, property, true);
+            validated[name] = value;
+            continue;
+        }
+        if (property["type"] === "boolean" && typeof value === "boolean") {
+            validated[name] = value;
+            continue;
+        }
+        if (property["type"] === "array" &&
+            Array.isArray(value) &&
+            value.every((entry) => typeof entry === "string")) {
+            const minimum = property["minItems"];
+            const maximum = property["maxItems"];
+            if ((typeof minimum === "number" && value.length < minimum) ||
+                (typeof maximum === "number" && value.length > maximum)) {
+                throw new AcpExecutionError(`Elicitation field ${name} has an invalid selection count`, {}, "invalid_elicitation_response");
+            }
+            const allowed = normalizeElicitationOptions(property);
+            if (allowed.length > 0 &&
+                value.some((entry) => !allowed.some((option) => option.value === entry))) {
+                throw new AcpExecutionError(`Elicitation field ${name} contains an invalid selection`, {}, "invalid_elicitation_response");
+            }
+            validated[name] = value;
+            continue;
+        }
+        throw new AcpExecutionError(`Elicitation field ${name} has the wrong type`, {}, "invalid_elicitation_response");
+    }
+    return validated;
+}
+class AcpTurnState {
+}
+class IdleAcpTurn extends AcpTurnState {
+    commandId = SESSION_CONTROL_COMMAND_ID;
+    running = false;
+    activities = new AcpActivityTracker(() => Promise.resolve());
+    onText = () => Promise.resolve();
+}
+class RunningAcpTurn extends AcpTurnState {
+    commandId;
+    running = true;
+    activities;
+    onText;
+    constructor(commandId, onActivity, onText) {
+        super();
+        this.commandId = commandId;
+        this.activities = new AcpActivityTracker(onActivity);
+        this.onText = onText;
+    }
+}
+class PendingPermission {
+    completion = Promise.withResolvers();
+    interactionId;
+    optionIds;
+    #settled = false;
+    constructor(interactionId, optionIds) {
+        this.interactionId = interactionId;
+        this.optionIds = optionIds;
+    }
+    cancel = () => {
+        if (this.#settled) {
+            return false;
+        }
+        this.#settled = true;
+        this.completion.resolve({ outcome: { outcome: "cancelled" } });
+        return true;
+    };
+    select = (optionId) => {
+        if (this.#settled) {
+            return false;
+        }
+        this.#settled = true;
+        this.completion.resolve({
+            outcome: { optionId, outcome: "selected" },
+        });
+        return true;
+    };
+}
+class PendingElicitation {
+    completion = Promise.withResolvers();
+    elicitationId;
+    interactionId;
+    requestedSchema;
+    #settled = false;
+    constructor(interactionId, elicitationId, requestedSchema) {
+        this.elicitationId = elicitationId;
+        this.interactionId = interactionId;
+        this.requestedSchema = requestedSchema;
+    }
+    accept = (content) => {
+        if (this.#settled) {
+            return false;
+        }
+        this.#settled = true;
+        this.completion.resolve({ action: "accept", content });
+        return true;
+    };
+    cancel = () => {
+        if (this.#settled) {
+            return false;
+        }
+        this.#settled = true;
+        this.completion.resolve({ action: "cancel" });
+        return true;
+    };
+    decline = () => {
+        if (this.#settled) {
+            return false;
+        }
+        this.#settled = true;
+        this.completion.resolve({ action: "decline" });
+        return true;
+    };
 }
 class AcpProcessSession {
+    #additionalDirectories;
+    #acceptedUrlElicitations = new Map();
     #agentId;
     #child;
     #connection;
+    #cwd;
+    #getObserver;
+    #mobiusSessionId;
+    #pendingElicitations = new Map();
+    #pendingPermissions = new Map();
     #processExit;
-    #session;
-    #turnRunning = false;
-    constructor(agentId, child, connection, session, processExit) {
-        this.#agentId = agentId;
-        this.#child = child;
-        this.#connection = connection;
-        this.#session = session;
-        this.#processExit = processExit;
-    }
-    static async start(agent, cwd, signal) {
-        signal.throwIfAborted();
-        const child = spawn(agent.command, [...agent.arguments], {
+    #store;
+    #agentName = "";
+    #agentVersion = "";
+    #capabilities = {
+        additionalDirectories: false,
+        audioPrompt: false,
+        closeSession: false,
+        deleteSession: false,
+        embeddedContextPrompt: false,
+        imagePrompt: false,
+        listSessions: false,
+        loadSession: false,
+        resumeSession: false,
+    };
+    #commands = [];
+    #configOptions = [];
+    #nativeSessionId = "";
+    #prompted = false;
+    #replaying = false;
+    #restored = false;
+    #sessionTitle = "";
+    #sessionUpdatedAt = "";
+    #turn = new IdleAcpTurn();
+    #updateTail = Promise.resolve();
+    constructor(agent, cwd, additionalDirectories, mobiusSessionId, getObserver, store) {
+        this.#additionalDirectories = [...additionalDirectories];
+        this.#agentId = agent.id;
+        this.#cwd = cwd;
+        this.#getObserver = getObserver;
+        this.#mobiusSessionId = mobiusSessionId;
+        this.#store = store;
+        this.#child = spawn(agent.command, [...agent.arguments], {
             cwd,
             stdio: ["pipe", "pipe", "pipe"],
         });
-        child.stderr.setEncoding("utf8");
-        child.stderr.on("data", (chunk) => {
+        const stdin = this.#child.stdin;
+        const stdout = this.#child.stdout;
+        const stderr = this.#child.stderr;
+        if (stdin === null || stdout === null || stderr === null) {
+            this.#child.kill("SIGKILL");
+            throw new AcpExecutionError("ACP process streams are unavailable");
+        }
+        stderr.setEncoding("utf8");
+        stderr.on("data", (chunk) => {
             process.stderr.write(`[${agent.id}-acp] ${chunk}`);
         });
-        const processExit = new Promise((resolve) => {
-            child.once("error", resolve);
-            child.once("exit", resolve);
+        this.#processExit = new Promise((resolve) => {
+            this.#child.once("error", resolve);
+            this.#child.once("exit", resolve);
         });
-        const stream = ndJsonStream(writableWebStream(child.stdin), readableWebStream(child.stdout));
-        const connection = createAcpClient().connect(stream);
+        const stream = ndJsonStream(createWritableAcpStream(stdin), readableWebStream(stdout));
+        this.#connection = createAcpClient(this).connect(stream);
+    }
+    static start = async (options, getObserver, store) => {
+        options.signal.throwIfAborted();
+        const runtime = new AcpProcessSession(options.agent, options.cwd, options.additionalDirectories, options.sessionId, getObserver, store);
         try {
-            await Promise.race([
-                connection.agent.request(methods.agent.initialize, {
-                    clientCapabilities: {},
-                    protocolVersion: PROTOCOL_VERSION,
-                }, { cancellationSignal: signal }),
-                processExit.then(() => {
-                    throw new AcpExecutionError("ACP agent exited during initialization");
-                }),
-                rejectWhenAborted(signal),
-            ]);
-            const session = await Promise.race([
-                connection.agent
-                    .buildSession(cwd)
-                    .start({ cancellationSignal: signal }),
-                processExit.then(() => {
-                    throw new AcpExecutionError("ACP agent exited while starting a session");
-                }),
-                rejectWhenAborted(signal),
-            ]);
-            return new AcpProcessSession(agent.id, child, connection, session, processExit);
+            await runtime.initialize(options.signal);
+            return runtime;
         }
         catch (error) {
-            connection.close(error);
-            await stopAgentProcess(child);
+            await runtime.closeProcess();
+            if (error instanceof AcpExecutionError) {
+                throw error;
+            }
             throw new AcpExecutionError("ACP agent initialization failed", {
                 cause: error,
             });
         }
-    }
-    belongsTo = (agentId) => this.#agentId === agentId;
+    };
+    belongsTo = (agentId, cwd, additionalDirectories) => this.#agentId === agentId &&
+        this.#cwd === cwd &&
+        arraysEqual(this.#additionalDirectories, additionalDirectories);
+    canRebind = () => !this.#prompted && !this.#turn.running;
+    prepared = () => new AcpPreparedSession(this.#agentName, this.#agentVersion, this.#capabilities, this.#commands, this.#configOptions, this.#restored);
+    initialize = async (signal) => {
+        const initialized = await this.race(this.#connection.agent.request(methods.agent.initialize, {
+            clientCapabilities: {
+                elicitation: { form: {}, url: {} },
+                plan: {},
+                session: { configOptions: { boolean: {} } },
+            },
+            clientInfo: { name: "mobius", version: "0.0.2" },
+            protocolVersion: PROTOCOL_VERSION,
+        }, { cancellationSignal: signal }), "ACP agent exited during initialization", signal);
+        if (initialized.protocolVersion !== PROTOCOL_VERSION) {
+            throw new AcpExecutionError("ACP agent selected an unsupported protocol version", {}, "unsupported_acp_protocol");
+        }
+        const capabilities = initialized.agentCapabilities ?? {};
+        this.#capabilities = normalizeCapabilities(capabilities);
+        this.#agentName = truncate(initialized.agentInfo?.title ??
+            initialized.agentInfo?.name ??
+            this.#agentId, 255);
+        this.#agentVersion = truncate(initialized.agentInfo?.version ?? "", 128);
+        const stored = this.#store.read(this.#mobiusSessionId);
+        let lifecycleResponse;
+        if (stored instanceof FoundAcpStoredSession &&
+            stored.session.agentId === this.#agentId &&
+            stored.session.cwd === this.#cwd &&
+            arraysEqual(stored.session.additionalDirectories, this.#additionalDirectories)) {
+            this.#nativeSessionId = stored.session.nativeSessionId;
+            this.#prompted = stored.session.prompted;
+            this.#restored = true;
+            if (this.#capabilities.resumeSession) {
+                lifecycleResponse = await this.race(this.#connection.agent.request(methods.agent.session.resume, {
+                    additionalDirectories: [...this.#additionalDirectories],
+                    cwd: this.#cwd,
+                    mcpServers: [],
+                    sessionId: this.#nativeSessionId,
+                }, { cancellationSignal: signal }), "ACP agent exited while resuming a session", signal);
+            }
+            else if (this.#capabilities.loadSession) {
+                this.#replaying = true;
+                try {
+                    lifecycleResponse = await this.race(this.#connection.agent.request(methods.agent.session.load, {
+                        additionalDirectories: [...this.#additionalDirectories],
+                        cwd: this.#cwd,
+                        mcpServers: [],
+                        sessionId: this.#nativeSessionId,
+                    }, { cancellationSignal: signal }), "ACP agent exited while loading a session", signal);
+                }
+                finally {
+                    this.#replaying = false;
+                }
+            }
+            else {
+                throw new AcpExecutionError("The ACP agent cannot restore its persisted session", {}, "session_restore_unsupported");
+            }
+        }
+        else {
+            if (stored instanceof FoundAcpStoredSession) {
+                if (stored.session.prompted) {
+                    throw new AcpExecutionError("The agent or workspace cannot change after a conversation has started", {}, "session_identity_mismatch");
+                }
+                this.#store.remove(this.#mobiusSessionId);
+            }
+            const created = await this.race(this.#connection.agent.request(methods.agent.session.new, {
+                additionalDirectories: [...this.#additionalDirectories],
+                cwd: this.#cwd,
+                mcpServers: [],
+            }, { cancellationSignal: signal }), "ACP agent exited while starting a session", signal);
+            this.#nativeSessionId = created.sessionId;
+            lifecycleResponse = created;
+            this.#store.write(new AcpStoredSession(this.#mobiusSessionId, this.#agentId, this.#nativeSessionId, this.#cwd, this.#additionalDirectories, false));
+        }
+        const lifecycleRecord = isRecord(lifecycleResponse)
+            ? lifecycleResponse
+            : {};
+        this.#configOptions = normalizeConfigOptions(lifecycleRecord["configOptions"], lifecycleRecord["modes"]);
+        await this.#updateTail;
+        signal.throwIfAborted();
+    };
+    configure = async (options) => {
+        const existing = this.#configOptions.find((option) => option.id === options.configId);
+        if (existing === undefined || existing.type !== options.valueType) {
+            throw new AcpExecutionError("The requested ACP configuration option is unavailable", {}, "invalid_session_configuration");
+        }
+        if (existing.type === "select") {
+            if (!existing.values.some((entry) => entry.value === options.value)) {
+                throw new AcpExecutionError("The requested ACP configuration value is unavailable", {}, "invalid_session_configuration");
+            }
+            if (existing.category === "mode") {
+                await this.race(this.#connection.agent.request(methods.agent.session.setMode, { modeId: options.value, sessionId: this.#nativeSessionId }, { cancellationSignal: options.signal }), "ACP agent exited while setting the session mode", options.signal);
+                this.#configOptions = this.#configOptions.map((option) => option.id === existing.id
+                    ? { ...option, currentValue: options.value }
+                    : option);
+            }
+            else {
+                const response = await this.race(this.#connection.agent.request(methods.agent.session.setConfigOption, {
+                    configId: existing.id,
+                    sessionId: this.#nativeSessionId,
+                    value: options.value,
+                }, { cancellationSignal: options.signal }), "ACP agent exited while changing session configuration", options.signal);
+                this.#configOptions = replaceConfigOptionsKeepingMode(this.#configOptions, response.configOptions);
+            }
+        }
+        else {
+            const response = await this.race(this.#connection.agent.request(methods.agent.session.setConfigOption, {
+                configId: existing.id,
+                sessionId: this.#nativeSessionId,
+                type: "boolean",
+                value: options.booleanValue,
+            }, { cancellationSignal: options.signal }), "ACP agent exited while changing session configuration", options.signal);
+            this.#configOptions = replaceConfigOptionsKeepingMode(this.#configOptions, response.configOptions);
+        }
+        return this.#configOptions;
+    };
+    prompt = async (options) => {
+        if (this.#turn.running) {
+            throw new AcpExecutionError("Another prompt is already running in this conversation", {}, "session_busy");
+        }
+        if (options.images.length > 0 && !this.#capabilities.imagePrompt) {
+            throw new AcpExecutionError("The selected agent does not accept image prompts", {}, "unsupported_prompt_content");
+        }
+        if (options.resources.some((resource) => resource.type === "embedded") &&
+            !this.#capabilities.embeddedContextPrompt) {
+            throw new AcpExecutionError("The selected agent does not accept embedded context", {}, "unsupported_prompt_content");
+        }
+        const prompt = [];
+        if (options.prompt.length > 0) {
+            prompt.push({ text: options.prompt, type: "text" });
+        }
+        for (const image of options.images) {
+            prompt.push({
+                _meta: { mobius: { name: image.name } },
+                data: image.data,
+                mimeType: image.mimeType,
+                type: "image",
+            });
+        }
+        for (const resource of options.resources) {
+            if (resource.type === "embedded") {
+                prompt.push({
+                    resource: {
+                        mimeType: resource.mimeType,
+                        text: resource.text,
+                        uri: resource.uri,
+                    },
+                    type: "resource",
+                });
+            }
+            else {
+                prompt.push({
+                    mimeType: resource.mimeType,
+                    name: resource.name,
+                    type: "resource_link",
+                    uri: resource.uri,
+                });
+            }
+        }
+        if (prompt.length === 0) {
+            throw new AcpExecutionError("A prompt must contain text or an attachment", {}, "empty_prompt");
+        }
+        this.#store.write(new AcpStoredSession(this.#mobiusSessionId, this.#agentId, this.#nativeSessionId, this.#cwd, this.#additionalDirectories, true));
+        this.#prompted = true;
+        const running = new RunningAcpTurn(options.commandId, options.onActivity, options.onText);
+        this.#turn = running;
+        try {
+            const response = await this.race(this.#connection.agent.request(methods.agent.session.prompt, { prompt, sessionId: this.#nativeSessionId }, { cancellationSignal: options.signal }), "ACP agent exited during a prompt", options.signal);
+            await this.#updateTail;
+            await running.activities.finish();
+            return { stopReason: response.stopReason };
+        }
+        catch (error) {
+            await running.activities.finish();
+            if (error instanceof AcpExecutionError) {
+                throw error;
+            }
+            throw new AcpExecutionError("ACP agent execution failed", {
+                cause: error,
+            });
+        }
+        finally {
+            this.#turn = new IdleAcpTurn();
+        }
+    };
     cancel = async () => {
-        if (!this.#turnRunning) {
+        await this.cancelPendingInteractions();
+        if (!this.#turn.running) {
             return;
         }
         await this.#connection.agent.notify(methods.agent.session.cancel, {
-            sessionId: this.#session.sessionId,
+            sessionId: this.#nativeSessionId,
         });
     };
-    prompt = async (prompt, onActivity, onText, signal) => {
-        if (this.#turnRunning) {
-            throw new AcpExecutionError("Another prompt is already running in this conversation");
+    respondPermission = async (options) => {
+        const pending = this.#pendingPermissions.get(options.interactionId);
+        if (pending === undefined) {
+            throw new AcpExecutionError("The permission request is no longer active", {}, "permission_request_not_found");
         }
-        this.#turnRunning = true;
-        const activities = new AcpActivityTracker(onActivity);
-        const runTurn = async () => {
-            const completion = this.#session.prompt(prompt, {
-                cancellationSignal: signal,
-            });
-            for (;;) {
-                const message = await this.#session.nextUpdate();
-                if (message.kind === "stop") {
-                    await completion;
-                    await activities.finish();
-                    return { stopReason: message.stopReason };
-                }
-                const update = message.update;
-                if (update.sessionUpdate === "agent_message_chunk") {
-                    if (update.content.type === "text") {
-                        if (isProgressMessage(update)) {
-                            await activities.recordNarrative("progress", update.messageId ?? "current", update.content.text);
-                        }
-                        else {
-                            await activities.finishNarrative();
-                            await onText(update.content.text);
-                        }
-                    }
-                    continue;
-                }
-                if (update.sessionUpdate === "agent_thought_chunk") {
-                    if (update.content.type === "text") {
-                        await activities.recordNarrative("reasoning", update.messageId ?? "current", update.content.text);
-                    }
-                    continue;
-                }
-                if (update.sessionUpdate === "tool_call") {
-                    await activities.recordToolCall(update);
-                    continue;
-                }
-                if (update.sessionUpdate === "tool_call_update") {
-                    await activities.recordToolCallUpdate(update);
-                    continue;
-                }
-                if (update.sessionUpdate === "plan") {
-                    await activities.recordPlan(update);
-                    continue;
-                }
-                if (update.sessionUpdate === "plan_update") {
-                    await activities.recordPlanUpdate(update);
-                    continue;
-                }
-                if (update.sessionUpdate === "plan_removed") {
-                    await activities.removePlan(update);
+        if (options.outcome === "selected" &&
+            !pending.optionIds.has(options.optionId)) {
+            throw new AcpExecutionError("The selected permission option is unavailable", {}, "invalid_permission_response");
+        }
+        const resolved = options.outcome === "selected"
+            ? pending.select(options.optionId)
+            : pending.cancel();
+        if (!resolved) {
+            throw new AcpExecutionError("The permission request was already resolved", {}, "permission_request_not_found");
+        }
+        this.#pendingPermissions.delete(options.interactionId);
+        await this.#getObserver().onPermissionResolved({
+            interactionId: options.interactionId,
+            kind: SESSION_PERMISSION_RESOLVED_KIND,
+            optionId: options.outcome === "selected" ? options.optionId : "",
+            outcome: options.outcome,
+            protocolVersion: MOBIUS_PROTOCOL_VERSION,
+            sessionId: this.#mobiusSessionId,
+        });
+    };
+    respondElicitation = async (options) => {
+        const pending = this.#pendingElicitations.get(options.interactionId);
+        if (pending === undefined) {
+            throw new AcpExecutionError("The elicitation request is no longer active", {}, "elicitation_request_not_found");
+        }
+        let resolved = false;
+        if (options.action === "accept") {
+            if (pending.elicitationId.length > 0) {
+                resolved = pending.accept({});
+                if (resolved) {
+                    this.#acceptedUrlElicitations.set(pending.elicitationId, pending.interactionId);
                 }
             }
+            else {
+                resolved = pending.accept(validateElicitationContent(options.content, pending.requestedSchema));
+            }
+        }
+        else if (options.action === "decline") {
+            resolved = pending.decline();
+        }
+        else {
+            resolved = pending.cancel();
+        }
+        if (!resolved) {
+            throw new AcpExecutionError("The elicitation request was already resolved", {}, "elicitation_request_not_found");
+        }
+        this.#pendingElicitations.delete(options.interactionId);
+        await this.#getObserver().onElicitationResolved({
+            action: options.action,
+            interactionId: options.interactionId,
+            kind: SESSION_ELICITATION_RESOLVED_KIND,
+            protocolVersion: MOBIUS_PROTOCOL_VERSION,
+            sessionId: this.#mobiusSessionId,
+        });
+    };
+    onPermission = async (request, signal) => {
+        this.assertNativeSession(request.sessionId);
+        const interactionId = `permission-${crypto.randomUUID()}`;
+        const options = request.options
+            .slice(0, 20)
+            .map((option) => ({
+            kind: option.kind,
+            name: truncate(option.name, 255),
+            optionId: truncate(option.optionId, 255),
+        }));
+        if (options.length === 0) {
+            throw new AcpExecutionError("ACP permission request did not provide any choices", {}, "invalid_agent_permission_request");
+        }
+        const pending = new PendingPermission(interactionId, new Set(options.map((option) => option.optionId)));
+        this.#pendingPermissions.set(interactionId, pending);
+        const abort = () => {
+            void this.cancelPermission(interactionId);
         };
+        signal.addEventListener("abort", abort, { once: true });
         try {
-            return await Promise.race([
-                runTurn(),
-                this.#processExit.then(() => {
-                    throw new AcpExecutionError("ACP agent exited during a prompt");
-                }),
-                rejectWhenAborted(signal),
-            ]);
+            await this.#getObserver().onPermission({
+                commandId: this.#turn.commandId,
+                interactionId,
+                kind: SESSION_PERMISSION_REQUESTED_KIND,
+                options,
+                protocolVersion: MOBIUS_PROTOCOL_VERSION,
+                sessionId: this.#mobiusSessionId,
+                title: truncate(request.toolCall.title ?? "Permission required", 500),
+                toolCallId: truncate(request.toolCall.toolCallId, 255),
+                toolKind: truncate(request.toolCall.kind ?? "other", 64),
+            });
+            return await pending.completion.promise;
         }
-        catch (error) {
-            await activities.finish();
-            throw new AcpExecutionError("ACP agent execution failed", {
-                cause: error,
+        finally {
+            signal.removeEventListener("abort", abort);
+            this.#pendingPermissions.delete(interactionId);
+        }
+    };
+    onElicitation = async (request, signal) => {
+        const sessionId = Reflect.get(request, "sessionId");
+        if (typeof sessionId !== "string") {
+            throw new AcpExecutionError("Mobius only accepts session-scoped ACP elicitations", {}, "unsupported_elicitation_scope");
+        }
+        this.assertNativeSession(sessionId);
+        if (request.mode !== "form" && request.mode !== "url") {
+            throw new AcpExecutionError("The ACP agent requested an unsupported elicitation mode", {}, "unsupported_elicitation_mode");
+        }
+        const interactionId = `elicitation-${crypto.randomUUID()}`;
+        const schemaValue = Reflect.get(request, "requestedSchema");
+        const requestedSchema = request.mode === "form" ? schemaValue : {};
+        const elicitationIdValue = Reflect.get(request, "elicitationId");
+        const elicitationId = request.mode === "url" && typeof elicitationIdValue === "string"
+            ? truncate(elicitationIdValue, 255)
+            : "";
+        const pending = new PendingElicitation(interactionId, elicitationId, requestedSchema);
+        this.#pendingElicitations.set(interactionId, pending);
+        const abort = () => {
+            void this.cancelElicitation(interactionId);
+        };
+        signal.addEventListener("abort", abort, { once: true });
+        try {
+            await this.#getObserver().onElicitation({
+                accepted: false,
+                commandId: this.#turn.commandId,
+                elicitationId,
+                fields: normalizeElicitationFields(requestedSchema),
+                interactionId,
+                kind: SESSION_ELICITATION_REQUESTED_KIND,
+                message: truncate(request.message, 2_000),
+                mode: request.mode,
+                protocolVersion: MOBIUS_PROTOCOL_VERSION,
+                sessionId: this.#mobiusSessionId,
+                url: request.mode === "url" &&
+                    typeof Reflect.get(request, "url") === "string"
+                    ? truncate(readString(Reflect.get(request, "url")), 4_096)
+                    : "",
             });
+            return await pending.completion.promise;
         }
         finally {
-            this.#turnRunning = false;
+            signal.removeEventListener("abort", abort);
+            this.#pendingElicitations.delete(interactionId);
+        }
+    };
+    onElicitationComplete = async (notification) => {
+        const interactionId = this.#acceptedUrlElicitations.get(notification.elicitationId);
+        if (interactionId === undefined) {
+            return;
+        }
+        this.#acceptedUrlElicitations.delete(notification.elicitationId);
+        await this.#getObserver().onElicitationResolved({
+            action: "complete",
+            interactionId,
+            kind: SESSION_ELICITATION_RESOLVED_KIND,
+            protocolVersion: MOBIUS_PROTOCOL_VERSION,
+            sessionId: this.#mobiusSessionId,
+        });
+    };
+    onUpdate = (notification) => {
+        this.#updateTail = this.#updateTail.then(async () => await this.processUpdate(notification));
+        return this.#updateTail;
+    };
+    processUpdate = async (notification) => {
+        this.assertNativeSession(notification.sessionId);
+        const update = notification.update;
+        if (this.#replaying &&
+            (update.sessionUpdate === "user_message_chunk" ||
+                update.sessionUpdate === "agent_message_chunk" ||
+                update.sessionUpdate === "agent_thought_chunk" ||
+                update.sessionUpdate === "tool_call" ||
+                update.sessionUpdate === "tool_call_update" ||
+                update.sessionUpdate === "plan" ||
+                update.sessionUpdate === "plan_update" ||
+                update.sessionUpdate === "plan_removed")) {
+            return;
+        }
+        if (update.sessionUpdate === "agent_message_chunk") {
+            if (update.content.type === "text") {
+                if (isProgressMessage(update)) {
+                    await this.#turn.activities.recordNarrative("progress", update.messageId ?? "current", update.content.text);
+                }
+                else {
+                    await this.#turn.activities.finishNarrative();
+                    await this.#turn.onText(update.content.text);
+                }
+            }
+            else {
+                await this.#turn.activities.finishNarrative();
+                await this.#getObserver().onContent({
+                    commandId: this.#turn.commandId,
+                    content: normalizeContentBlock(update.content),
+                    contentId: `content-${crypto.randomUUID()}`,
+                    kind: AGENT_CONTENT_KIND,
+                    messageId: truncate(update.messageId ?? "", 255),
+                    protocolVersion: MOBIUS_PROTOCOL_VERSION,
+                    sessionId: this.#mobiusSessionId,
+                });
+            }
+            return;
+        }
+        if (update.sessionUpdate === "agent_thought_chunk") {
+            if (update.content.type === "text") {
+                await this.#turn.activities.recordNarrative("reasoning", update.messageId ?? "current", update.content.text);
+            }
+            return;
+        }
+        if (update.sessionUpdate === "tool_call") {
+            await this.#turn.activities.recordToolCall(update);
+            return;
+        }
+        if (update.sessionUpdate === "tool_call_update") {
+            await this.#turn.activities.recordToolCallUpdate(update);
+            return;
+        }
+        if (update.sessionUpdate === "plan") {
+            await this.#turn.activities.recordPlan(update);
+            return;
+        }
+        if (update.sessionUpdate === "plan_update") {
+            await this.#turn.activities.recordPlanUpdate(update);
+            return;
+        }
+        if (update.sessionUpdate === "plan_removed") {
+            await this.#turn.activities.removePlan(update);
+            return;
+        }
+        if (update.sessionUpdate === "available_commands_update") {
+            const commands = update.availableCommands
+                .slice(0, 500)
+                .map((command) => ({
+                description: truncate(command.description, 500),
+                inputHint: truncate(command.input?.hint ?? "", 255),
+                name: truncate(command.name, 128),
+            }))
+                .filter((command) => command.name.length > 0);
+            this.#commands = commands;
+            await this.#getObserver().onCommands({
+                commands,
+                kind: SESSION_COMMANDS_UPDATED_KIND,
+                protocolVersion: MOBIUS_PROTOCOL_VERSION,
+                sessionId: this.#mobiusSessionId,
+            });
+            return;
+        }
+        if (update.sessionUpdate === "config_option_update") {
+            this.#configOptions = replaceConfigOptionsKeepingMode(this.#configOptions, update.configOptions);
+            await this.emitConfigUpdate();
+            return;
+        }
+        if (update.sessionUpdate === "current_mode_update") {
+            this.#configOptions = this.#configOptions.map((option) => option.category === "mode"
+                ? { ...option, currentValue: update.currentModeId }
+                : option);
+            await this.emitConfigUpdate();
+            return;
+        }
+        if (update.sessionUpdate === "session_info_update") {
+            if (Object.hasOwn(update, "title")) {
+                this.#sessionTitle = truncate(update.title ?? "", 500);
+            }
+            if (Object.hasOwn(update, "updatedAt")) {
+                this.#sessionUpdatedAt = truncate(update.updatedAt ?? "", 128);
+            }
+            await this.#getObserver().onInfo({
+                kind: SESSION_INFO_UPDATED_KIND,
+                protocolVersion: MOBIUS_PROTOCOL_VERSION,
+                sessionId: this.#mobiusSessionId,
+                title: this.#sessionTitle,
+                updatedAt: this.#sessionUpdatedAt,
+            });
+            return;
+        }
+        if (update.sessionUpdate === "usage_update") {
+            await this.#getObserver().onUsage({
+                costAmount: update.cost?.amount ?? 0,
+                costCurrency: truncate(update.cost?.currency ?? "", 16),
+                hasCost: update.cost !== undefined && update.cost !== null,
+                kind: SESSION_USAGE_UPDATED_KIND,
+                protocolVersion: MOBIUS_PROTOCOL_VERSION,
+                sessionId: this.#mobiusSessionId,
+                size: Math.max(0, Math.trunc(update.size)),
+                used: Math.max(0, Math.trunc(update.used)),
+            });
         }
     };
     close = async () => {
-        this.#session.dispose();
+        await this.cancelPendingInteractions();
+        if (this.#capabilities.closeSession && this.#nativeSessionId.length > 0) {
+            try {
+                await this.#connection.agent.request(methods.agent.session.close, { sessionId: this.#nativeSessionId }, {
+                    cancellationSignal: AbortSignal.timeout(PROCESS_STOP_TIMEOUT_MILLISECONDS),
+                });
+            }
+            catch {
+                // Process teardown below remains authoritative.
+            }
+        }
+        await this.closeProcess();
+    };
+    closeProcess = async () => {
         this.#connection.close();
         await stopAgentProcess(this.#child);
     };
+    race = async (operation, exitMessage, signal) => {
+        signal.throwIfAborted();
+        let removeAbortListener = () => { };
+        const aborted = new Promise((_resolve, reject) => {
+            const rejectAbort = () => {
+                reject(signal.reason ?? new Error("ACP request was cancelled"));
+            };
+            signal.addEventListener("abort", rejectAbort, { once: true });
+            removeAbortListener = () => {
+                signal.removeEventListener("abort", rejectAbort);
+            };
+        });
+        try {
+            return await Promise.race([
+                operation,
+                this.#processExit.then(() => {
+                    throw new AcpExecutionError(exitMessage);
+                }),
+                aborted,
+            ]);
+        }
+        finally {
+            removeAbortListener();
+        }
+    };
+    assertNativeSession = (sessionId) => {
+        if (sessionId !== this.#nativeSessionId) {
+            throw new AcpExecutionError("ACP agent referenced an unknown session", {}, "invalid_agent_session");
+        }
+    };
+    emitConfigUpdate = async () => {
+        await this.#getObserver().onConfig({
+            configOptions: this.#configOptions,
+            kind: SESSION_CONFIG_UPDATED_KIND,
+            protocolVersion: MOBIUS_PROTOCOL_VERSION,
+            requestId: `agent-update-${crypto.randomUUID()}`,
+            sessionId: this.#mobiusSessionId,
+        });
+    };
+    cancelPermission = async (interactionId) => {
+        const pending = this.#pendingPermissions.get(interactionId);
+        if (pending === undefined || !pending.cancel()) {
+            return;
+        }
+        this.#pendingPermissions.delete(interactionId);
+        await this.#getObserver().onPermissionResolved({
+            interactionId,
+            kind: SESSION_PERMISSION_RESOLVED_KIND,
+            optionId: "",
+            outcome: "cancelled",
+            protocolVersion: MOBIUS_PROTOCOL_VERSION,
+            sessionId: this.#mobiusSessionId,
+        });
+    };
+    cancelElicitation = async (interactionId) => {
+        const pending = this.#pendingElicitations.get(interactionId);
+        if (pending === undefined || !pending.cancel()) {
+            return;
+        }
+        this.#pendingElicitations.delete(interactionId);
+        await this.#getObserver().onElicitationResolved({
+            action: "cancel",
+            interactionId,
+            kind: SESSION_ELICITATION_RESOLVED_KIND,
+            protocolVersion: MOBIUS_PROTOCOL_VERSION,
+            sessionId: this.#mobiusSessionId,
+        });
+    };
+    cancelPendingInteractions = async () => {
+        const permissionIds = [...this.#pendingPermissions.keys()];
+        const elicitationIds = [...this.#pendingElicitations.keys()];
+        const acceptedElicitationIds = [...this.#acceptedUrlElicitations.values()];
+        this.#acceptedUrlElicitations.clear();
+        for (const interactionId of permissionIds) {
+            await this.cancelPermission(interactionId);
+        }
+        for (const interactionId of elicitationIds) {
+            await this.cancelElicitation(interactionId);
+        }
+        for (const interactionId of acceptedElicitationIds) {
+            await this.#getObserver().onElicitationResolved({
+                action: "cancel",
+                interactionId,
+                kind: SESSION_ELICITATION_RESOLVED_KIND,
+                protocolVersion: MOBIUS_PROTOCOL_VERSION,
+                sessionId: this.#mobiusSessionId,
+            });
+        }
+    };
 }
 export class AcpSessionManager {
     #activeSessionIds = new Set();
     #cancellationRequests = new Set();
+    #preparing = new Map();
     #sessions = new Map();
+    #store;
+    #observer;
+    constructor(observer = new NullAcpSessionObserver(), store = new MemoryAcpSessionStore()) {
+        this.#observer = observer;
+        this.#store = store;
+    }
+    setObserver = (observer) => {
+        this.#observer = observer;
+    };
+    async #startPreparation(options) {
+        const operation = (async () => {
+            try {
+                const runtime = await AcpProcessSession.start(options, () => this.#observer, this.#store);
+                this.#sessions.set(options.sessionId, runtime);
+                return runtime;
+            }
+            finally {
+                this.#preparing.delete(options.sessionId);
+            }
+        })();
+        this.#preparing.set(options.sessionId, operation);
+        return await operation;
+    }
+    async #replacePreparation(existing, options) {
+        const operation = (async () => {
+            try {
+                this.#sessions.delete(options.sessionId);
+                await existing.close();
+                this.#store.remove(options.sessionId);
+                const runtime = await AcpProcessSession.start(options, () => this.#observer, this.#store);
+                this.#sessions.set(options.sessionId, runtime);
+                return runtime;
+            }
+            finally {
+                this.#preparing.delete(options.sessionId);
+            }
+        })();
+        this.#preparing.set(options.sessionId, operation);
+        return await operation;
+    }
+    prepareSession = async (options) => {
+        const pending = this.#preparing.get(options.sessionId);
+        if (pending !== undefined) {
+            const runtime = await pending;
+            if (runtime.belongsTo(options.agent.id, options.cwd, options.additionalDirectories)) {
+                return runtime.prepared();
+            }
+            return await this.prepareSession(options);
+        }
+        const existing = this.#sessions.get(options.sessionId);
+        if (existing !== undefined) {
+            if (existing.belongsTo(options.agent.id, options.cwd, options.additionalDirectories)) {
+                return existing.prepared();
+            }
+            if (!existing.canRebind()) {
+                throw new AcpExecutionError("The agent or workspace cannot change after a conversation has started", {}, "session_identity_mismatch");
+            }
+            const runtime = await this.#replacePreparation(existing, options);
+            return runtime.prepared();
+        }
+        const runtime = await this.#startPreparation(options);
+        return runtime.prepared();
+    };
+    configureSession = async (options) => {
+        const runtime = await this.ensureSession(options);
+        return await runtime.configure(options);
+    };
     cancelPrompt = async (sessionId) => {
         this.#cancellationRequests.add(sessionId);
         const runtime = this.#sessions.get(sessionId);
@@ -254,31 +1333,24 @@ export class AcpSessionManager {
     };
     runPrompt = async (options) => {
         if (this.#activeSessionIds.has(options.sessionId)) {
-            throw new AcpExecutionError("Another prompt is already running in this conversation");
+            throw new AcpExecutionError("Another prompt is already running in this conversation", {}, "session_busy");
         }
         this.#activeSessionIds.add(options.sessionId);
-        let runtime = this.#sessions.get(options.sessionId);
-        if (runtime !== undefined && !runtime.belongsTo(options.agent.id)) {
-            this.#activeSessionIds.delete(options.sessionId);
-            throw new AcpExecutionError("The agent cannot change after a conversation has started");
-        }
         try {
             if (this.#cancellationRequests.has(options.sessionId)) {
                 return { stopReason: "cancelled" };
             }
-            if (runtime === undefined) {
-                runtime = await AcpProcessSession.start(options.agent, options.cwd, options.signal);
-                this.#sessions.set(options.sessionId, runtime);
-            }
+            const runtime = await this.ensureSession(options);
             if (this.#cancellationRequests.has(options.sessionId)) {
                 return { stopReason: "cancelled" };
             }
-            return await runtime.prompt(options.prompt, options.onActivity, options.onText, options.signal);
+            return await runtime.prompt(options);
         }
         catch (error) {
-            if (runtime !== undefined) {
+            const failedRuntime = this.#sessions.get(options.sessionId);
+            if (failedRuntime !== undefined) {
                 this.#sessions.delete(options.sessionId);
-                await runtime.close();
+                await failedRuntime.close();
             }
             if (error instanceof AcpExecutionError) {
                 throw error;
@@ -292,10 +1364,39 @@ export class AcpSessionManager {
             this.#cancellationRequests.delete(options.sessionId);
         }
     };
+    respondPermission = async (options) => {
+        const runtime = this.#sessions.get(options.sessionId);
+        if (runtime === undefined) {
+            throw new AcpExecutionError("The permission request session is unavailable", {}, "session_not_found");
+        }
+        await runtime.respondPermission(options);
+    };
+    respondElicitation = async (options) => {
+        const runtime = this.#sessions.get(options.sessionId);
+        if (runtime === undefined) {
+            throw new AcpExecutionError("The elicitation request session is unavailable", {}, "session_not_found");
+        }
+        await runtime.respondElicitation(options);
+    };
     close = async () => {
         const sessions = [...this.#sessions.values()];
         this.#sessions.clear();
         await Promise.all(sessions.map(async (session) => await session.close()));
     };
+    ensureSession = async (options) => {
+        const existing = this.#sessions.get(options.sessionId);
+        if (existing !== undefined) {
+            if (!existing.belongsTo(options.agent.id, options.cwd, options.additionalDirectories)) {
+                throw new AcpExecutionError("The agent or workspace cannot change after a conversation has started", {}, "session_identity_mismatch");
+            }
+            return existing;
+        }
+        await this.prepareSession(options);
+        const started = this.#sessions.get(options.sessionId);
+        if (started === undefined) {
+            throw new AcpExecutionError("ACP session did not start");
+        }
+        return started;
+    };
 }
 //# sourceMappingURL=session-manager.js.map