@agentclientprotocol/claude-agent-acp 0.85.2-preview.19 → 0.85.2-preview.3

package/dist/v2/prompt.d.ts

@@ -1,47 +0,0 @@
-/**
- * ACP v2 `session/prompt`, served through the turn events of `ClaudeAcpAgent`.
- *
- * v2 answers the prompt once Claude Code takes it in, with the id of the user
- * message it became, and reports the rest of the turn as `state_update`s.
- */
-import { type PromptRequest } from "@agentclientprotocol/sdk";
-import * as v2 from "@agentclientprotocol/sdk/experimental/v2";
-import type { ClaudeAcpAgent } from "../acp-agent.js";
-/**
- * Starts a turn for `params`, and answers when Claude Code takes the prompt
- * in. `send` delivers a session update of the prompt's session; it must not
- * throw, and must deliver updates in the order it is called, also relative to
- * the agent's own updates.
- *
- * - Taken in: the prompt's `user_message`, then `running`, then the answer.
- * - Waiting on a permission request or a question: `requires_action`, and
- *   `running` once none is open.
- * - Ended: `idle` with the stop reason, usage, and `_meta` of the turn.
- * - Failed after it was taken in: `idle` with {@link FAILED_STOP_REASON} and
- *   the JSON-RPC error that v1 answers with in `_meta.claudeCode.error`, and
- *   an error `notice` before it that shows the failure. v2 has no error on
- *   `idle`, and a notice must not be the only report of a failure.
- * - Ended or failed before it was taken in: the answer is a JSON-RPC error,
- *   `-32800` for a prompt that a cancel ended in the queue.
- *
- * Deferred decision: a turn whose background subagents still run ends only
- * when they finish (`Turn.deferredSettle`), so `idle` waits for them too. The
- * hold exists for v1, whose clients stop listening at the prompt response.
- * v2 allows background updates while idle, so it could report `idle` at the
- * turn's result instead, with a turn event for the hold. To be decided with
- * async tasks (step 6 in `docs/acp-v2.md`).
- */
-export declare function v2Prompt(agent: ClaudeAcpAgent, params: v2.PromptRequest, send: (update: v2.SessionUpdate) => void): Promise<v2.PromptResponse>;
-/**
- * The stop reason of a turn that failed after it was taken in. v2's stop
- * reasons all describe work that ended without an error, and a custom one
- * starts with `_`; clients show it as a generic stop.
- */
-export declare const FAILED_STOP_REASON = "_error";
-/**
- * A v2 prompt may hold content blocks that v1 cannot express: a custom one,
- * or one from a newer ACP version. Clients send only the kinds the agent
- * advertised, so such a block is rejected rather than silently dropped.
- */
-export declare function v1PromptRequest({ prompt, ...request }: v2.PromptRequest): PromptRequest;
-//# sourceMappingURL=prompt.d.ts.map

package/dist/v2/prompt.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../src/v2/prompt.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAIL,KAAK,aAAa,EAEnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,MAAM,0CAA0C,CAAC;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAItD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,cAAc,EACrB,MAAM,EAAE,EAAE,CAAC,aAAa,EACxB,IAAI,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,aAAa,KAAK,IAAI,GACvC,OAAO,CAAC,EAAE,CAAC,cAAc,CAAC,CA0D5B;AAED;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,WAAW,CAAC;AA2B3C;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,EAAE,EAAE,EAAE,CAAC,aAAa,GAAG,aAAa,CAEvF"}

package/dist/v2/prompt.js

