@lucascouts/claude-agent-acp-plus 0.3.0 → 0.5.0

package/dist/tools.js

@@ -338,7 +338,80 @@ export function toolInfoFromToolUse(toolUse, supportsTerminalOutput = false, cwd
             };
     }
 }
-export function toolUpdateFromToolResult(toolResult, toolUse, supportsTerminalOutput = false) {
+/**
+ * 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;
+}
+export function toolUpdateFromToolResult(toolResult, toolUse, supportsTerminalOutput = false, toolUseResult) {
     if ("is_error" in toolResult &&
         toolResult.is_error &&
         toolResult.content &&
@@ -347,8 +420,57 @@ export function toolUpdateFromToolResult(toolResult, toolUse, supportsTerminalOu
         // 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":
+        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) => ({
@@ -376,19 +498,70 @@ export function toolUpdateFromToolResult(toolResult, toolUse, supportsTerminalOu
                 };
             }
             return {};
+        }
         case "Bash": {
             const result = toolResult.content;
-            const terminalId = "tool_use_id" in toolResult ? String(toolResult.tool_use_id) : "";
+            // 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. BetaBashCodeExecutionResultBlock: { type: "bash_code_execution_result", stdout, stderr, return_code }
-            // 2. Plain string content from a regular tool_result
-            // 3. Array content (e.g. [{ type: "text", text: "..." }] for stdout,
+            // 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;
-            if (result &&
+            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") {
@@ -413,7 +586,14 @@ export function toolUpdateFromToolResult(toolResult, toolUse, supportsTerminalOu
                     return toAcpContentUpdate(result, isError);
                 }
             }
-            if (supportsTerminalOutput) {
+            // 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: {
@@ -448,6 +628,36 @@ export function toolUpdateFromToolResult(toolResult, toolUse, supportsTerminalOu
             }
             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(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(stripAgentTrailerFromContent(toolResult.content), "is_error" in toolResult ? toolResult.is_error : false);
+        }
         case "Edit": // Edit is handled in hooks
         case "Write": {
             return {};
@@ -455,11 +665,47 @@ export function toolUpdateFromToolResult(toolResult, toolUse, supportsTerminalOu
         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 toAcpContentUpdate(toolResult.content, "is_error" in toolResult ? toolResult.is_error : false);
+            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})`;
+}
 function toAcpContentUpdate(content, isError = false) {
     if (Array.isArray(content) && content.length > 0) {
         return {
@@ -524,7 +770,7 @@ function toAcpContentBlock(content, isError) {
         case "tool_search_tool_result_error":
             return wrapText(`Error: ${content.error_code}${content.error_message ? ` - ${content.error_message}` : ""}`);
         case "web_search_result":
-            return wrapText(`${content.title} (${content.url})`);
+            return wrapText(formatWebSearchHit(content));
         case "web_search_tool_result_error":
             return wrapText(`Error: ${content.error_code}`);
         case "web_fetch_result":
@@ -698,7 +944,7 @@ export const registerHookCallback = (toolUseID, { onPostToolUseHook, }) => {
     };
 };
 /* A callback for Claude Code that is called when receiving a PostToolUse hook */
-export const createPostToolUseHook = (logger = console, options) => async (input, toolUseID) => {
+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) {
@@ -708,12 +954,8 @@ export const createPostToolUseHook = (logger = console, options) => async (input
             const onPostToolUseHook = toolUseCallbacks[toolUseID]?.onPostToolUseHook;
             if (onPostToolUseHook) {
                 await onPostToolUseHook(toolUseID, input.tool_input, input.tool_response);
-                delete toolUseCallbacks[toolUseID]; // Cleanup after execution
-            }
-            else {
-                logger.error(`No onPostToolUseHook found for tool use ID: ${toolUseID}`);
-                delete toolUseCallbacks[toolUseID];
             }
+            delete toolUseCallbacks[toolUseID]; // Cleanup after execution
         }
     }
     return { continue: true };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "ACP adapter for the Claude Agent SDK with VS Code-parity UX for Zed and other ACP clients — checkbox multi-select questions, refusal consent dialog, dynamic agent name. Fork of claude-agent-acp.",
   "main": "dist/lib.js",
   "types": "dist/lib.d.ts",
@@ -64,17 +64,20 @@
     "node": ">=24"
   },
   "dependencies": {
-    "@agentclientprotocol/sdk": "1.2.1",
-    "@anthropic-ai/claude-agent-sdk": "0.3.206",
+    "@agentclientprotocol/sdk": "1.3.0",
+    "@anthropic-ai/claude-agent-sdk": "0.3.220",
     "zod": "^3.25.0 || ^4.0.0"
   },
