viberoom 0.3.0 → 0.4.0

package/vendor/acp/claude-agent-acp/dist/tools.js

@@ -0,0 +1,1235 @@
+import path from "node:path";
+/**
+ * Convert an absolute file path to a project-relative path for display.
+ * Returns the original path if it's outside the project directory or if no cwd is provided.
+ */
+export function toDisplayPath(filePath, cwd) {
+    if (!cwd)
+        return filePath;
+    const resolvedCwd = path.resolve(cwd);
+    const resolvedFile = path.resolve(filePath);
+    if (resolvedFile.startsWith(resolvedCwd + path.sep) || resolvedFile === resolvedCwd) {
+        return path.relative(resolvedCwd, resolvedFile);
+    }
+    return filePath;
+}
+export function toolInfoFromToolUse(toolUse, supportsTerminalOutput = false, cwd) {
+    const name = toolUse.name;
+    switch (name) {
+        case "Agent":
+        case "Task": {
+            const input = toolUse.input;
+            return {
+                title: input?.description ? input.description : "Task",
+                kind: "think",
+                content: input && "prompt" in input
+                    ? [
+                        {
+                            type: "content",
+                            content: { type: "text", text: input.prompt },
+                        },
+                    ]
+                    : [],
+            };
+        }
+        case "Bash": {
+            const input = toolUse.input;
+            return {
+                title: input?.command ? input.command : "Terminal",
+                kind: "execute",
+                content: supportsTerminalOutput
+                    ? [{ type: "terminal", terminalId: toolUse.id }]
+                    : input && input.description
+                        ? [
+                            {
+                                type: "content",
+                                content: { type: "text", text: input.description },
+                            },
+                        ]
+                        : [],
+            };
+        }
+        case "Read": {
+            const input = toolUse.input;
+            let limit = "";
+            if (input?.limit && input.limit > 0) {
+                limit = " (" + (input.offset ?? 1) + " - " + ((input.offset ?? 1) + input.limit - 1) + ")";
+            }
+            else if (input?.offset) {
+                limit = " (from line " + input.offset + ")";
+            }
+            const displayPath = input?.file_path ? toDisplayPath(input.file_path, cwd) : "File";
+            return {
+                title: "Read " + displayPath + limit,
+                kind: "read",
+                locations: input?.file_path
+                    ? [
+                        {
+                            path: input.file_path,
+                            line: input.offset ?? 1,
+                        },
+                    ]
+                    : [],
+                content: [],
+            };
+        }
+        case "Write": {
+            const input = toolUse.input;
+            let content = [];
+            if (input && input.file_path) {
+                content = [
+                    {
+                        type: "diff",
+                        path: input.file_path,
+                        oldText: null,
+                        newText: input.content,
+                    },
+                ];
+            }
+            else if (input && input.content) {
+                content = [
+                    {
+                        type: "content",
+                        content: { type: "text", text: input.content },
+                    },
+                ];
+            }
+            const displayPath = input?.file_path ? toDisplayPath(input.file_path, cwd) : undefined;
+            return {
+                title: displayPath ? `Write ${displayPath}` : "Preparing file…",
+                kind: "edit",
+                content,
+                locations: input?.file_path ? [{ path: input.file_path }] : [],
+            };
+        }
+        case "Edit": {
+            const input = toolUse.input;
+            let content = [];
+            if (input && input.file_path && (input.old_string || input.new_string)) {
+                content = [
+                    {
+                        type: "diff",
+                        path: input.file_path,
+                        oldText: input.old_string || null,
+                        newText: input.new_string ?? "",
+                    },
+                ];
+            }
+            const displayPath = input?.file_path ? toDisplayPath(input.file_path, cwd) : undefined;
+            return {
+                title: displayPath ? `Edit ${displayPath}` : "Edit",
+                kind: "edit",
+                content,
+                locations: input?.file_path ? [{ path: input.file_path }] : [],
+            };
+        }
+        case "Glob": {
+            const input = toolUse.input;
+            let label = "Find";
+            if (input?.path) {
+                label += ` \`${input.path}\``;
+            }
+            if (input?.pattern) {
+                label += ` \`${input.pattern}\``;
+            }
+            return {
+                title: label,
+                kind: "search",
+                content: [],
+                locations: input?.path ? [{ path: input.path }] : [],
+            };
+        }
+        case "Grep": {
+            const input = toolUse.input;
+            let label = "grep";
+            if (input?.["-i"]) {
+                label += " -i";
+            }
+            if (input?.["-n"]) {
+                label += " -n";
+            }
+            if (input?.["-A"] !== undefined) {
+                label += ` -A ${input["-A"]}`;
+            }
+            if (input?.["-B"] !== undefined) {
+                label += ` -B ${input["-B"]}`;
+            }
+            if (input?.["-C"] !== undefined) {
+                label += ` -C ${input["-C"]}`;
+            }
+            if (input?.output_mode) {
+                switch (input.output_mode) {
+                    case "files_with_matches":
+                        label += " -l";
+                        break;
+                    case "count":
+                        label += " -c";
+                        break;
+                    case "content":
+                    default:
+                        break;
+                }
+            }
+            if (input?.head_limit !== undefined) {
+                label += ` | head -${input.head_limit}`;
+            }
+            if (input?.glob) {
+                label += ` --include="${input.glob}"`;
+            }
+            if (input?.type) {
+                label += ` --type=${input.type}`;
+            }
+            if (input?.multiline) {
+                label += " -P";
+            }
+            if (input?.pattern) {
+                label += ` "${input.pattern}"`;
+            }
+            if (input?.path) {
+                label += ` ${input.path}`;
+            }
+            return {
+                title: label,
+                kind: "search",
+                content: [],
+            };
+        }
+        case "WebFetch": {
+            const input = toolUse.input;
+            return {
+                title: input?.url ? `Fetch ${input.url}` : "Fetch",
+                kind: "fetch",
+                content: input && input.prompt
+                    ? [
+                        {
+                            type: "content",
+                            content: { type: "text", text: input.prompt },
+                        },
+                    ]
+                    : [],
+            };
+        }
+        case "WebSearch": {
+            const input = toolUse.input;
+            return {
+                title: input?.query ? `Search "${input.query}"` : "Web search",
+                kind: "fetch",
+                content: [],
+            };
+        }
+        case "TodoWrite": {
+            const input = toolUse.input;
+            return {
+                title: Array.isArray(input?.todos)
+                    ? `Update TODOs: ${input.todos.map((todo) => todo.content).join(", ")}`
+                    : "Update TODOs",
+                kind: "think",
+                content: [],
+            };
+        }
+        case "ReportFindings": {
+            const input = toolUse.input;
+            const findings = input?.findings ?? [];
+            return {
+                title: findings.length === 0
+                    ? "Report findings: none found"
+                    : `Report ${findings.length} finding${findings.length === 1 ? "" : "s"}`,
+                kind: "think",
+                content: findings.map((finding) => ({
+                    type: "content",
+                    content: {
+                        type: "text",
+                        text: `**${finding.file}${finding.line ? `:${finding.line}` : ""}** — ${finding.summary}`,
+                    },
+                })),
+            };
+        }
+        case "TaskCreate": {
+            const input = toolUse.input;
+            return {
+                title: input?.subject ? `Create task: ${input.subject}` : "Create task",
+                kind: "think",
+                content: [],
+            };
+        }
+        case "TaskUpdate": {
+            const input = toolUse.input;
+            return {
+                title: input?.subject ? `Update task: ${input.subject}` : "Update task",
+                kind: "think",
+                content: [],
+            };
+        }
+        case "TaskList": {
+            return {
+                title: "List tasks",
+                kind: "think",
+                content: [],
+            };
+        }
+        case "TaskGet": {
+            return {
+                title: "Get task",
+                kind: "think",
+                content: [],
+            };
+        }
+        case "ExitPlanMode": {
+            const planInput = toolUse.input;
+            return {
+                title: "Approve Plan",
+                kind: "switch_mode",
+                content: planInput?.plan
+                    ? [{ type: "content", content: { type: "text", text: planInput.plan } }]
+                    : [],
+            };
+        }
+        case "Skill": {
+            const input = toolUse.input;
+            const skillName = input?.skill;
+            return {
+                title: skillName ? `Load skill: ${skillName}` : "Load skill",
+                kind: "other",
+                content: [],
+            };
+        }
+        case "AskUserQuestion": {
+            const input = toolUse.input;
+            const questions = Array.isArray(input?.questions) ? input.questions : [];
+            return {
+                title: questions.length === 1 && questions[0]?.question
+                    ? questions[0].question
+                    : "Asking for your input",
+                kind: "other",
+                content: questions
+                    .filter((q) => typeof q?.question === "string")
+                    .map((q) => ({
+                    type: "content",
+                    content: { type: "text", text: q.question },
+                })),
+            };
+        }
+        case "Other": {
+            const input = toolUse.input;
+            let output;
+            try {
+                output = JSON.stringify(input, null, 2);
+            }
+            catch {
+                output = typeof input === "string" ? input : "{}";
+            }
+            return {
+                title: name || "Unknown Tool",
+                kind: "other",
+                content: [
+                    {
+                        type: "content",
+                        content: {
+                            type: "text",
+                            text: `\`\`\`json\n${output}\`\`\``,
+                        },
+                    },
+                ],
+            };
+        }
+        default:
+            return {
+                title: name || "Unknown Tool",
+                kind: "other",
+                content: [],
+            };
+    }
+}
+/**
+ * Narrow the untyped message-level `tool_use_result` toward a per-tool Output
+ * shape: rejects everything but a plain non-null object (arrays pass a bare
+ * `typeof === "object"` check, so they're excluded here). The returned value
+ * is only *nominally* typed — it arrives over the wire from arbitrary CLI
+ * versions, so each caller must still guard the specific fields it reads
+ * before trusting them.
+ */
+function structuredResult(toolUseResult) {
+    return toolUseResult !== null &&
+        typeof toolUseResult === "object" &&
+        !Array.isArray(toolUseResult)
+        ? toolUseResult
+        : undefined;
+}
+/**
+ * Strip the model-directed trailer from a raw Agent/Task tool_result text:
+ * a `<usage>…</usage>` totals block and/or an
+ * `agentId: <id> (use SendMessage …)` continuation line at the end of the
+ * text. Both patterns are tail-anchored and independent (older CLIs emit
+ * variants with only one of them), so a format change makes them stop
+ * matching rather than mangle the report.
+ */
+function stripAgentTrailer(text) {
+    return stripAgentIdLine(stripUsageBlock(text));
+}
+const USAGE_OPEN = "<usage>";
+const USAGE_CLOSE = "</usage>";
+/** Remove a trailing `<usage>…</usage>` block, plus trailing whitespace and
+ *  one preceding newline. Matches from the *last* `<usage>` so a report that
+ *  merely mentions the marker earlier isn't truncated at the mention. */
+function stripUsageBlock(text) {
+    const body = text.trimEnd();
+    if (!body.endsWith(USAGE_CLOSE)) {
+        return text;
+    }
+    const open = body.lastIndexOf(USAGE_OPEN, body.length - USAGE_CLOSE.length - USAGE_OPEN.length);
+    if (open === -1) {
+        return text;
+    }
+    return body.slice(0, open > 0 && body[open - 1] === "\n" ? open - 1 : open);
+}
+/** The continuation line, anchored to a whole line so the regex has a single
+ *  start position and no ambiguous repetition (`[\w-]+` can't consume the
+ *  following space, `[^)]*` can't consume the closing paren) — it runs in
+ *  linear time on any input. */
+const AGENT_ID_LINE = /^agentId: [\w-]+ \([^)]*\)$/;
+/** Remove a final `agentId: <id> (…)` line, plus trailing whitespace and the
+ *  newline that preceded the line. */
+function stripAgentIdLine(text) {
+    const body = text.trimEnd();
+    const lineStart = body.lastIndexOf("\n") + 1;
+    if (!AGENT_ID_LINE.test(body.slice(lineStart))) {
+        return text;
+    }
+    return body.slice(0, Math.max(lineStart - 1, 0));
+}
+/** Apply {@link stripAgentTrailer} across a raw tool_result `content` (plain
+ *  string or block array), leaving non-text blocks untouched. */
+function stripAgentTrailerFromContent(content) {
+    if (typeof content === "string") {
+        return stripAgentTrailer(content);
+    }
+    if (Array.isArray(content)) {
+        return content.map((block) => block !== null &&
+            typeof block === "object" &&
+            block.type === "text" &&
+            typeof block.text === "string"
+            ? { ...block, text: stripAgentTrailer(block.text) }
+            : block);
+    }
+    return content;
+}
+/** Leading model-directed note the CLI prepends to a subagent's report when
+ *  the agent stopped at its maxTurns limit (CLI 2.1.246+); the result still
+ *  ships as `status: "completed"`. Two body variants follow this prefix, and
+ *  the trailing "Send the agent a message (SendMessage) …" sentence is
+ *  omitted for some agent types — anchor only the stable prefix so a format
+ *  change makes the replacement stop matching rather than mangle a report. */
+const PARTIAL_OUTPUT_NOTE = /^NOTE: this agent stopped at its \d+-turn limit before finishing\./;
+/** Client-facing replacement: the partial-output fact matters to the user,
+ *  but the SendMessage continuation instruction is model-directed and
+ *  meaningless over ACP. */
+const PARTIAL_OUTPUT_LABEL = "[Agent stopped at its turn limit — the output below is partial]";
+/** Replace a leading partial-output note paragraph with the concise
+ *  client-facing label, leaving the report that follows intact. */
+function replacePartialNoteInText(text) {
+    if (!PARTIAL_OUTPUT_NOTE.test(text))
+        return text;
+    const paragraphEnd = text.indexOf("\n\n");
+    const report = paragraphEnd === -1 ? "" : text.slice(paragraphEnd + 2).trimStart();
+    return report ? `${PARTIAL_OUTPUT_LABEL}\n\n${report}` : PARTIAL_OUTPUT_LABEL;
+}
+/** Apply {@link replacePartialNoteInText} to an Agent/Task result `content`.
+ *  In the structured AgentOutput lane the note is its own leading text block;
+ *  in the raw lane it is the first paragraph of the text — both reduce to
+ *  transforming the first text block (or the plain string). */
+function replacePartialOutputNote(content) {
+    if (typeof content === "string") {
+        return replacePartialNoteInText(content);
+    }
+    if (Array.isArray(content) && content.length > 0) {
+        const [first, ...rest] = content;
+        if (first !== null &&
+            typeof first === "object" &&
+            first.type === "text" &&
+            typeof first.text === "string") {
+            return [{ ...first, text: replacePartialNoteInText(first.text) }, ...rest];
+        }
+    }
+    return content;
+}
+export function toolUpdateFromToolResult(toolResult, toolUse, supportsTerminalOutput = false, toolUseResult) {
+    if ("is_error" in toolResult &&
+        toolResult.is_error &&
+        toolResult.content &&
+        toolResult.content.length > 0 &&
+        !(toolUse?.name === "Bash" && supportsTerminalOutput)) {
+        // Only return errors
+        return toAcpContentUpdate(toolResult.content, true);
+    }
+    // Shared raw-text fallback: renders the tool_result content the model saw.
+    // The structured cases below fall back to this when `tool_use_result` is
+    // absent or fails its shape guard (older CLIs, replayed sessions).
+    const rawContentUpdate = () => toAcpContentUpdate(toolResult.content, "is_error" in toolResult ? toolResult.is_error : false);
+    switch (toolUse?.name) {
+        case "Read": {
+            // The raw tool_result text is the model-facing view: line-numbered
+            // content plus any appended <system-reminder> blocks (malicious-code
+            // checks, memory staleness notes, …) that clients shouldn't see. The
+            // structured FileReadOutput carries the clean content — rebuild the
+            // line-numbered view from it. Non-text variants (image/notebook/pdf)
+            // fall back to the raw content blocks, which already render fine.
+            const structuredRead = structuredResult(toolUseResult);
+            if (structuredRead?.type === "text" &&
+                typeof structuredRead.file?.content === "string" &&
+                // An empty file has nothing to line-number; keep the raw view (the
+                // model-facing "file is empty" note) rather than a phantom blank line.
+                structuredRead.file.content.length > 0) {
+                // startLine is typed non-optional but defended anyway; a Read's
+                // `offset` input is the same 1-based starting line, so it beats a
+                // blind 1 when an emitter omits the field.
+                const startLine = structuredRead.file.startLine ??
+                    toolUse.input?.offset ??
+                    1;
+                // A trailing newline is a line terminator, not an extra line — don't
+                // number a phantom empty line after it.
+                let numbered = structuredRead.file.content
+                    .replace(/\n$/, "")
+                    .split("\n")
+                    .map((line, i) => `${startLine + i}\t${line}`)
+                    .join("\n");
+                // The model-facing truncation banner doesn't survive reconstruction
+                // from file.content (the SDK flag exists for exactly this case) —
+                // re-establish it so a partial first page doesn't read as the whole
+                // file.
+                if (structuredRead.file.truncatedByTokenCap) {
+                    const { numLines, totalLines } = structuredRead.file;
+                    const detail = typeof numLines === "number" && typeof totalLines === "number"
+                        ? `: showing ${numLines} of ${totalLines} lines`
+                        : "";
+                    numbered += `\n[File truncated${detail}]`;
+                }
+                return {
+                    content: [
+                        {
+                            type: "content",
+                            content: { type: "text", text: markdownEscape(numbered) },
+                        },
+                    ],
+                };
+            }
+            if (Array.isArray(toolResult.content) && toolResult.content.length > 0) {
+                return {
+                    content: toolResult.content.map((content) => ({
+                        type: "content",
+                        content: content.type === "text"
+                            ? {
+                                type: "text",
+                                text: markdownEscape(content.text),
+                            }
+                            : toAcpContentBlock(content, false),
+                    })),
+                };
+            }
+            else if (typeof toolResult.content === "string" && toolResult.content.length > 0) {
+                return {
+                    content: [
+                        {
+                            type: "content",
+                            content: {
+                                type: "text",
+                                text: markdownEscape(toolResult.content),
+                            },
+                        },
+                    ],
+                };
+            }
+            return {};
+        }
+        case "Bash": {
+            const result = toolResult.content;
+            // The terminal was announced under the tool_use's own id (see
+            // `toolInfoFromToolUse`), so key the output/exit metas off that: it is the
+            // id the client actually created a terminal for. `toolResult.tool_use_id`
+            // is the same value whenever present — the caller looks the tool_use up by
+            // it — so preferring `toolUse.id` only adds a source for the case where the
+            // result block carries no id at all. Anything that isn't a non-empty
+            // string is no id at all: `""` matches no terminal, and stringifying a
+            // present-but-undefined field would invent the literal `"undefined"`.
+            const terminalIdOf = (id) => typeof id === "string" && id.length > 0 ? id : undefined;
+            const terminalId = terminalIdOf(toolUse?.id) ??
+                terminalIdOf("tool_use_id" in toolResult ? toolResult.tool_use_id : undefined);
+            const isError = "is_error" in toolResult && toolResult.is_error;
+            // Extract output and exit code from either format:
+            // 1. The structured BashOutput (message-level tool_use_result): its
+            //    stdout/stderr exclude the model-directed suffixes the raw text
+            //    carries (stale-read hints, gh rate-limit hints, the
+            //    persisted-output wrapper for too-large outputs — the interruption
+            //    and truncation facts those carried are re-established from the
+            //    structured flags below). Skipped for image output (the raw content
+            //    array carries the actual image blocks) and backgrounded commands
+            //    (the raw text carries the background-task notice; structured
+            //    stdout may be empty).
+            // 2. BetaBashCodeExecutionResultBlock: { type: "bash_code_execution_result", stdout, stderr, return_code }
+            // 3. Plain string content from a regular tool_result
+            // 4. Array content (e.g. [{ type: "text", text: "..." }] for stdout,
+            //    or [{ type: "image", source: {...} }] when the local Bash tool
+            //    produces an image, e.g. piping a base64 data URI)
+            let output = "";
+            let exitCode = isError ? 1 : 0;
+            const structuredBash = structuredResult(toolUseResult);
+            if (structuredBash &&
+                typeof structuredBash.stdout === "string" &&
+                typeof structuredBash.stderr === "string" &&
+                !structuredBash.isImage &&
+                structuredBash.backgroundTaskId === undefined) {
+                output = [structuredBash.stdout, structuredBash.stderr].filter(Boolean).join("\n");
+                // Two raw-text notices don't survive the structured stdout/stderr —
+                // re-establish them so the client isn't shown a clean-looking result:
+                // the CLI appends its abort marker only to the model-facing text, and
+                // an aborted command isn't a success, so synthesize a failing exit
+                // code when the result wasn't already an error.
+                if (structuredBash.interrupted) {
+                    output = [output, "[Command was aborted before completion]"].filter(Boolean).join("\n");
+                    exitCode = 1;
+                }
+                // Structured stdout is clipped (~30k chars) when the full output was
+                // persisted to disk; without this note the clip is silent and the
+                // path to the full output is lost.
+                if (typeof structuredBash.persistedOutputPath === "string") {
+                    const size = typeof structuredBash.persistedOutputSize === "number"
+                        ? ` (${structuredBash.persistedOutputSize} bytes total)`
+                        : "";
+                    output = [
+                        output,
+                        `[Output truncated${size}: full output saved to ${structuredBash.persistedOutputPath}]`,
+                    ]
+                        .filter(Boolean)
+                        .join("\n");
+                }
+            }
+            else if (result &&
+                typeof result === "object" &&
+                "type" in result &&
+                result.type === "bash_code_execution_result") {
+                const bashResult = result;
+                output = [bashResult.stdout, bashResult.stderr].filter(Boolean).join("\n");
+                exitCode = bashResult.return_code;
+            }
+            else if (typeof result === "string") {
+                output = result;
+            }
+            else if (Array.isArray(result) && result.length > 0) {
+                const textOnly = result.every((c) => c && typeof c === "object" && typeof c.text === "string");
+                if (textOnly) {
+                    output = result.map((c) => c.text).join("\n");
+                }
+                else {
+                    // Image (or mixed non-text) content. Binary payloads can't be
+                    // streamed through the terminal-output _meta channel, so bypass
+                    // it and surface the blocks as ACP content. This handles the
+                    // local Bash tool's image output, which previously failed the
+                    // text-only guard and was silently dropped.
+                    return toAcpContentUpdate(result, isError);
+                }
+            }
+            // Without a terminal id there is nothing the client can reconcile these
+            // metas against, and emitting them anyway strands the output: a client that
+            // buffers output/exit for terminals it has not been told about (Zed keeps
+            // them in `pending_terminal_output`/`pending_terminal_exit`, drained only on
+            // a matching create) would hold them forever behind an id that never
+            // arrives, showing an empty terminal. Fall through to the code-block
+            // rendering below instead.
+            if (supportsTerminalOutput && terminalId !== undefined) {
+                return {
+                    content: [{ type: "terminal", terminalId }],
+                    _meta: {
+                        terminal_info: {
+                            terminal_id: terminalId,
+                        },
+                        terminal_output: {
+                            terminal_id: terminalId,
+                            data: output,
+                        },
+                        terminal_exit: {
+                            terminal_id: terminalId,
+                            exit_code: exitCode,
+                            signal: null,
+                        },
+                    },
+                };
+            }
+            // Fallback: format output as a code block without terminal _meta
+            if (output.trim()) {
+                return {
+                    content: [
+                        {
+                            type: "content",
+                            content: {
+                                type: "text",
+                                text: `\`\`\`console\n${output.trimEnd()}\n\`\`\``,
+                            },
+                        },
+                    ],
+                };
+            }
+            return {};
+        }
+        case "Agent":
+        case "Task": {
+            // The raw tool_result text ends with a model-directed trailer (an
+            // `agentId: … (use SendMessage …)` line plus a `<usage>` totals block)
+            // that ACP clients shouldn't see. The message-level `tool_use_result`
+            // carries the structured AgentOutput whose `content` is the subagent's
+            // report without the trailer — render from it when present (per the SDK
+            // 0.3.207 guidance) and fall back to the raw text otherwise (older CLIs,
+            // replayed sessions).
+            // Narrowed to the full union, not the completed variant — the status
+            // check below is what discriminates it, and pre-narrowing would let
+            // future field reads typecheck against a variant the runtime value may
+            // not be.
+            const structured = structuredResult(toolUseResult);
+            if (structured?.status === "completed" &&
+                Array.isArray(structured.content) &&
+                // A completed subagent can end with zero text blocks; an empty
+                // structured render would beat the raw fallback for no benefit.
+                structured.content.length > 0) {
+                return toAcpContentUpdate(
+                // A maxTurns-stopped subagent still completes, with a model-directed
+                // partial-output note prepended to its report — swap it for a
+                // client-facing label (see PARTIAL_OUTPUT_NOTE).
+                replacePartialOutputNote(structured.content), "is_error" in toolResult ? toolResult.is_error : false);
+            }
+            // No structured report to render from (replayed sessions —
+            // getSessionMessages doesn't expose the transcript's toolUseResult —
+            // and older CLIs). The SDK advises rendering from tool_use_result
+            // instead of parsing the text, but with no structured value the
+            // tail-anchored strip is the only cleanup available; if the trailer
+            // format changes it simply stops matching and the full raw text
+            // renders, no worse than before.
+            return toAcpContentUpdate(
+            // Head and tail cleanups are independent: the partial-output note
+            // leads the raw text the same way it leads the structured content.
+            replacePartialOutputNote(stripAgentTrailerFromContent(toolResult.content)), "is_error" in toolResult ? toolResult.is_error : false);
+        }
+        case "Skill": {
+            return {};
+        }
+        case "Edit": // Edit is handled in hooks
+        case "Write": {
+            return {};
+        }
+        case "ExitPlanMode": {
+            return { title: "Exited Plan Mode" };
+        }
+        case "WebSearch": {
+            // The raw tool_result text is a model-directed dump ("Web search
+            // results for query: …\n\nLinks: [{…json…}]"). The structured
+            // WebSearchOutput carries the hits — render them the way server-side
+            // web_search_result blocks render ("Title (url)").
+            const structuredSearch = structuredResult(toolUseResult);
+            if (structuredSearch && Array.isArray(structuredSearch.results)) {
+                const lines = structuredSearch.results.flatMap((entry) => typeof entry === "string"
+                    ? [entry]
+                    : Array.isArray(entry?.content)
+                        ? // tool_use_result arrives untyped across CLI version skew —
+                            // skip off-spec hits rather than rendering
+                            // "undefined (undefined)" lines.
+                            entry.content.flatMap((hit) => typeof hit?.title === "string" && typeof hit?.url === "string"
+                                ? [formatWebSearchHit(hit)]
+                                : [])
+                        : []);
+                if (lines.length > 0) {
+                    return {
+                        content: [
+                            {
+                                type: "content",
+                                content: { type: "text", text: lines.join("\n") },
+                            },
+                        ],
+                    };
+                }
+            }
+            return rawContentUpdate();
+        }
+        default: {
+            return rawContentUpdate();
+        }
+    }
+}
+/** One display format for a web-search hit, shared by the structured
+ *  WebSearchOutput render and the server-side `web_search_result` block so
+ *  the two paths can't drift. */
+function formatWebSearchHit(hit) {
+    return `${hit.title} (${hit.url})`;
+}
+/** Human-readable size for the document placeholder ("312 B", "2.4 KB",
+ *  "1.3 MB"). */
+function formatByteSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function toAcpContentUpdate(content, isError = false) {
+    if (Array.isArray(content) && content.length > 0) {
+        return {
+            content: content.map((c) => ({
+                type: "content",
+                content: toAcpContentBlock(c, isError),
+            })),
+        };
+    }
+    else if (typeof content === "object" && content !== null && "type" in content) {
+        return {
+            content: [
+                {
+                    type: "content",
+                    content: toAcpContentBlock(content, isError),
+                },
+            ],
+        };
+    }
+    else if (typeof content === "string" && content.length > 0) {
+        return {
+            content: [
+                {
+                    type: "content",
+                    content: {
+                        type: "text",
+                        text: isError ? `\`\`\`\n${content}\n\`\`\`` : content,
+                    },
+                },
+            ],
+        };
+    }
+    return {};
+}
+function toAcpContentBlock(content, isError) {
+    const wrapText = (text) => ({
+        type: "text",
+        text: isError ? `\`\`\`\n${text}\n\`\`\`` : text,
+    });
+    switch (content.type) {
+        case "text":
+            return {
+                type: "text",
+                text: isError ? `\`\`\`\n${content.text}\n\`\`\`` : content.text,
+            };
+        case "image":
+            if (content.source.type === "base64") {
+                return {
+                    type: "image",
+                    data: content.source.data,
+                    mimeType: content.source.media_type,
+                };
+            }
+            // URL and file-based images can't be converted to ACP format (requires data)
+            return wrapText(content.source.type === "url"
+                ? `[image: ${content.source.url}]`
+                : "[image: file reference]");
+        case "document": {
+            // A PDF Read delivers its raw `document` block inside the tool_result
+            // content (SDK 0.3.243 moved it here from a separate follow-up user
+            // message; the MultiRead documents lane always lived here). ACP has no
+            // document block and the base64 payload can be megabytes — render a
+            // compact placeholder, never the data, matching the CLI's own compact
+            // "Read PDF (size)" rendering.
+            const title = typeof content.title === "string" && content.title.length > 0 ? ` "${content.title}"` : "";
+            const source = content.source;
+            switch (source.type) {
+                case "url":
+                    return wrapText(`[document${title}: ${source.url}]`);
+                case "base64":
+                case "text":
+                    // base64 inflates the byte count by 4/3; plain text is 1:1.
+                    return wrapText(`[document${title}: ${source.media_type}, ${formatByteSize(source.type === "base64"
+                        ? Math.floor((source.data.length * 3) / 4)
+                        : source.data.length)}]`);
+                default:
+                    return wrapText(`[document${title}]`);
+            }
+        }
+        case "tool_reference":
+            return wrapText(`Tool: ${content.tool_name}`);
+        case "tool_search_tool_search_result":
+            return wrapText(`Tools found: ${content.tool_references.map((r) => r.tool_name).join(", ") || "none"}`);
+        case "tool_search_tool_result_error":
+            return wrapText(`Error: ${content.error_code}${content.error_message ? ` - ${content.error_message}` : ""}`);
+        case "web_search_result":
+            return wrapText(formatWebSearchHit(content));
+        case "web_search_tool_result_error":
+            return wrapText(`Error: ${content.error_code}`);
+        case "web_fetch_result":
+            return wrapText(`Fetched: ${content.url}`);
+        case "web_fetch_tool_result_error":
+            return wrapText(`Error: ${content.error_code}`);
+        case "code_execution_result":
+            return wrapText(`Output: ${content.stdout || content.stderr || ""}`);
+        case "bash_code_execution_result":
+            return wrapText(`Output: ${content.stdout || content.stderr || ""}`);
+        case "code_execution_tool_result_error":
+        case "bash_code_execution_tool_result_error":
+            return wrapText(`Error: ${content.error_code}`);
+        case "text_editor_code_execution_view_result":
+            return wrapText(content.content);
+        case "text_editor_code_execution_create_result":
+            return wrapText(content.is_file_update ? "File updated" : "File created");
+        case "text_editor_code_execution_str_replace_result":
+            return wrapText(content.lines?.join("\n") || "");
+        case "text_editor_code_execution_tool_result_error":
+            return wrapText(`Error: ${content.error_code}${content.error_message ? ` - ${content.error_message}` : ""}`);
+        default:
+            return wrapText(JSON.stringify(content));
+    }
+}
+export function planEntries(input) {
+    return (input?.todos ?? []).map((todo) => ({
+        content: todo.status === "in_progress" && todo.activeForm ? todo.activeForm : todo.content,
+        status: todo.status,
+        priority: "medium",
+    }));
+}
+/**
+ * Best-effort parse of a structured Task* tool_result. The SDK delivers tool
+ * outputs either as a string or as an array of TextBlockParam-like blocks
+ * containing JSON text; try both.
+ */
+function parseJsonToolOutput(content, isExpectedOutput) {
+    const tryParse = (text) => {
+        try {
+            const parsed = JSON.parse(text);
+            return isExpectedOutput(parsed) ? parsed : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    if (typeof content === "string") {
+        return tryParse(content);
+    }
+    if (content && typeof content === "object" && !Array.isArray(content)) {
+        return isExpectedOutput(content) ? content : undefined;
+    }
+    if (Array.isArray(content)) {
+        for (const block of content) {
+            if (block && typeof block === "object" && "type" in block && block.type === "text") {
+                const text = block.text;
+                if (typeof text === "string") {
+                    const parsed = tryParse(text);
+                    if (parsed)
+                        return parsed;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function toolOutputTexts(content) {
+    if (typeof content === "string")
+        return [content];
+    if (!Array.isArray(content))
+        return [];
+    return content.flatMap((block) => block &&
+        typeof block === "object" &&
+        "type" in block &&
+        block.type === "text" &&
+        "text" in block &&
+        typeof block.text === "string"
+        ? [block.text]
+        : []);
+}
+export function parseTaskCreateOutput(content) {
+    const structured = parseJsonToolOutput(content, (parsed) => Boolean(parsed &&
+        typeof parsed === "object" &&
+        "task" in parsed &&
+        parsed.task &&
+        typeof parsed.task === "object" &&
+        "id" in parsed.task &&
+        typeof parsed.task.id === "string"));
+    if (structured)
+        return structured;
+    for (const text of toolOutputTexts(content)) {
+        const match = /^Task #(\S+) created successfully: (.+)$/.exec(text.trim());
+        if (match)
+            return { task: { id: match[1], subject: match[2] } };
+    }
+    return undefined;
+}
+export function parseTaskListOutput(content) {
+    const validStatuses = new Set(["pending", "in_progress", "completed"]);
+    const structured = parseJsonToolOutput(content, (parsed) => Boolean(parsed &&
+        typeof parsed === "object" &&
+        "tasks" in parsed &&
+        Array.isArray(parsed.tasks) &&
+        parsed.tasks.every((task) => task &&
+            typeof task === "object" &&
+            typeof task.id === "string" &&
+            typeof task.subject === "string" &&
+            typeof task.status === "string" &&
+            validStatuses.has(task.status))));
+    if (structured)
+        return structured;
+    for (const text of toolOutputTexts(content)) {
+        if (text.trim() === "No tasks found")
+            return { tasks: [] };
+        const tasks = [];
+        const lines = text.trim().split("\n");
+        for (const line of lines) {
+            const match = /^#(\S+) \[(pending|in_progress|completed)\] (.+?)(?: \(([^()]*)\))?(?: \[blocked by ((?:#[^,\]]+(?:, )?)+)\])?$/.exec(line);
+            if (!match) {
+                tasks.length = 0;
+                break;
+            }
+            tasks.push({
+                id: match[1],
+                subject: match[3],
+                status: match[2],
+                ...(match[4] ? { owner: match[4] } : {}),
+                blockedBy: match[5] ? match[5].split(", ").map((id) => id.slice(1)) : [],
+            });
+        }
+        if (tasks.length > 0)
+            return { tasks };
+    }
+    return undefined;
+}
+export function parseTaskUpdateOutput(content, expectedTaskId) {
+    const structured = parseJsonToolOutput(content, (parsed) => Boolean(parsed &&
+        typeof parsed === "object" &&
+        "success" in parsed &&
+        typeof parsed.success === "boolean" &&
+        "taskId" in parsed &&
+        typeof parsed.taskId === "string" &&
+        "updatedFields" in parsed &&
+        Array.isArray(parsed.updatedFields) &&
+        parsed.updatedFields.every((field) => typeof field === "string")));
+    if (structured)
+        return structured;
+    for (const text of toolOutputTexts(content)) {
+        const notFound = /^Task #(\S+) not found$/.exec(text.trim());
+        const taskId = notFound?.[1] ?? expectedTaskId;
+        if (taskId && (notFound || text.trim() === "Failed to delete task")) {
+            return { success: false, taskId, updatedFields: [], error: text.trim() };
+        }
+    }
+    return undefined;
+}
+export function applyTaskCreate(state, input, output) {
+    const taskId = output?.task?.id;
+    if (!taskId || !input)
+        return;
+    state.set(taskId, {
+        subject: input.subject,
+        status: "pending",
+        activeForm: input.activeForm,
+        description: input.description,
+    });
+}
+export function applyTaskUpdate(state, input) {
+    if (!input?.taskId)
+        return;
+    if (input.status === "deleted") {
+        state.delete(input.taskId);
+        return;
+    }
+    const existing = state.get(input.taskId);
+    // Without a subject from either the existing entry or the update payload,
+    // we'd produce a plan entry with empty `content` — drop the update.
+    const subject = input.subject ?? existing?.subject;
+    if (!subject)
+        return;
+    state.set(input.taskId, {
+        subject,
+        status: input.status ?? existing?.status ?? "pending",
+        activeForm: input.activeForm ?? existing?.activeForm,
+        description: input.description ?? existing?.description,
+    });
+}
+export function applyTaskList(state, output) {
+    const previous = new Map(state);
+    state.clear();
+    for (const task of output.tasks) {
+        const existing = previous.get(task.id);
+        state.set(task.id, {
+            subject: task.subject,
+            status: task.status,
+            activeForm: existing?.activeForm,
+            description: existing?.description,
+        });
+    }
+}
+export function taskStateToPlanEntries(state) {
+    return Array.from(state.values()).map((task) => ({
+        content: task.status === "in_progress" && task.activeForm ? task.activeForm : task.subject,
+        status: task.status,
+        priority: "medium",
+    }));
+}
+export function markdownEscape(text) {
+    let escape = "```";
+    for (const [m] of text.matchAll(/^```+/gm)) {
+        while (m.length >= escape.length) {
+            escape += "`";
+        }
+    }
+    return escape + "\n" + text + (text.endsWith("\n") ? "" : "\n") + escape;
+}
+/**
+ * Builds diff ToolUpdate content from the structured toolResponse provided by
+ * the PostToolUse hook for diff-producing tools (Edit, Write). Unlike parsing
+ * the plain unified diff string, this uses the pre-parsed structuredPatch
+ * which supports multiple replacement sites (replaceAll) and always includes
+ * context lines for better readability.
+ */
+export function toolUpdateFromDiffToolResponse(toolResponse) {
+    if (!toolResponse || typeof toolResponse !== "object")
+        return {};
+    const response = toolResponse;
+    if (!response.filePath || !Array.isArray(response.structuredPatch))
+        return {};
+    const content = [];
+    const locations = [];
+    for (const { lines, newStart } of response.structuredPatch) {
+        const oldText = [];
+        const newText = [];
+        for (const line of lines) {
+            if (line.startsWith("-")) {
+                oldText.push(line.slice(1));
+            }
+            else if (line.startsWith("+")) {
+                newText.push(line.slice(1));
+            }
+            else {
+                oldText.push(line.slice(1));
+                newText.push(line.slice(1));
+            }
+        }
+        if (oldText.length > 0 || newText.length > 0) {
+            locations.push({ path: response.filePath, line: newStart });
+            content.push({
+                type: "diff",
+                path: response.filePath,
+                oldText: oldText.join("\n") || null,
+                newText: newText.join("\n"),
+            });
+        }
+    }
+    // A Write `update` can arrive with an empty structuredPatch — nothing
+    // changed, the diff timed out, or the previous content was too large to
+    // diff (originalFile null; SDK 0.3.252 documents the lane). Returning `{}`
+    // would leave Write's optimistic tool_use-time content standing, and that
+    // was built with `oldText: null` — "creation" semantics — so an overwrite
+    // of a large existing file would render as creating it. Emit a truthful
+    // replacement instead. Gated on `type` so Edit (whose output carries no
+    // `type` and whose optimistic old/new diff is already truthful) keeps the
+    // empty-return behavior.
+    if (content.length === 0 && response.type === "update" && typeof response.content === "string") {
+        locations.push({ path: response.filePath });
+        content.push(typeof response.originalFile === "string"
+            ? {
+                type: "diff",
+                path: response.filePath,
+                oldText: response.originalFile,
+                newText: response.content,
+            }
+            : {
+                type: "content",
+                content: {
+                    type: "text",
+                    text: `Updated \`${response.filePath}\` (previous content too large to diff)`,
+                },
+            });
+    }
+    const result = {};
+    if (content.length > 0)
+        result.content = content;
+    if (locations.length > 0)
+        result.locations = locations;
+    return result;
+}
+/* Callbacks are keyed globally because the SDK hook is process-wide, but each
+ * entry retains its owning ACP session so cancellation/teardown can release it. */
+const toolUseCallbacks = new Map();
+/* Setup callbacks that will be called when receiving hooks from Claude Code */
+export const registerHookCallback = (toolUseID, { onPostToolUseHook, }, ownerId) => {
+    unregisterHookCallback(toolUseID);
+    toolUseCallbacks.set(toolUseID, {
+        ownerId,
+        onPostToolUseHook,
+    });
+};
+export function unregisterHookCallback(toolUseID) {
+    const callback = toolUseCallbacks.get(toolUseID);
+    if (callback?.cleanupTimer)
+        clearTimeout(callback.cleanupTimer);
+    toolUseCallbacks.delete(toolUseID);
+}
+/** PostToolUse normally follows tool_result, so keep the callback for a short
+ * grace period while still bounding retention when the hook never arrives. */
+export function completeHookCallback(toolUseID) {
+    const callback = toolUseCallbacks.get(toolUseID);
+    if (!callback || callback.cleanupTimer)
+        return;
+    callback.cleanupTimer = setTimeout(() => unregisterHookCallback(toolUseID), 30_000);
+    callback.cleanupTimer.unref?.();
+}
+export function clearHookCallbacks(ownerId) {
+    for (const [toolUseID, callback] of toolUseCallbacks) {
+        if (callback.ownerId === ownerId)
+            unregisterHookCallback(toolUseID);
+    }
+}
+/* A callback for Claude Code that is called when receiving a PostToolUse hook */
+export const createPostToolUseHook = (options) => async (input, toolUseID) => {
+    if (input.hook_event_name === "PostToolUse") {
+        // Handle EnterPlanMode tool - notify client of mode change after successful execution
+        if (input.tool_name === "EnterPlanMode" && options?.onEnterPlanMode) {
+            await options.onEnterPlanMode();
+        }
+        if (toolUseID) {
+            const onPostToolUseHook = toolUseCallbacks.get(toolUseID)?.onPostToolUseHook;
+            try {
+                if (onPostToolUseHook) {
+                    await onPostToolUseHook(toolUseID, input.tool_input, input.tool_response);
+                }
+            }
+            finally {
+                unregisterHookCallback(toolUseID);
+            }
+        }
+    }
+    return { continue: true };
+};
+/**
+ * Hook callback for `TaskCreated` / `TaskCompleted` events. The SDK fires
+ * these for both user-facing TaskCreate tool calls and subagent task
+ * creation, giving us `task_id` + `task_subject` without having to parse
+ * tool_result payloads.
+ *
+ * Populating `taskState` from the hook means a later `TaskUpdate` (which
+ * typically only carries `taskId` + `status`) finds an existing entry with
+ * a real subject, instead of synthesizing a placeholder with empty content.
+ */
+export const createTaskHook = (options) => async (input) => {
+    const taskId = "task_id" in input && typeof input.task_id === "string" ? input.task_id : undefined;
+    if (!taskId)
+        return { continue: true };
+    if (input.hook_event_name === "TaskCreated") {
+        if (!input.task_subject)
+            return { continue: true };
+        if (options.taskState.has(taskId))
+            return { continue: true };
+        options.taskState.set(taskId, {
+            subject: input.task_subject,
+            status: "pending",
+            description: input.task_description,
+        });
+        if (options.onChange)
+            await options.onChange();
+    }
+    else if (input.hook_event_name === "TaskCompleted") {
+        const existing = options.taskState.get(taskId);
+        if (!existing || existing.status === "completed")
+            return { continue: true };
+        options.taskState.set(taskId, { ...existing, status: "completed" });
+        if (options.onChange)
+            await options.onChange();
+    }
+    return { continue: true };
+};