@@ -1,153 +0,0 @@
-/**
- * ACP v2 `session/prompt`, served through the turn events of `ClaudeAcpAgent`.
- *
- * v2 answers the prompt once Claude Code takes it in, with the id of the user
- * message it became, and reports the rest of the turn as `state_update`s.
- */
-import { RequestError, } from "@agentclientprotocol/sdk";
-import * as v2 from "@agentclientprotocol/sdk/experimental/v2";
-import { splitNoticeText } from "../session-notices.js";
-/**
- * Starts a turn for `params`, and answers when Claude Code takes the prompt
- * in. `send` delivers a session update of the prompt's session; it must not
- * throw, and must deliver updates in the order it is called, also relative to
- * the agent's own updates.
- *
- * - Taken in: the prompt's `user_message`, then `running`, then the answer.
- * - Waiting on a permission request or a question: `requires_action`, and
- *   `running` once none is open.
- * - Ended: `idle` with the stop reason, usage, and `_meta` of the turn.
- * - Failed after it was taken in: `idle` with {@link FAILED_STOP_REASON} and
- *   the JSON-RPC error that v1 answers with in `_meta.claudeCode.error`, and
- *   an error `notice` before it that shows the failure. v2 has no error on
- *   `idle`, and a notice must not be the only report of a failure.
- * - Ended or failed before it was taken in: the answer is a JSON-RPC error,
- *   `-32800` for a prompt that a cancel ended in the queue.
- *
- * Deferred decision: a turn whose background subagents still run ends only
- * when they finish (`Turn.deferredSettle`), so `idle` waits for them too. The
- * hold exists for v1, whose clients stop listening at the prompt response.
- * v2 allows background updates while idle, so it could report `idle` at the
- * turn's result instead, with a turn event for the hold. To be decided with
- * async tasks (step 6 in `docs/acp-v2.md`).
- */
-export function v2Prompt(agent, params, send) {
-    return new Promise((resolve, reject) => {
-        let inserted = false;
-        const events = {
-            inserted(messageId) {
-                inserted = true;
-                send({ sessionUpdate: "user_message", messageId, content: params.prompt });
-                send({ sessionUpdate: "state_update", state: "running" });
-                resolve({ messageId });
-            },
-            awaitingUser() {
-                send({ sessionUpdate: "state_update", state: "requires_action" });
-            },
-            resumed() {
-                send({ sessionUpdate: "state_update", state: "running" });
-            },
-            ended(outcome) {
-                if (inserted) {
-                    send(idle(outcome));
-                }
-                else if (outcome.stopReason === "cancelled") {
-                    reject(RequestError.requestCancelled());
-                }
-                else {
-                    reject(RequestError.internalError({ stopReason: outcome.stopReason }, "The turn ended before Claude Code took the prompt in"));
-                }
-            },
-            failed(error, title) {
-                if (!inserted) {
-                    reject(error);
-                    return;
-                }
-                const failure = jsonRpcError(error);
-                send({
-                    sessionUpdate: "notice",
-                    severity: "error",
-                    ...splitNoticeText(title ?? failure.message, "The turn failed"),
-                });
-                send({
-                    sessionUpdate: "state_update",
-                    state: "idle",
-                    stopReason: FAILED_STOP_REASON,
-                    _meta: { claudeCode: { error: failure } },
-                });
-            },
-        };
-        let request;
-        try {
-            request = v1PromptRequest(params);
-        }
-        catch (error) {
-            reject(error);
-            return;
-        }
-        agent.startTurn(request, events).catch(reject);
-    });
-}
-/**
- * The stop reason of a turn that failed after it was taken in. v2's stop
- * reasons all describe work that ended without an error, and a custom one
- * starts with `_`; clients show it as a generic stop.
- */
-export const FAILED_STOP_REASON = "_error";
-/** The JSON-RPC error that v1 answers a failed prompt with. */
-function jsonRpcError(error) {
-    if (error instanceof RequestError) {
-        return {
-            code: error.code,
-            message: error.message,
-            ...(error.data !== undefined ? { data: error.data } : {}),
-        };
-    }
-    return {
-        code: RequestError.internalError().code,
-        message: error instanceof Error ? error.message : String(error),
-    };
-}
-function idle({ stopReason, usage, _meta }) {
-    return {
-        sessionUpdate: "state_update",
-        state: "idle",
-        stopReason,
-        ...(usage ? { usage } : {}),
-        ...(_meta ? { _meta } : {}),
-    };
-}
-/**
- * A v2 prompt may hold content blocks that v1 cannot express: a custom one,
- * or one from a newer ACP version. Clients send only the kinds the agent
- * advertised, so such a block is rejected rather than silently dropped.
- */
-export function v1PromptRequest({ prompt, ...request }) {
-    return { ...request, prompt: prompt.map(v1ContentBlock) };
-}
-function v1ContentBlock(block) {
-    if (v2.ContentBlock.isText(block) ||
-        v2.ContentBlock.isImage(block) ||
-        v2.ContentBlock.isAudio(block) ||
-        v2.ContentBlock.isResourceLink(block) ||
-        v2.ContentBlock.isResource(block)) {
-        const { annotations, ...rest } = block;
-        return annotations != null ? { ...rest, annotations: v1Annotations(annotations) } : rest;
-    }
-    throw RequestError.invalidParams({ type: block.type }, `Content blocks of type ${block.type} are not supported`);
-}
-/**
- * v2 also accepts audiences of a newer ACP version; v1 knows two. An audience
- * of only unknown roles is dropped rather than narrowed to nobody.
- */
-function v1Annotations({ audience, ...annotations }) {
-    if (audience == null)
-        return annotations;
-    const known = audience.filter(isV1Role);
-    return known.length > 0 || audience.length === 0
-        ? { ...annotations, audience: known }
-        : annotations;
-}
-function isV1Role(role) {
-    return role === "assistant" || role === "user";
-}