+  "overrides": {
+    "brace-expansion": "5.0.8"
+  },
   "devDependencies": {
-    "@anthropic-ai/sdk": "0.111.0",
+    "@anthropic-ai/sdk": "0.115.0",
     "@eslint/js": "10.0.1",
     "@tsconfig/node24": "24.0.4",
     "@types/node": "26.1.1",
-    "@typescript-eslint/eslint-plugin": "8.63.0",
-    "@typescript-eslint/parser": "8.63.0",
+    "@typescript-eslint/eslint-plugin": "8.64.0",
+    "@typescript-eslint/parser": "8.64.0",
     "eslint": "10.7.0",
     "eslint-config-prettier": "10.1.8",
     "globals": "17.7.0",

package/dist/ask-user-question-fallback.d.ts

@@ -1,78 +0,0 @@
-/**
- * Fallback for the built-in AskUserQuestion tool when the connected client does
- * NOT advertise `elicitation.form`. Upstream disables the tool for such clients;
- * this module lets the agent instead route each question through ACP's
- * `session/request_permission` dialog. The path is gated by the
- * `ACP_ASKUSERQUESTION_FALLBACK` env var so it can be turned off to restore
- * byte-for-byte upstream behavior.
- *
- * Alongside the env gate this module provides the pure mapping/orchestration
- * helpers (`questionPermissionOptions`, `handleAskUserQuestionViaPermission`);
- * the ACP client is injected by the adapter that wires them in.
- */
-import type { PermissionOption } from "@agentclientprotocol/sdk";
-import { type AskUserQuestion } from "./elicitation.js";
-/**
- * Whether the AskUserQuestion permission fallback is enabled for clients lacking
- * `elicitation.form`. Defaults ON: only an explicit `0` or `false` (trimmed,
- * case-insensitive) turns it off; any other value — unset, `1`, `true`, … —
- * leaves it on.
- *
- * @param env Environment map to read `ACP_ASKUSERQUESTION_FALLBACK` from (pass
- *   `process.env`).
- */
-export declare function askUserQuestionFallbackEnabled(env: Record<string, string | undefined>): boolean;
-/**
- * Map one AskUserQuestion question to the options shown in ACP's
- * `session/request_permission` dialog: one `allow_once` option per choice (in
- * order) followed by a trailing `reject_once` "Skip this question" option.
- *
- * Each choice's `optionId` is its bare `label` — the value the tool records as
- * the answer — so the description is never folded into the id; a non-empty
- * `description` is instead appended to the human-readable `name` as
- * `"<label> — <description>"`. The skip option is given a random `optionId`
- * that cannot collide with any label, so the orchestrator can recognize a skip
- * by id alone.
- *
- * @param question The single question whose choices become permission options.
- */
-export declare function questionPermissionOptions(question: AskUserQuestion): PermissionOption[];
-/**
- * Route an AskUserQuestion tool call through ACP permission requests rather than
- * a form elicitation, for clients that lack `elicitation.form`. Each question is
- * asked sequentially via the injected `requestPermission`; the selected label is
- * accumulated into `answers` (keyed by the question text), a skipped question is
- * omitted, and a multi-select question naturally degrades to a single label
- * since each option is single-select here.
- *
- * Mirrors the upstream form handler's contract: input with no parseable
- * questions denies with the identical message, and an aborted signal or a
- * cancelled request throws `"Tool use aborted"`, discarding every accumulated
- * answer. On success it returns the original `toolInput` augmented with
- * `answers` as `updatedInput`.
- *
- * Pure and injectable — the real ACP client is wired in by the adapter — so the
- * orchestration can be exercised without a transport.
- *
- * @param toolInput Raw AskUserQuestion tool input (expected to carry `questions`).
- * @param requestPermission Injected permission-request function, invoked once per
- *   question, resolving to the user's selection or a cancellation.
- * @param signal Abort signal for the tool call; checked on entry and around each
- *   request.
- */
-export declare function handleAskUserQuestionViaPermission(toolInput: Record<string, unknown>, requestPermission: (req: {
-    question: AskUserQuestion;
-    options: PermissionOption[];
-}) => Promise<{
-    outcome: "selected";
-    optionId: string;
-} | {
-    outcome: "cancelled";
-}>, signal: AbortSignal): Promise<{
-    behavior: "allow";
-    updatedInput: Record<string, unknown>;
-} | {
-    behavior: "deny";
-    message: string;
-}>;
-//# sourceMappingURL=ask-user-question-fallback.d.ts.map

package/dist/ask-user-question-fallback.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ask-user-question-fallback.d.ts","sourceRoot":"","sources":["../src/ask-user-question-fallback.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAA2B,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEjF;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,GAAG,OAAO,CAO/F;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,eAAe,GAAG,gBAAgB,EAAE,CAYvF;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,kCAAkC,CACtD,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,iBAAiB,EAAE,CAAC,GAAG,EAAE;IACvB,QAAQ,EAAE,eAAe,CAAC;IAC1B,OAAO,EAAE,gBAAgB,EAAE,CAAC;CAC7B,KAAK,OAAO,CAAC;IAAE,OAAO,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,WAAW,CAAA;CAAE,CAAC,EACnF,MAAM,EAAE,WAAW,GAClB,OAAO,CACN;IAAE,QAAQ,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GAC5D;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CACxC,CAyBA"}

package/dist/ask-user-question-fallback.js

@@ -1,104 +0,0 @@
-/**
- * Fallback for the built-in AskUserQuestion tool when the connected client does
- * NOT advertise `elicitation.form`. Upstream disables the tool for such clients;
- * this module lets the agent instead route each question through ACP's
- * `session/request_permission` dialog. The path is gated by the
- * `ACP_ASKUSERQUESTION_FALLBACK` env var so it can be turned off to restore
- * byte-for-byte upstream behavior.
- *
- * Alongside the env gate this module provides the pure mapping/orchestration
- * helpers (`questionPermissionOptions`, `handleAskUserQuestionViaPermission`);
- * the ACP client is injected by the adapter that wires them in.
- */
-import { randomUUID } from "node:crypto";
-import { extractAskUserQuestions } from "./elicitation.js";
-/**
- * Whether the AskUserQuestion permission fallback is enabled for clients lacking
- * `elicitation.form`. Defaults ON: only an explicit `0` or `false` (trimmed,
- * case-insensitive) turns it off; any other value — unset, `1`, `true`, … —
- * leaves it on.
- *
- * @param env Environment map to read `ACP_ASKUSERQUESTION_FALLBACK` from (pass
- *   `process.env`).
- */
-export function askUserQuestionFallbackEnabled(env) {
-    const raw = env.ACP_ASKUSERQUESTION_FALLBACK;
-    if (raw === undefined) {
-        return true;
-    }
-    const normalized = raw.trim().toLowerCase();
-    return normalized !== "0" && normalized !== "false";
-}
-/**
- * Map one AskUserQuestion question to the options shown in ACP's
- * `session/request_permission` dialog: one `allow_once` option per choice (in
- * order) followed by a trailing `reject_once` "Skip this question" option.
- *
- * Each choice's `optionId` is its bare `label` — the value the tool records as
- * the answer — so the description is never folded into the id; a non-empty
- * `description` is instead appended to the human-readable `name` as
- * `"<label> — <description>"`. The skip option is given a random `optionId`
- * that cannot collide with any label, so the orchestrator can recognize a skip
- * by id alone.
- *
- * @param question The single question whose choices become permission options.
- */
-export function questionPermissionOptions(question) {
-    const options = question.options.map((option) => ({
-        kind: "allow_once",
-        optionId: option.label,
-        name: option.description ? `${option.label} — ${option.description}` : option.label,
-    }));
-    options.push({
-        kind: "reject_once",
-        name: "Skip this question",
-        optionId: randomUUID(),
-    });
-    return options;
-}
-/**
- * Route an AskUserQuestion tool call through ACP permission requests rather than
- * a form elicitation, for clients that lack `elicitation.form`. Each question is
- * asked sequentially via the injected `requestPermission`; the selected label is
- * accumulated into `answers` (keyed by the question text), a skipped question is
- * omitted, and a multi-select question naturally degrades to a single label
- * since each option is single-select here.
- *
- * Mirrors the upstream form handler's contract: input with no parseable
- * questions denies with the identical message, and an aborted signal or a
- * cancelled request throws `"Tool use aborted"`, discarding every accumulated
- * answer. On success it returns the original `toolInput` augmented with
- * `answers` as `updatedInput`.
- *
- * Pure and injectable — the real ACP client is wired in by the adapter — so the
- * orchestration can be exercised without a transport.
- *
- * @param toolInput Raw AskUserQuestion tool input (expected to carry `questions`).
- * @param requestPermission Injected permission-request function, invoked once per
- *   question, resolving to the user's selection or a cancellation.
- * @param signal Abort signal for the tool call; checked on entry and around each
- *   request.
- */
-export async function handleAskUserQuestionViaPermission(toolInput, requestPermission, signal) {
-    if (signal.aborted) {
-        throw new Error("Tool use aborted");
-    }
-    const questions = extractAskUserQuestions(toolInput);
-    if (!questions) {
-        return { behavior: "deny", message: "AskUserQuestion called with no valid questions." };
-    }
-    const answers = {};
-    for (const question of questions) {
-        const options = questionPermissionOptions(question);
-        const skipOptionId = options.find((option) => option.kind === "reject_once")?.optionId;
-        const outcome = await requestPermission({ question, options });
-        if (outcome.outcome === "cancelled" || signal.aborted) {
-            throw new Error("Tool use aborted");
-        }
-        if (outcome.optionId === skipOptionId) {
-            continue;
-        }
-        answers[question.question] = outcome.optionId;
-    }
-    return { behavior: "allow", updatedInput: { ...toolInput, answers } };
-}