@kenkaiiii/ggcoder 5.29.0 → 5.30.0

package/dist/modes/acp-mode.js

@@ -0,0 +1,802 @@
+/**
+ * ACP mode: expose GG Coder as an Agent Client Protocol agent over stdio.
+ *
+ * This is the integration surface for ACP clients (Zed, pew2, any editor that
+ * speaks the protocol). It is deliberately a sibling of `rpc-mode.ts` — same
+ * shape, same `AgentSession`, same NDJSON-on-stdio transport — but the frames
+ * are the standard protocol instead of ggcoder's bespoke one, so a client
+ * written against the spec works with no ggcoder-specific code.
+ *
+ * Spec: https://agentclientprotocol.com/protocol/overview
+ *
+ * Scope: `initialize`, `session/new`, `session/prompt`, `session/cancel`,
+ * `session/list`, `session/load` and `session/set_config_option`. Everything
+ * advertised in `agentCapabilities` is implemented, because a client must be
+ * able to trust that list — advertising a method that then errors is worse
+ * than advertising nothing.
+ *
+ * stdout carries protocol frames ONLY. Anything diagnostic goes to stderr or
+ * the log file; a stray `console.log` anywhere in the process corrupts the
+ * stream and the client disconnects.
+ */
+import readline from "node:readline";
+import { isAbortError } from "@kenkaiiii/gg-agent";
+import { getAllModels, getMaxThinkingLevel, getModel } from "@kenkaiiii/gg-core";
+import { AgentSession } from "../core/agent-session.js";
+import { findSessionById, listAllSessions, listSessionSummaries } from "../session.js";
+import { formatUserError } from "../utils/error-handler.js";
+import { closeLogger } from "../core/logger.js";
+/** The ACP major version this mode implements. Bumped only for breaking changes. */
+export const ACP_PROTOCOL_VERSION = 1;
+/** JSON-RPC 2.0 reserved codes. ACP adds no codes of its own. */
+const RPC_PARSE_ERROR = -32700;
+const RPC_INVALID_REQUEST = -32600;
+const RPC_METHOD_NOT_FOUND = -32601;
+const RPC_INVALID_PARAMS = -32602;
+const RPC_INTERNAL_ERROR = -32603;
+/**
+ * The client asked for something impossible, as opposed to the agent failing.
+ *
+ * Typed rather than sniffed from the message text, so that a client can tell a
+ * bug in its own sequencing from an agent that fell over — and so that a later
+ * reworded message cannot silently change the code on the wire.
+ */
+class InvalidParams extends Error {
+}
+// ── Tool mapping ───────────────────────────────────────────
+/**
+ * ggcoder tool name → ACP `ToolKind`.
+ *
+ * Purely cosmetic on the client (icon + progress treatment), so an unmapped
+ * tool falls back to `other` rather than failing. Keep in step with
+ * `src/tools/index.ts` as tools are added.
+ */
+const TOOL_KINDS = {
+    read: "read",
+    ls: "read",
+    find: "read",
+    grep: "search",
+    code_search: "search",
+    web_search: "search",
+    edit: "edit",
+    write: "edit",
+    bash: "execute",
+    screenshot: "execute",
+    web_fetch: "fetch",
+    source_path: "fetch",
+    subagent: "think",
+    spawn_agent: "think",
+    enter_plan: "switch_mode",
+    exit_plan: "switch_mode",
+};
+function toolKind(name) {
+    return TOOL_KINDS[name] ?? "other";
+}
+/**
+ * A one-line tool title for the client's activity list.
+ *
+ * The first string-ish argument is nearly always the interesting one (a path, a
+ * command, a query), and it is truncated because this renders on a phone.
+ */
+function toolTitle(name, args) {
+    for (const value of Object.values(args)) {
+        if (typeof value !== "string" || value.length === 0)
+            continue;
+        const flat = value.replace(/\s+/g, " ").trim();
+        const clipped = flat.length > 80 ? `${flat.slice(0, 79)}…` : flat;
+        return `${name}(${clipped})`;
+    }
+    return name;
+}
+/**
+ * Why the current prompt turn ended.
+ *
+ * ACP has a closed set; ggcoder's `turn_end` carries whatever the provider
+ * said. Only the reasons that map cleanly are translated — everything else is
+ * a normal completion, which is what the client renders anyway.
+ */
+function stopReasonFor(truncation, hitMaxTurns) {
+    if (hitMaxTurns)
+        return "max_turn_requests";
+    if (truncation === "max_tokens")
+        return "max_tokens";
+    if (truncation === "refusal")
+        return "refusal";
+    return "end_turn";
+}
+// ── Config options ─────────────────────────────────────
+/** The selectors this agent exposes. Ids are part of the wire contract. */
+export const MODEL_CONFIG_ID = "model";
+export const THINKING_CONFIG_ID = "thinking";
+export const MODE_CONFIG_ID = "mode";
+/** ACP session modes, mapped onto GG's plan mode. */
+const MODE_DEFAULT = "default";
+const MODE_PLAN = "plan";
+/** Thinking off is a real choice, so it needs a value id of its own. */
+const THINKING_OFF = "off";
+const THINKING_LADDER = [
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+    "ultra",
+];
+/**
+ * Thinking levels this model actually honours, hardest last.
+ *
+ * Offering levels above the model's ceiling would let a phone pick a setting
+ * that silently degrades to something else — a control that lies.
+ */
+function thinkingOptionsFor(modelId) {
+    const ceiling = getMaxThinkingLevel(modelId);
+    const top = THINKING_LADDER.indexOf(ceiling);
+    const levels = THINKING_LADDER.slice(0, top < 0 ? THINKING_LADDER.length : top + 1);
+    return [
+        { value: THINKING_OFF, name: "Off", description: "No extended reasoning" },
+        ...levels.map((level) => ({ value: level, name: level })),
+    ];
+}
+/**
+ * The selectors a client renders for a session, with their live values.
+ *
+ * Model and thinking come from ggcoder's own registry rather than anything
+ * pew2- or Zed-specific, which is what lets a phone show GG Coder's real model
+ * list without either side hard-coding the other's.
+ */
+function configOptionsFor(session) {
+    const { model } = session.getState();
+    const thinking = session.getThinkingLevel();
+    return [
+        {
+            id: MODEL_CONFIG_ID,
+            name: "Model",
+            category: "model",
+            type: "select",
+            currentValue: model,
+            options: getAllModels().map((entry) => ({
+                value: entry.id,
+                name: entry.name,
+                description: entry.provider,
+            })),
+        },
+        {
+            id: THINKING_CONFIG_ID,
+            name: "Thinking",
+            description: "Extended reasoning effort",
+            category: "thought_level",
+            type: "select",
+            // A model that cannot think reports `off`, which is the truth rather than
+            // a level it would ignore.
+            currentValue: getModel(model)?.supportsThinking ? (thinking ?? THINKING_OFF) : THINKING_OFF,
+            options: thinkingOptionsFor(model),
+        },
+        {
+            id: MODE_CONFIG_ID,
+            name: "Mode",
+            description: "Plan mode is read-only research until a plan is approved",
+            category: "mode",
+            type: "select",
+            currentValue: session.getPlanMode() ? MODE_PLAN : MODE_DEFAULT,
+            options: [
+                { value: MODE_DEFAULT, name: "Default", description: "Full tool access" },
+                { value: MODE_PLAN, name: "Plan", description: "Read-only until exit_plan" },
+            ],
+        },
+    ];
+}
+/** The `modes` block ACP clients like Zed read from session/new and session/load. */
+function sessionModes(session) {
+    return {
+        currentModeId: session.getPlanMode() ? MODE_PLAN : MODE_DEFAULT,
+        availableModes: [
+            { id: MODE_DEFAULT, name: "Default", description: "Full tool access" },
+            { id: MODE_PLAN, name: "Plan", description: "Read-only research until a plan is approved" },
+        ],
+    };
+}
+// ── History replay ───────────────────────────────────
+/** Flatten a persisted message's content to the text a client would show. */
+function messageText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((block) => block?.type === "text")
+        .map((block) => block.text ?? "")
+        .join("");
+}
+/**
+ * Turn a restored conversation into the `session/update` stream a client needs
+ * to draw it.
+ *
+ * ACP has no "here is the transcript" response: a loaded session is replayed as
+ * the same notifications a live turn produces, so the client needs no second
+ * rendering path. Thinking is deliberately NOT replayed — it is transient by
+ * design, and a wall of stale reasoning above a resumed conversation buries the
+ * thing the user came back for.
+ */
+export function historyUpdates(messages) {
+    const updates = [];
+    for (const message of messages) {
+        if (message.role === "system")
+            continue;
+        if (message.role === "user") {
+            const text = messageText(message.content);
+            if (text) {
+                updates.push({
+                    sessionUpdate: "user_message_chunk",
+                    content: { type: "text", text },
+                });
+            }
+            continue;
+        }
+        if (message.role === "assistant") {
+            const text = messageText(message.content);
+            if (text) {
+                updates.push({
+                    sessionUpdate: "agent_message_chunk",
+                    content: { type: "text", text },
+                });
+            }
+            if (Array.isArray(message.content)) {
+                for (const block of message.content) {
+                    if (block.type !== "tool_call")
+                        continue;
+                    const call = block;
+                    const args = call.args ?? {};
+                    updates.push({
+                        sessionUpdate: "tool_call",
+                        toolCallId: call.id,
+                        title: toolTitle(call.name, args),
+                        name: call.name,
+                        kind: toolKind(call.name),
+                        // History is settled: a replayed call that still said `in_progress`
+                        // would leave a spinner running forever on a resumed session.
+                        status: "completed",
+                        rawInput: args,
+                    });
+                }
+            }
+            continue;
+        }
+        for (const result of message.content) {
+            const entry = result;
+            updates.push({
+                sessionUpdate: "tool_call_update",
+                toolCallId: entry.toolCallId,
+                status: entry.isError ? "failed" : "completed",
+                content: [
+                    {
+                        type: "content",
+                        content: { type: "text", text: messageText(entry.content) },
+                    },
+                ],
+            });
+        }
+    }
+    return updates;
+}
+// ── Mode ───────────────────────────────────────────────────
+/**
+ * Serve ACP on stdio until the input stream ends.
+ *
+ * Resolves when the client disconnects; the caller owns process exit.
+ */
+export async function runAcpMode(options) {
+    const input = options.input ?? process.stdin;
+    const output = options.output ?? process.stdout;
+    function write(frame) {
+        output.write(`${JSON.stringify(frame)}\n`);
+    }
+    function respond(id, result) {
+        write({ jsonrpc: "2.0", id, result });
+    }
+    function fail(id, code, message) {
+        write({ jsonrpc: "2.0", id, error: { code, message } });
+    }
+    /**
+     * The single session this process serves.
+     *
+     * ACP allows many per connection, but an ACP client spawns one agent process
+     * per session anyway, and `AgentSession` owns process-wide state (cwd, tool
+     * registry, session file). One-per-process is the honest model; a second
+     * `session/new` replaces the first rather than pretending to multiplex.
+     */
+    let session = null;
+    let sessionId = "";
+    let abort = new AbortController();
+    /** Set while a `session/prompt` is in flight, so a second one is rejected. */
+    let running = false;
+    let cancelled = false;
+    let truncation;
+    let hitMaxTurns = false;
+    /** Detaches every event listener when the session is replaced or disposed. */
+    let unwire = [];
+    function notifyUpdate(update) {
+        write({
+            jsonrpc: "2.0",
+            method: "session/update",
+            params: { sessionId, update },
+        });
+    }
+    /**
+     * Tell the client the session mode changed outside a request it made — the
+     * model itself can enter/exit plan mode mid-run via the enter_plan/exit_plan
+     * tools, and a picker that only tracks its own changes would lie.
+     */
+    function notifyModeChange(modeId) {
+        if (!session)
+            return;
+        notifyUpdate({ sessionUpdate: "current_mode_update", currentModeId: modeId });
+        notifyUpdate({
+            sessionUpdate: "config_option_update",
+            configOptions: configOptionsFor(session),
+        });
+    }
+    /**
+     * Bridge ggcoder's event bus onto `session/update` notifications.
+     *
+     * Every handler is synchronous and writes immediately, which is what keeps
+     * updates ordered ahead of the `session/prompt` response — a client that sees
+     * the result before the chunks renders an empty turn.
+     */
+    function wire(target) {
+        const bus = target.eventBus;
+        unwire = [
+            bus.on("text_delta", ({ text }) => {
+                notifyUpdate({
+                    sessionUpdate: "agent_message_chunk",
+                    content: { type: "text", text },
+                });
+            }),
+            bus.on("thinking_delta", ({ text }) => {
+                notifyUpdate({
+                    sessionUpdate: "agent_thought_chunk",
+                    content: { type: "text", text },
+                });
+            }),
+            bus.on("tool_call_start", ({ toolCallId, name, args }) => {
+                notifyUpdate({
+                    sessionUpdate: "tool_call",
+                    toolCallId,
+                    title: toolTitle(name, args),
+                    name,
+                    kind: toolKind(name),
+                    status: "in_progress",
+                    rawInput: args,
+                });
+            }),
+            // Mid-flight tool progress. The payload is tool-defined, so it rides in
+            // `rawOutput` rather than being invented into content the client would
+            // then render as if it were final.
+            bus.on("tool_call_update", ({ toolCallId, update }) => {
+                notifyUpdate({
+                    sessionUpdate: "tool_call_update",
+                    toolCallId,
+                    status: "in_progress",
+                    rawOutput: update,
+                });
+            }),
+            bus.on("tool_call_end", ({ toolCallId, result, isError }) => {
+                notifyUpdate({
+                    sessionUpdate: "tool_call_update",
+                    toolCallId,
+                    status: isError ? "failed" : "completed",
+                    content: [{ type: "content", content: { type: "text", text: result } }],
+                });
+            }),
+            // Turn-level outcomes are remembered rather than sent: ACP reports them
+            // once, as the `stopReason` of the prompt response.
+            bus.on("truncated", ({ reason }) => {
+                truncation = reason;
+            }),
+            bus.on("max_turns", () => {
+                hitMaxTurns = true;
+            }),
+        ];
+    }
+    function unwireAll() {
+        for (const off of unwire)
+            off();
+        unwire = [];
+    }
+    async function disposeSession() {
+        if (!session)
+            return;
+        unwireAll();
+        const previous = session;
+        session = null;
+        sessionId = "";
+        await previous.dispose();
+    }
+    const createSession = options.createSession ??
+        ((signal) => {
+            // Self-reference is safe: the callbacks only run once the agent loop is
+            // executing tools, long after the constructor returns.
+            const created = new AgentSession({
+                provider: options.provider,
+                model: options.model,
+                cwd: options.cwd,
+                baseUrl: options.baseUrl,
+                systemPrompt: options.systemPrompt,
+                thinkingLevel: options.thinkingLevel,
+                // MCP connect (spawning stdio servers, HTTP handshakes) takes seconds
+                // and would otherwise sit on the critical path of session/new and
+                // session/load. The desktop sidecar already ships this path: the tool
+                // catalog is seeded from the disk cache so tools are visible
+                // immediately, and live connections promote in the background. A phone
+                // client gets its session in milliseconds and the same tools a moment
+                // later.
+                backgroundMcpConnect: true,
+                // Plan mode. Supplying these callbacks is what registers the
+                // enter_plan/exit_plan tools at all — without them the mode exists but
+                // the model cannot move between states. GG Coder runs without
+                // approvals, so a submitted plan is auto-approved, the [DONE:n]
+                // contract is baked in so progress markers work as on the desktop, and
+                // the client is told about every mode change.
+                onEnterPlan: async () => {
+                    await created.setPlanMode(true);
+                    notifyModeChange(MODE_PLAN);
+                },
+                onExitPlan: async (planPath) => {
+                    await created.setPlanMode(false);
+                    await created.setApprovedPlan(planPath);
+                    notifyModeChange(MODE_DEFAULT);
+                    return "Plan approved. Proceed with implementation, marking each completed step with [DONE:n].";
+                },
+                signal,
+            });
+            return created;
+        });
+    // ── Method handlers ──────────────────────────────────────
+    function handleInitialize() {
+        return {
+            protocolVersion: ACP_PROTOCOL_VERSION,
+            agentCapabilities: {
+                loadSession: true,
+                promptCapabilities: { image: false, audio: false, embeddedContext: false },
+                mcpCapabilities: { http: false, sse: false, acp: false },
+                // `{}` is how ACP says "supported" for a capability with no options of
+                // its own. Omitting the key means unsupported, so this is not cosmetic.
+                sessionCapabilities: { list: {}, resume: {} },
+            },
+            authMethods: [],
+            agentInfo: { name: "ggcoder", title: "GG Coder", version: options.version },
+        };
+    }
+    /**
+     * Start a session, optionally replaying a stored one into it.
+     *
+     * `session/new` and `session/load` differ only in whether history is
+     * restored first, so they share this path rather than drifting apart.
+     */
+    async function startSession(restorePath) {
+        // Replacing an in-flight session would strand the prompt that is running
+        // on it, so the old one is stopped first, deliberately and visibly.
+        await disposeSession();
+        abort = new AbortController();
+        const created = createSession(abort.signal);
+        await created.initialize();
+        if (restorePath)
+            await created.loadSession(restorePath);
+        session = created;
+        sessionId = created.getState().sessionId;
+        wire(created);
+        return created;
+    }
+    async function handleNewSession() {
+        const created = await startSession();
+        return { sessionId, configOptions: configOptionsFor(created), modes: sessionModes(created) };
+    }
+    /** The directory a request is about, defaulting to the one we were started in. */
+    function requestCwd(params) {
+        const cwd = params?.cwd;
+        return typeof cwd === "string" && cwd ? cwd : options.cwd;
+    }
+    /**
+     * Stored sessions, newest first.
+     *
+     * This is the answer to "see everything that was on GG Coder": the phone asks
+     * the agent, and the agent reads the same `~/.gg/sessions` files the desktop
+     * browses — no separate index to fall out of step.
+     *
+     * ACP makes `cwd` nullable here on purpose. Omitted means EVERY project, not
+     * the agent's own directory: a remote client is asking what you have been
+     * working on, and that spans checkouts. Each entry carries its own `cwd` so
+     * the client can group by project.
+     */
+    async function handleListSessions(params) {
+        const scope = params?.cwd;
+        const stored = typeof scope === "string" && scope
+            ? await listSessionSummaries(scope)
+            : await listAllSessions();
+        return {
+            sessions: stored
+                // An empty session has nothing to resume and nothing to title; listing
+                // it would fill the phone with identical blank rows.
+                .filter((entry) => entry.hasMessages)
+                .map((entry) => ({
+                sessionId: entry.id,
+                cwd: entry.cwd,
+                // Captured during the listing pass, so titling the whole machine's
+                // history costs no extra reads.
+                title: entry.preview ?? null,
+                updatedAt: entry.lastActivity,
+            })),
+        };
+    }
+    /**
+     * Resume a stored session and replay it to the client.
+     *
+     * The transcript is streamed as `session/update` notifications BEFORE this
+     * resolves, which is what the protocol requires and what lets a client draw a
+     * resumed conversation with its normal live-turn rendering.
+     */
+    async function handleLoadSession(params) {
+        const requested = params?.sessionId;
+        if (typeof requested !== "string" || !requested) {
+            throw new InvalidParams("session/load requires a sessionId.");
+        }
+        // Searched by id across every project directory, not just `cwd`: a client
+        // lists sessions from wherever it probed and reopens them against the
+        // directory the session belongs to, so those two rarely match.
+        const sessionPath = await findSessionById(requested, requestCwd(params));
+        if (!sessionPath)
+            throw new InvalidParams(`Unknown session '${requested}'.`);
+        const restored = await startSession(sessionPath);
+        // The id the client asked for is the id it keeps using; `loadSession` may
+        // adopt a different internal one, and answering with that would leave the
+        // client addressing a session it never heard of.
+        sessionId = requested;
+        for (const update of historyUpdates(restored.getMessages()))
+            notifyUpdate(update);
+        return { configOptions: configOptionsFor(restored), modes: sessionModes(restored) };
+    }
+    /**
+     * Switch session mode (ACP `session/set_mode`; Zed's mode picker uses this,
+     * pew2 routes it through session/set_config_option with configId "mode").
+     */
+    async function handleSetMode(params) {
+        if (!session)
+            throw new InvalidParams("No session. Call session/new first.");
+        const modeId = params?.modeId;
+        if (modeId !== MODE_DEFAULT && modeId !== MODE_PLAN) {
+            throw new InvalidParams(`Unknown mode '${String(modeId)}'.`);
+        }
+        const plan = modeId === MODE_PLAN;
+        if (session.getPlanMode() !== plan) {
+            await session.setPlanMode(plan);
+            notifyModeChange(modeId);
+        }
+        return {};
+    }
+    /**
+     * Apply a selector change from the client.
+     *
+     * Replies with the COMPLETE option set rather than the one that changed:
+     * switching model can move the thinking ceiling, and a client that only
+     * patched the field it sent would keep offering levels the new model ignores.
+     */
+    async function handleSetConfigOption(params) {
+        if (!session)
+            throw new InvalidParams("No session. Call session/new first.");
+        const { configId, value } = (params ?? {});
+        if (typeof configId !== "string" || typeof value !== "string") {
+            throw new InvalidParams("session/set_config_option requires a configId and a string value.");
+        }
+        if (configId === MODEL_CONFIG_ID) {
+            const target = getModel(value);
+            if (!target)
+                throw new InvalidParams(`Unknown model '${value}'.`);
+            await session.switchModel(target.provider, target.id);
+            // Thinking levels are per-model, so a level the previous model allowed can
+            // be above the new one's ceiling. Clamping here keeps the session's actual
+            // effort equal to what the client is about to be told it is.
+            const current = session.getThinkingLevel();
+            if (current) {
+                const allowed = thinkingOptionsFor(target.id).map((option) => option.value);
+                if (!allowed.includes(current))
+                    session.setThinkingLevel(getMaxThinkingLevel(target.id));
+            }
+        }
+        else if (configId === MODE_CONFIG_ID) {
+            // Share the dedicated handler so both entry points behave identically.
+            await handleSetMode({
+                sessionId: params?.sessionId,
+                modeId: value,
+            });
+        }
+        else if (configId === THINKING_CONFIG_ID) {
+            if (value === THINKING_OFF) {
+                session.setThinkingLevel(undefined);
+            }
+            else {
+                const { model } = session.getState();
+                const allowed = thinkingOptionsFor(model).map((option) => option.value);
+                if (!allowed.includes(value)) {
+                    throw new InvalidParams(`Model '${model}' does not support thinking level '${value}'.`);
+                }
+                session.setThinkingLevel(value);
+            }
+        }
+        else {
+            throw new InvalidParams(`Unknown config option '${configId}'.`);
+        }
+        return { configOptions: configOptionsFor(session) };
+    }
+    /** Flatten ACP prompt blocks to the plain text `AgentSession` accepts. */
+    function promptText(params) {
+        const blocks = params?.prompt;
+        if (!Array.isArray(blocks))
+            return "";
+        return blocks
+            .map((block) => {
+            const entry = block;
+            return entry?.type === "text" && typeof entry.text === "string" ? entry.text : "";
+        })
+            .filter(Boolean)
+            .join("\n")
+            .trim();
+    }
+    async function handlePrompt(params) {
+        if (!session)
+            throw new InvalidParams("No session. Call session/new first.");
+        if (running)
+            throw new InvalidParams("A prompt is already running in this session.");
+        const text = promptText(params);
+        if (!text)
+            throw new InvalidParams("prompt must contain at least one non-empty text block.");
+        running = true;
+        cancelled = false;
+        truncation = undefined;
+        hitMaxTurns = false;
+        try {
+            await session.prompt(text);
+        }
+        catch (err) {
+            // A cancel aborts the loop, which surfaces here. The spec requires the
+            // turn to still resolve with `cancelled` rather than reject — the client
+            // is confirming its own cancel, not being told something went wrong.
+            if (cancelled || isAbortError(err))
+                return { stopReason: "cancelled" };
+            throw err;
+        }
+        finally {
+            running = false;
+        }
+        return { stopReason: cancelled ? "cancelled" : stopReasonFor(truncation, hitMaxTurns) };
+    }
+    function handleCancel() {
+        if (!running || !session)
+            return;
+        cancelled = true;
+        abort.abort();
+        // `AgentSession` keeps the construction signal for future turns. Re-arm it
+        // immediately after aborting this turn, or every later prompt sees an
+        // already-aborted signal and silently completes with no output.
+        abort = new AbortController();
+        session.setSignal(abort.signal);
+    }
+    async function dispatch(method, params) {
+        switch (method) {
+            case "initialize":
+                return handleInitialize();
+            case "session/new":
+                return handleNewSession();
+            case "session/prompt":
+                return handlePrompt(params);
+            case "session/list":
+                return handleListSessions(params);
+            case "session/load":
+                return handleLoadSession(params);
+            case "session/set_config_option":
+                return handleSetConfigOption(params);
+            case "session/set_mode":
+                return handleSetMode(params);
+            default:
+                return undefined;
+        }
+    }
+    // ── Read loop ────────────────────────────────────────────
+    const rl = readline.createInterface({ input, terminal: false });
+    /**
+     * Requests still being served.
+     *
+     * Requests are dispatched WITHOUT blocking the read loop, because
+     * `session/prompt` runs for as long as the agent does — awaiting it here
+     * would mean `session/cancel` is not read until the turn it cancels has
+     * already finished. That is a deadlock, not a slow path.
+     */
+    const inFlight = new Set();
+    function serve(id, method, params) {
+        const task = (async () => {
+            try {
+                const result = await dispatch(method, params);
+                if (result === undefined) {
+                    fail(id, RPC_METHOD_NOT_FOUND, `Unsupported method: ${method}`);
+                    return;
+                }
+                respond(id, result);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                const code = err instanceof InvalidParams ? RPC_INVALID_PARAMS : RPC_INTERNAL_ERROR;
+                fail(id, code, message);
+            }
+        })();
+        inFlight.add(task);
+        void task.finally(() => inFlight.delete(task));
+    }
+    try {
+        for await (const line of rl) {
+            if (!line.trim())
+                continue;
+            let frame;
+            try {
+                frame = JSON.parse(line);
+            }
+            catch {
+                // No id to answer against, so this is the one case that uses a null id,
+                // exactly as JSON-RPC 2.0 prescribes for unparseable input.
+                write({
+                    jsonrpc: "2.0",
+                    id: null,
+                    error: { code: RPC_PARSE_ERROR, message: "Invalid JSON" },
+                });
+                continue;
+            }
+            const { id, method } = frame;
+            if (typeof method !== "string") {
+                if (id !== undefined)
+                    fail(id, RPC_INVALID_REQUEST, "Missing 'method'");
+                continue;
+            }
+            // Notifications: no id, no response, ever — answering one is a protocol
+            // violation that some clients treat as a fatal desync.
+            if (id === undefined) {
+                if (method === "session/cancel")
+                    handleCancel();
+                continue;
+            }
+            serve(id, method, frame.params);
+        }
+    }
+    finally {
+        rl.close();
+        // The client is gone, so a turn still running has nowhere to report to.
+        // Cancelling first is what stops the wait below from being unbounded.
+        handleCancel();
+        // A disconnect mid-turn must still not tear the session out from under the
+        // run that is writing to it.
+        await Promise.allSettled([...inFlight]);
+        await disposeSession().catch(() => { });
+    }
+}
+/**
+ * CLI entry point: serve ACP on the real stdio, then exit.
+ *
+ * Split from {@link runAcpMode} so the protocol can be tested without the
+ * process-level side effects (signal handlers, logger teardown, exit codes).
+ */
+export async function runAcpModeCli(options) {
+    const onSigint = () => {
+        // An ACP agent is driven entirely by its client; Ctrl-C is the user asking
+        // the process to end, not the current turn to stop.
+        process.exit(130);
+    };
+    process.on("SIGINT", onSigint);
+    try {
+        await runAcpMode(options);
+    }
+    catch (err) {
+        process.stderr.write(`${formatUserError(err)}\n`);
+        process.exitCode = 1;
+    }
+    finally {
+        process.removeListener("SIGINT", onSigint);
+        closeLogger();
+    }
+}
+//# sourceMappingURL=acp-mode.js.map