package/dist/v2/terminal.d.ts

@@ -1,42 +0,0 @@
-/**
- * Agent-owned display terminals for the commands that the agent runs.
- *
- * The agent reports a command through the terminal extension of ACP v1
- * clients, as codex-acp does: `_meta.terminal_info` names the terminal of a
- * tool call, whose content references it; `terminal_output` (a snapshot) or
- * `terminal_output_delta` (a chunk) carries the output, and `terminal_exit` the
- * exit. ACP v2 standardizes this as display-only terminals: the same content
- * reference, and `terminal_update` and `terminal_output_chunk` for the
- * terminal's state. The agent reports to a v2 client as to a client of the
- * extension (`ToolCallClientCapabilities.from`), and {@link V2Terminals} turns
- * the extension's keys into those updates.
- */
-import type { ToolCall, ToolCallUpdate } from "@agentclientprotocol/sdk";
-import type * as v2 from "@agentclientprotocol/sdk/experimental/v2";
-type V1ToolCallReport = (ToolCall & {
-    sessionUpdate: "tool_call";
-}) | (ToolCallUpdate & {
-    sessionUpdate: "tool_call_update";
-});
-/** The terminal updates of the tool call reports of one v2 connection. */
-export declare class V2Terminals {
-    /** The terminal and the last reported command of each running command, by session and tool call. */
-    private readonly running;
-    /**
-     * The terminal updates that a tool call report carries in the extension's
-     * keys, and the report without them, or undefined when nothing else is left
-     * in it.
-     *
-     * The extension names no command, so the terminal gets the command of the
-     * tool call's `rawInput` once a report carries it: the first report of a
-     * streamed tool use has no input yet.
-     */
-    split(sessionId: string, report: V1ToolCallReport): {
-        terminal: v2.SessionUpdate[];
-        report: V1ToolCallReport | undefined;
-    };
-    /** Forgets the terminals of a session. */
-    forget(sessionId: string): void;
-}
-export {};
-//# sourceMappingURL=terminal.d.ts.map

package/dist/v2/terminal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"terminal.d.ts","sourceRoot":"","sources":["../../src/v2/terminal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,KAAK,KAAK,EAAE,MAAM,0CAA0C,CAAC;AAEpE,KAAK,gBAAgB,GACjB,CAAC,QAAQ,GAAG;IAAE,aAAa,EAAE,WAAW,CAAA;CAAE,CAAC,GAC3C,CAAC,cAAc,GAAG;IAAE,aAAa,EAAE,kBAAkB,CAAA;CAAE,CAAC,CAAC;AAiB7D,0EAA0E;AAC1E,qBAAa,WAAW;IACtB,oGAAoG;IACpG,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA+D;IAEvF;;;;;;;;OAQG;IACH,KAAK,CACH,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,gBAAgB,GACvB;QAAE,QAAQ,EAAE,EAAE,CAAC,aAAa,EAAE,CAAC;QAAC,MAAM,EAAE,gBAAgB,GAAG,SAAS,CAAA;KAAE;IAuCzE,0CAA0C;IAC1C,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;CAKhC"}

package/dist/v2/terminal.js

@@ -1,95 +0,0 @@
-const TERMINAL_KEYS = [
-    "terminal_info",
-    "terminal_output",
-    "terminal_output_delta",
-    "terminal_exit",
-];
-/** The terminal updates of the tool call reports of one v2 connection. */
-export class V2Terminals {
-    /** The terminal and the last reported command of each running command, by session and tool call. */
-    running = new Map();
-    /**
-     * The terminal updates that a tool call report carries in the extension's
-     * keys, and the report without them, or undefined when nothing else is left
-     * in it.
-     *
-     * The extension names no command, so the terminal gets the command of the
-     * tool call's `rawInput` once a report carries it: the first report of a
-     * streamed tool use has no input yet.
-     */
-    split(sessionId, report) {
-        const meta = (report._meta ?? {});
-        const key = `${sessionId} ${report.toolCallId}`;
-        if (meta.terminal_info)
-            this.running.set(key, { terminalId: meta.terminal_info.terminal_id });
-        const terminal = [];
-        const running = this.running.get(key);
-        if (running) {
-            const command = commandOf(report.rawInput);
-            const newCommand = command !== undefined && command !== running.command;
-            if (newCommand)
-                running.command = command;
-            const { terminal_output: output, terminal_output_delta: delta, terminal_exit: exit } = meta;
-            if (meta.terminal_info || newCommand || output || exit) {
-                terminal.push({
-                    sessionUpdate: "terminal_update",
-                    terminalId: running.terminalId,
-                    ...(newCommand ? { command } : {}),
-                    ...(output ? { output: { data: base64(output.data) } } : {}),
-                    ...(exit
-                        ? {
-                            exitStatus: {
-                                exitCode: exit.exit_code,
-                                ...(exit.signal != null ? { signal: exit.signal } : {}),
-                            },
-                        }
-                        : {}),
-                });
-            }
-            if (delta) {
-                terminal.push({
-                    sessionUpdate: "terminal_output_chunk",
-                    terminalId: running.terminalId,
-                    data: base64(delta.data),
-                });
-            }
-            if (exit)
-                this.running.delete(key);
-        }
-        return { terminal, report: withoutTerminalKeys(report) };
-    }
-    /** Forgets the terminals of a session. */
-    forget(sessionId) {
-        for (const key of this.running.keys()) {
-            if (key.startsWith(`${sessionId} `))
-                this.running.delete(key);
-        }
-    }
-}
-/**
- * The report without the extension's keys, or undefined when it carried
- * nothing else but `_meta`: the output report of a command carries the output
- * alone, and only the stamps that every report of the tool call repeats. In v2
- * a concrete `_meta` replaces the stored one, so sending them would drop the
- * other keys that the tool call holds.
- */
-function withoutTerminalKeys(report) {
-    if (!report._meta || !TERMINAL_KEYS.some((key) => key in report._meta))
-        return report;
-    const meta = Object.fromEntries(Object.entries(report._meta).filter(([key]) => !TERMINAL_KEYS.includes(key)));
-    const stripped = { ...report };
-    if (Object.keys(meta).length > 0)
-        stripped._meta = meta;
-    else
-        delete stripped._meta;
-    const fields = Object.keys(stripped).filter((key) => key !== "sessionUpdate" && key !== "toolCallId" && key !== "_meta");
-    return fields.length > 0 || report.sessionUpdate === "tool_call" ? stripped : undefined;
-}
-function commandOf(rawInput) {
-    const command = rawInput?.command;
-    return typeof command === "string" && command.length > 0 ? command : undefined;
-}
-/** The output bytes, base64-encoded as a v2 terminal carries them. */
-function base64(text) {
-    return Buffer.from(text, "utf8").toString("base64");
-}

package/dist/v2/tool-call.d.ts

@@ -1,38 +0,0 @@
-/**
- * The v2 form of the tool call reports that `ClaudeAcpAgent` sends as v1
- * `tool_call` and `tool_call_update` updates, and in permission requests.
- */
-import type { ToolCall, ToolCallUpdate } from "@agentclientprotocol/sdk";
-import type * as v2 from "@agentclientprotocol/sdk/experimental/v2";
-type V1ToolCallReport = (ToolCall & {
-    sessionUpdate: "tool_call";
-}) | (ToolCallUpdate & {
-    sessionUpdate: "tool_call_update";
-});
-type V2ToolCallUpdate = v2.ToolCallUpdate & {
-    sessionUpdate: "tool_call_update";
-};
-/**
- * The v2 form of a v1 tool call report.
- *
- * v1 reports a new tool call with `tool_call` and changes it with
- * `tool_call_update`; v2 has one `tool_call_update` that upserts by
- * `toolCallId`. Both leave a field that a report omits unchanged, and both
- * replace `content` and `locations` as whole arrays. They differ on `null`:
- * in v1 it leaves the field unchanged too, in v2 it clears the field, so `null`
- * fields are left out.
- *
- * Diffs need what a v1 diff does not say, so the agent builds them in v2 form
- * for a v2 client (`v2DiffContent`), and they pass as they are. Terminal
- * content references a display terminal, as in v2: a v2 client has no client
- * terminals, so the agent's only terminals are those of its terminal extension
- * (see `terminal.ts`).
- */
-export declare function v2ToolCallUpdate(report: V1ToolCallReport): V2ToolCallUpdate;
-/**
- * The v2 form of the fields of a v1 tool call report, which a session update
- * and the subject of a permission request carry. See {@link v2ToolCallUpdate}.
- */
-export declare function v2ToolCallPatch(toolCall: ToolCall | ToolCallUpdate): v2.ToolCallUpdate;
-export {};
-//# sourceMappingURL=tool-call.d.ts.map

package/dist/v2/tool-call.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tool-call.d.ts","sourceRoot":"","sources":["../../src/v2/tool-call.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAmB,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1F,OAAO,KAAK,KAAK,EAAE,MAAM,0CAA0C,CAAC;AAEpE,KAAK,gBAAgB,GACjB,CAAC,QAAQ,GAAG;IAAE,aAAa,EAAE,WAAW,CAAA;CAAE,CAAC,GAC3C,CAAC,cAAc,GAAG;IAAE,aAAa,EAAE,kBAAkB,CAAA;CAAE,CAAC,CAAC;AAE7D,KAAK,gBAAgB,GAAG,EAAE,CAAC,cAAc,GAAG;IAAE,aAAa,EAAE,kBAAkB,CAAA;CAAE,CAAC;AAElF;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,GAAG,gBAAgB,CAE3E;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,QAAQ,GAAG,cAAc,GAAG,EAAE,CAAC,cAAc,CAUtF"}

package/dist/v2/tool-call.js

@@ -1,49 +0,0 @@
-/**
- * The v2 form of a v1 tool call report.
- *
- * v1 reports a new tool call with `tool_call` and changes it with
- * `tool_call_update`; v2 has one `tool_call_update` that upserts by
- * `toolCallId`. Both leave a field that a report omits unchanged, and both
- * replace `content` and `locations` as whole arrays. They differ on `null`:
- * in v1 it leaves the field unchanged too, in v2 it clears the field, so `null`
- * fields are left out.
- *
- * Diffs need what a v1 diff does not say, so the agent builds them in v2 form
- * for a v2 client (`v2DiffContent`), and they pass as they are. Terminal
- * content references a display terminal, as in v2: a v2 client has no client
- * terminals, so the agent's only terminals are those of its terminal extension
- * (see `terminal.ts`).
- */
-export function v2ToolCallUpdate(report) {
-    return { ...v2ToolCallPatch(report), sessionUpdate: "tool_call_update" };
-}
-/**
- * The v2 form of the fields of a v1 tool call report, which a session update
- * and the subject of a permission request carry. See {@link v2ToolCallUpdate}.
- */
-export function v2ToolCallPatch(toolCall) {
-    const patch = Object.fromEntries(Object.entries(toolCall).filter(([key, value]) => value !== null && key !== "sessionUpdate" && key !== "content"));
-    return {
-        ...patch,
-        ...(toolCall.content != null ? { content: toolCall.content.map(v2ToolCallContent) } : {}),
-    };
-}
-function v2ToolCallContent(item) {
-    switch (item.type) {
-        case "content":
-            // v2 content blocks are a superset of the v1 blocks.
-            return item;
-        case "terminal":
-            return item;
-        default:
-            if (isV2Diff(item))
-                return item;
-            // A v1 diff names one path, with old and new texts that can be a
-            // snippet: v2 cannot say which operation it is, nor give its patch.
-            throw new Error("An ACP v2 client cannot take a v1 diff");
-    }
-}
-/** A diff that the agent built in v2 form, which travels as v1 content. */
-function isV2Diff(item) {
-    return "changes" in item;
-}