@agentclientprotocol/claude-agent-acp 0.81.3-preview.1 → 0.81.3-preview.2

package/dist/diff.js

@@ -1,10 +1,207 @@
-import { AIR_DIFF_STATS_KEY, withAirMeta } from "./air-extension.js";
+import { structuredPatch } from "diff";
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import path from "node:path";
+import { AIR_DIFF_PATCH_CAPABILITY, withAirMeta } from "./air-extension.js";
+import { normalizeWriteInput } from "./tool-calls/reporters/file-edit.js";
 /**
- * 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.
+ * The largest file, in bytes, that the adapter turns into a git patch.
+ *
+ * A larger file, a larger new text, or an Edit whose result can be larger
+ * gets no patch. The tool call then keeps its standard ACP content. The limit
+ * bounds the file read, the replacement, and the line diff that run while
+ * Claude waits for an approval.
+ */
+export const MAX_PATCH_FILE_BYTES = 1024 * 1024;
+/**
+ * The wall-clock budget, in milliseconds, of one line diff for a patch.
+ *
+ * The diff runs synchronously, so the budget is also the longest block of the
+ * event loop.
+ */
+const PATCH_DIFF_TIMEOUT_MS = 100;
+/** The number of context lines around a change in a hunk. */
+const PATCH_CONTEXT_LINES = 3;
+/** Git reads this many leading bytes to decide that a file is binary. */
+const BINARY_SNIFF_BYTES = 8000;
+const NO_NEWLINE_MARKER = "\";
+/**
+ * Builds the exact patch shown before Claude runs an Edit or Write tool.
+ *
+ * Returns undefined when the adapter cannot predict the file change exactly.
+ * The caller then keeps the standard tool-call content. The adapter declines
+ * a file that is missing for an Edit, too large, binary, or that has CR line
+ * endings. Claude converts the line endings of an edited file, so an in-memory
+ * replacement would not match the bytes that Claude writes. It also declines
+ * an `old_string` that does not match exactly once, because Claude then
+ * normalizes quotes or fails.
+ *
+ * A Write always gets content that shows the change: the patch, the standard
+ * diff of a text that cannot have an exact patch, or a notice that the Write
+ * overwrites a file that the adapter cannot show.
+ *
+ * The preview uses the tool input as it is. Claude can still remove the
+ * trailing whitespace of a line before it writes. The PostToolUse hook then
+ * sends the patch of the written file.
+ */
+export async function previewPatchContent(toolName, input, cwd) {
+    if (toolName === "Edit") {
+        const edit = input;
+        if (typeof edit.file_path !== "string" ||
+            typeof edit.old_string !== "string" ||
+            typeof edit.new_string !== "string") {
+            return undefined;
+        }
+        const oldString = edit.old_string;
+        const filePath = resolveToolPath(edit.file_path, cwd);
+        const oldText = await readPatchSource(filePath);
+        if (oldText === undefined)
+            return undefined;
+        const newString = edit.new_string;
+        if (oldString === newString || !isPatchableText(newString))
+            return undefined;
+        if (oldString.length === 0) {
+            // An empty old_string creates the file, or fills an existing file that
+            // holds only whitespace. `trim` also removes a byte order mark, whose
+            // handling the adapter does not predict, so such a file is declined.
+            if (oldText !== null && (oldText.trim() !== "" || oldText.includes("\uFEFF"))) {
+                return undefined;
+            }
+            return optionalContent(filePatch(filePath, oldText, newString)?.content);
+        }
+        if (oldText === null)
+            return undefined;
+        const occurrences = oldText.split(oldString).length - 1;
+        if (occurrences === 0 || (edit.replace_all !== true && occurrences !== 1))
+            return undefined;
+        if (replacedTextBytesBound(oldText, oldString, newString, occurrences) > MAX_PATCH_FILE_BYTES) {
+            return undefined;
+        }
+        const newText = replacedText(oldText, oldString, newString, edit.replace_all === true);
+        return optionalContent(filePatch(filePath, oldText, newText)?.content);
+    }
+    if (toolName === "Write") {
+        const write = normalizeWriteInput(input);
+        if (typeof write?.file_path !== "string" || typeof write.content !== "string") {
+            return undefined;
+        }
+        // The Write tool call shows no diff, so the approval is the only place that
+        // shows what the Write changes.
+        const content = write.content;
+        const filePath = resolveToolPath(write.file_path, cwd);
+        const oldText = await readPatchSource(filePath);
+        if (oldText === undefined) {
+            return [
+                {
+                    type: "content",
+                    content: {
+                        type: "text",
+                        text: `Overwrites the existing file \`${write.file_path}\`. The adapter cannot show its current content.`,
+                    },
+                },
+            ];
+        }
+        if (oldText === content)
+            return undefined;
+        const standard = [
+            { type: "diff", path: write.file_path, oldText, newText: content },
+        ];
+        if (!isPatchableText(content))
+            return standard;
+        // A dense change can exceed the diff budget. The approval then shows the standard diff.
+        return optionalContent(filePatch(filePath, oldText, content)?.content) ?? standard;
+    }
+    return undefined;
+}
+/**
+ * An upper bound of the UTF-8 size, in bytes, of {@link replacedText}.
+ *
+ * The caller checks the bound before it builds the text. A `replace_all` of
+ * many short matches with a long `newString` can otherwise build a text of
+ * gigabytes before the timed line diff starts.
+ */
+function replacedTextBytesBound(fileText, oldString, newString, occurrences) {
+    const growth = Buffer.byteLength(newString, "utf8") - Buffer.byteLength(oldString, "utf8");
+    return Buffer.byteLength(fileText, "utf8") + occurrences * Math.max(0, growth);
+}
+/**
+ * The file text after Claude replaces `oldString` with `newString`.
+ *
+ * An empty `newString` deletes a line: when `oldString` does not end with a
+ * line break and the file holds `oldString` and a line break, Claude also
+ * removes that line break. With `replaceAll`, it then replaces only the
+ * occurrences that a line break follows.
+ */
+function replacedText(fileText, oldString, newString, replaceAll) {
+    const target = newString === "" && !oldString.endsWith("\n") && fileText.includes(`${oldString}\n`)
+        ? `${oldString}\n`
+        : oldString;
+    return replaceAll
+        ? fileText.split(target).join(newString)
+        : fileText.replace(target, () => newString);
+}
+/**
+ * Builds the git patch for a finished Edit or Write from the file on disk.
+ *
+ * The Claude SDK `structuredPatch` is display data: Claude converts leading
+ * tabs to spaces and CRLF line endings to LF before it computes the hunks. A
+ * patch built from those hunks does not match the file. This function diffs
+ * `originalFile` against the written file instead. It returns undefined when
+ * it cannot build an exact patch, and the caller then sends the standard diff.
+ * A written file that contains a CR or a byte order mark is declined, because
+ * Claude removed those bytes from `originalFile`.
+ */
+export async function patchUpdateFromDiffToolResponse(toolResponse) {
+    if (!toolResponse || typeof toolResponse !== "object")
+        return undefined;
+    const response = toolResponse;
+    if (typeof response.filePath !== "string")
+        return undefined;
+    // An Edit with an empty old_string reports "" as the original of a created
+    // file and of an existing empty file. The response does not tell the two
+    // apart, so the caller keeps the standard diff.
+    if (response.type === undefined && response.oldString === "" && response.originalFile === "") {
+        return undefined;
+    }
+    // A Write whose content is the previous text changed nothing. The file on
+    // disk can hold a later change, and that change is not the change of this Write.
+    if (response.type === "update" &&
+        typeof response.content === "string" &&
+        response.originalFile === response.content) {
+        return undefined;
+    }
+    const oldText = response.type === "create"
+        ? null
+        : typeof response.originalFile === "string"
+            ? response.originalFile
+            : undefined;
+    if (oldText === undefined)
+        return undefined;
+    // The same size limit as the new side: a larger text gets the standard diff.
+    if (oldText !== null && Buffer.byteLength(oldText, "utf8") > MAX_PATCH_FILE_BYTES)
+        return undefined;
+    const newText = await readPatchSource(response.filePath);
+    if (typeof newText !== "string" || newText.startsWith("\uFEFF"))
+        return undefined;
+    if (response.type === "create" && newText !== response.content)
+        return undefined;
+    const patch = filePatch(response.filePath, oldText, newText);
+    if (!patch)
+        return undefined;
+    return {
+        content: [patch.content],
+        // A created file keeps the location of its Write tool call.
+        locations: oldText === null
+            ? [{ path: response.filePath }]
+            : patch.hunks.map(({ newStart }) => ({ path: response.filePath, line: newStart })),
+    };
+}
+/**
+ * Builds standard ACP diff 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")
@@ -14,67 +211,20 @@ export function toolUpdateFromDiffToolResponse(toolResponse) {
         return {};
     const content = [];
     const locations = [];
-    let previousOldEnd = 0;
-    let previousNewEnd = 0;
-    let accumulatedDelta = 0;
-    let coordinatesRemainConsistent = true;
-    for (const { lines, oldStart, newStart, oldLines, newLines } of response.structuredPatch) {
+    for (const { lines, newStart } of response.structuredPatch) {
         const oldText = [];
         const newText = [];
-        let added = 0;
-        let removed = 0;
-        let validPrefixes = true;
-        let validEofMarkers = true;
-        const oldPosition = oldStart + (oldLines === 0 ? 1 : 0);
-        const newPosition = newStart + (newLines === 0 ? 1 : 0);
-        const oldEnd = oldPosition + oldLines;
-        const newEnd = newPosition + newLines;
-        const nextDelta = accumulatedDelta + newLines - oldLines;
-        const validCoordinates = coordinatesRemainConsistent &&
-            Number.isSafeInteger(oldStart) &&
-            Number.isSafeInteger(newStart) &&
-            Number.isSafeInteger(oldLines) &&
-            Number.isSafeInteger(newLines) &&
-            oldStart >= (oldLines === 0 ? 0 : 1) &&
-            newStart >= (newLines === 0 ? 0 : 1) &&
-            oldLines >= 0 &&
-            newLines >= 0 &&
-            Number.isSafeInteger(oldPosition) &&
-            Number.isSafeInteger(newPosition) &&
-            Number.isSafeInteger(oldEnd) &&
-            Number.isSafeInteger(newEnd) &&
-            Number.isSafeInteger(nextDelta) &&
-            oldPosition >= previousOldEnd &&
-            newPosition >= previousNewEnd &&
-            newPosition - oldPosition === accumulatedDelta;
-        coordinatesRemainConsistent = validCoordinates;
-        if (validCoordinates) {
-            previousOldEnd = oldEnd;
-            previousNewEnd = newEnd;
-            accumulatedDelta = nextDelta;
-        }
-        for (const [index, line] of lines.entries()) {
+        for (const line of lines) {
             if (line.startsWith("-")) {
                 oldText.push(line.slice(1));
-                removed++;
             }
             else if (line.startsWith("+")) {
                 newText.push(line.slice(1));
-                added++;
             }
-            else if (line === "\") {
-                const previousLine = lines[index - 1];
-                if (typeof previousLine !== "string" ||
-                    (!previousLine.startsWith("-") &&
-                        !previousLine.startsWith("+") &&
-                        !previousLine.startsWith(" "))) {
-                    validEofMarkers = false;
-                }
+            else if (line === NO_NEWLINE_MARKER) {
                 continue;
             }
             else {
-                if (!line.startsWith(" "))
-                    validPrefixes = false;
                 oldText.push(line.slice(1));
                 newText.push(line.slice(1));
             }
@@ -86,13 +236,6 @@ export function toolUpdateFromDiffToolResponse(toolResponse) {
                 path: response.filePath,
                 oldText: oldText.join("\n") || null,
                 newText: newText.join("\n"),
-                ...(validCoordinates &&
-                    validPrefixes &&
-                    validEofMarkers &&
-                    oldText.length === oldLines &&
-                    newText.length === newLines
-                    ? { _meta: withAirMeta(undefined, AIR_DIFF_STATS_KEY, { version: 1, added, removed }) }
-                    : {}),
             });
         }
     }
@@ -104,7 +247,9 @@ export function toolUpdateFromDiffToolResponse(toolResponse) {
     // 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.
+    // empty-return behavior. A `create` needs nothing here: the
+    // tool_use-time diff shows the created file, and a client with diffPatch
+    // gets it from the Write reporter.
     if (content.length === 0 && response.type === "update" && typeof response.content === "string") {
         locations.push({ path: response.filePath });
         content.push(typeof response.originalFile === "string"
@@ -129,3 +274,229 @@ export function toolUpdateFromDiffToolResponse(toolResponse) {
         result.locations = locations;
     return result;
 }
+/**
+ * The text of one git patch for `filePath`.
+ *
+ * The headers follow `git diff`: the path loses its leading slash, gets the
+ * `a/` and `b/` prefixes, and is quoted when git would quote it. A created
+ * file gets its mode line and a `/dev/null` side.
+ */
+export function gitPatchText(filePath, change, hunks) {
+    return [
+        ...gitPatchHeader(filePath, change),
+        ...hunks.flatMap((hunk) => [hunkHeader(hunk), ...hunk.lines]),
+        "",
+    ].join("\n");
+}
+function gitPatchHeader(filePath, change) {
+    // git drops one leading slash of an absolute path; a Windows path gets
+    // forward slashes so the header names the same file on every platform.
+    const name = filePath.replaceAll("\\", "/").replace(/^\/+/u, "");
+    const oldName = quoteGitPath("a/", name);
+    const newName = quoteGitPath("b/", name);
+    // git ends a ---/+++ name that contains a space with a tab, for GNU patch.
+    const tab = name.includes(" ") ? "\t" : "";
+    return [
+        `diff --git ${oldName} ${newName}`,
+        ...(change === "create" ? ["new file mode 100644"] : []),
+        `--- ${change === "create" ? "/dev/null" : `${oldName}${tab}`}`,
+        `+++ ${newName}${tab}`,
+    ];
+}
+const GIT_PATH_ESCAPES = {
+    0x07: "a",
+    0x08: "b",
+    0x09: "t",
+    0x0a: "n",
+    0x0b: "v",
+    0x0c: "f",
+    0x0d: "r",
+    0x22: '"',
+    0x5c: "\\",
+};
+/**
+ * Quotes `prefix + name` like git with the default `core.quotePath`.
+ *
+ * A double quote, a backslash, a control byte, or a non-ASCII byte makes git
+ * put the whole name in double quotes. git then writes a C escape or a
+ * three-digit octal escape for each such UTF-8 byte.
+ */
+function quoteGitPath(prefix, name) {
+    const full = `${prefix}${name}`;
+    let quoted = "";
+    let needsQuotes = false;
+    for (const byte of Buffer.from(full, "utf8")) {
+        const escape = GIT_PATH_ESCAPES[byte];
+        if (escape !== undefined) {
+            quoted += `\\${escape}`;
+            needsQuotes = true;
+        }
+        else if (byte < 0x20 || byte >= 0x7f) {
+            quoted += `\\${byte.toString(8).padStart(3, "0")}`;
+            needsQuotes = true;
+        }
+        else {
+            quoted += String.fromCharCode(byte);
+        }
+    }
+    return needsQuotes ? `"${quoted}"` : full;
+}
+function hunkHeader({ oldStart, oldLines, newStart, newLines }) {
+    return `@@ -${hunkRange(oldStart, oldLines)} +${hunkRange(newStart, newLines)} @@`;
+}
+/** A git hunk range. A side with zero lines names the line before the change. */
+function hunkRange(start, count) {
+    if (count === 0)
+        return `${Math.max(0, start - 1)},0`;
+    return count === 1 ? String(start) : `${start},${count}`;
+}
+/** The hunk that adds every line of `text` to an empty file. */
+function wholeFileHunk(text) {
+    if (text.length === 0)
+        return undefined;
+    const terminated = text.endsWith("\n");
+    const lines = (terminated ? text.slice(0, -1) : text).split("\n");
+    return {
+        oldStart: 1,
+        oldLines: 0,
+        newStart: 1,
+        newLines: lines.length,
+        lines: [...lines.map((line) => `+${line}`), ...(terminated ? [] : [NO_NEWLINE_MARKER])],
+    };
+}
+/**
+ * The line-diff hunks between two texts. Returns undefined when the diff runs
+ * out of its time budget.
+ */
+function diffHunks(oldText, newText) {
+    if (oldText === null) {
+        const hunk = wholeFileHunk(newText);
+        return hunk ? [hunk] : [];
+    }
+    const oldLines = textLines(oldText);
+    const newLines = textLines(newText);
+    // The diff gets only the changed middle and its context lines. An edit
+    // usually changes a small part of a large file.
+    const common = Math.min(oldLines.length, newLines.length);
+    let prefix = 0;
+    while (prefix < common && oldLines[prefix] === newLines[prefix])
+        prefix++;
+    let suffix = 0;
+    while (suffix < common - prefix &&
+        oldLines[oldLines.length - 1 - suffix] === newLines[newLines.length - 1 - suffix]) {
+        suffix++;
+    }
+    const skipped = Math.max(0, prefix - PATCH_CONTEXT_LINES);
+    const skippedEnd = Math.max(0, suffix - PATCH_CONTEXT_LINES);
+    const patch = structuredPatch("", "", oldLines.slice(skipped, oldLines.length - skippedEnd).join(""), newLines.slice(skipped, newLines.length - skippedEnd).join(""), "", "", { context: PATCH_CONTEXT_LINES, timeout: PATCH_DIFF_TIMEOUT_MS });
+    return patch?.hunks.map((hunk) => ({
+        ...hunk,
+        oldStart: hunk.oldStart + skipped,
+        newStart: hunk.newStart + skipped,
+    }));
+}
+/** The lines of a text, each with its line break. The last line can have none. */
+function textLines(text) {
+    return text.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+}
+/**
+ * The git patch of a file change and its hunks. Returns undefined when
+ * nothing changed or the diff runs out of its time budget.
+ */
+function filePatch(filePath, oldText, newText) {
+    const hunks = diffHunks(oldText, newText);
+    if (!hunks || hunks.length === 0)
+        return undefined;
+    const change = oldText === null ? "create" : "update";
+    return { content: patchContent(filePath, gitPatchText(filePath, change, hunks)), hunks };
+}
+/**
+ * Reads a file as patch input.
+ *
+ * Returns null when the file does not exist. Returns undefined when the file
+ * cannot be read, is not a regular file, is larger than
+ * {@link MAX_PATCH_FILE_BYTES}, is binary, is not valid UTF-8, or contains a
+ * CR.
+ */
+async function readPatchSource(filePath) {
+    let handle;
+    try {
+        // O_NONBLOCK keeps the open of a FIFO from waiting for a writer. It does not change a regular file.
+        handle = await open(filePath, constants.O_RDONLY | constants.O_NONBLOCK);
+    }
+    catch (error) {
+        return isMissingFileError(error) ? null : undefined;
+    }
+    try {
+        // The checks and the read use one open file, so a swap of the path between them has no effect.
+        const stats = await handle.stat();
+        if (!stats.isFile() || stats.size > MAX_PATCH_FILE_BYTES)
+            return undefined;
+        // One byte more than the checked size shows a file that grew after the check.
+        const buffer = Buffer.alloc(stats.size + 1);
+        let length = 0;
+        while (length < buffer.length) {
+            const { bytesRead } = await handle.read(buffer, length, buffer.length - length, length);
+            if (bytesRead === 0)
+                break;
+            length += bytesRead;
+        }
+        if (length > stats.size)
+            return undefined;
+        const text = decodeFileText(buffer.subarray(0, length));
+        return text?.includes("\r") ? undefined : text;
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        await handle.close();
+    }
+}
+/** The text of a file of at most {@link MAX_PATCH_FILE_BYTES} that is not binary and is valid UTF-8. */
+function decodeFileText(bytes) {
+    if (bytes.length > MAX_PATCH_FILE_BYTES)
+        return undefined;
+    if (bytes.subarray(0, BINARY_SNIFF_BYTES).includes(0))
+        return undefined;
+    try {
+        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Whether a tool input text can be the new side of an exact patch. */
+function isPatchableText(text) {
+    return (Buffer.byteLength(text, "utf8") <= MAX_PATCH_FILE_BYTES &&
+        !text.includes("\0") &&
+        !text.includes("\r"));
+}
+function optionalContent(content) {
+    return content ? [content] : undefined;
+}
+/**
+ * A diff block in the AIR patch form.
+ *
+ * `oldText: null` and `newText: ""` only satisfy the ACP schema. The adapter
+ * sends this form only to a client that advertised `diffPatch`.
+ */
+function patchContent(filePath, text) {
+    return {
+        type: "diff",
+        path: filePath,
+        oldText: null,
+        newText: "",
+        _meta: withAirMeta(undefined, AIR_DIFF_PATCH_CAPABILITY, {
+            version: 1,
+            format: "git_patch",
+            text,
+        }),
+    };
+}
+function resolveToolPath(filePath, cwd) {
+    return path.isAbsolute(filePath) ? filePath : path.resolve(cwd ?? process.cwd(), filePath);
+}
+function isMissingFileError(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}

package/dist/elicitation.d.ts

@@ -63,7 +63,7 @@ export declare function extractAskUserQuestions(input: Record<string, unknown>):
  * marked required, so the user can also just skip — matching the built-in tool,
  * which always offers Skip + a free-text box.
  */
-export declare function askUserQuestionsToCreateRequest(questions: AskUserQuestion[], sessionId: string, toolCallId: string | undefined): CreateElicitationRequest;
+export declare function askUserQuestionsToCreateRequest(questions: AskUserQuestion[], sessionId: string, toolCallId: string | undefined, airClient?: boolean): CreateElicitationRequest;
 /** Outcome of an AskUserQuestion elicitation, decoupled from any transport. */
 export type AskUserQuestionOutcome = {
     action: "answered";

package/dist/elicitation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"elicitation.d.ts","sourceRoot":"","sources":["../src/elicitation.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,KAAK,EACV,wBAAwB,EAKzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAC5F,OAAO,KAAK,EACV,oBAAoB,EAErB,MAAM,6CAA6C,CAAC;AAErD;;;;;;;;;;;;;GAaG;AAEH,yDAAyD;AACzD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,OAAO,CAAC;IACd,GAAG,EAAE,OAAO,CAAC;CACd,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,MAAM,GAChB,wBAAwB,GAAG,IAAI,CAyBjC;AAgBD;;;GAGG;AACH,wBAAgB,uCAAuC,CACrD,QAAQ,EAAE,yBAAyB,GAClC,iBAAiB,CAUnB;AAED;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,oBAAoB,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAExE;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,eAAe,EAAE,GAAG,IAAI,CAUhG;AAgCD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,+BAA+B,CAC7C,SAAS,EAAE,eAAe,EAAE,EAC5B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GAAG,SAAS,GAC7B,wBAAwB,CA6D1B;AAED,+EAA+E;AAC/E,MAAM,MAAM,sBAAsB,GAChC;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,QAAQ,CAAA;CAAE,CAAC;AAevF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,yBAAyB,EACnC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,SAAS,EAAE,eAAe,EAAE,GAC3B,sBAAsB,CAgExB;AAgBD;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,4BAA4B,CAAC;AAEtE;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,qBAAqB,GAAG,IAAI,CAW9B;AAYD;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,qBAAqB,EAC7B,SAAS,EAAE,MAAM,GAChB,wBAAwB,CA+B1B;AAED;;;;;;GAMG;AACH,wBAAgB,iCAAiC,CAAC,QAAQ,EAAE,yBAAyB,GAAG,MAAM,CAG7F"}
+{"version":3,"file":"elicitation.d.ts","sourceRoot":"","sources":["../src/elicitation.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,KAAK,EACV,wBAAwB,EAKzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAC5F,OAAO,KAAK,EACV,oBAAoB,EAErB,MAAM,6CAA6C,CAAC;AAGrD;;;;;;;;;;;;;GAaG;AAEH,yDAAyD;AACzD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,OAAO,CAAC;IACd,GAAG,EAAE,OAAO,CAAC;CACd,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,MAAM,GAChB,wBAAwB,GAAG,IAAI,CAyBjC;AAgBD;;;GAGG;AACH,wBAAgB,uCAAuC,CACrD,QAAQ,EAAE,yBAAyB,GAClC,iBAAiB,CAUnB;AAED;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,oBAAoB,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAExE;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,eAAe,EAAE,GAAG,IAAI,CAUhG;AAwBD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,+BAA+B,CAC7C,SAAS,EAAE,eAAe,EAAE,EAC5B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,SAAS,UAAQ,GAChB,wBAAwB,CAiE1B;AAED,+EAA+E;AAC/E,MAAM,MAAM,sBAAsB,GAChC;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,QAAQ,CAAA;CAAE,CAAC;AAevF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,yBAAyB,EACnC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,SAAS,EAAE,eAAe,EAAE,GAC3B,sBAAsB,CAgExB;AAgBD;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,4BAA4B,CAAC;AAEtE;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,qBAAqB,GAAG,IAAI,CAW9B;AAYD;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,qBAAqB,EAC7B,SAAS,EAAE,MAAM,GAChB,wBAAwB,CA+B1B;AAED;;;;;;GAMG;AACH,wBAAgB,iCAAiC,CAAC,QAAQ,EAAE,yBAAyB,GAAG,MAAM,CAG7F"}

package/dist/elicitation.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { CreateElicitationResponse } from "@agentclientprotocol/sdk";
+import { AIR_CUSTOM_ANSWER_KEY, withAirMeta } from "./air-extension.js";
 /**
  * Convert an MCP elicitation request (from the SDK's `onElicitation` callback)
  * into an ACP `CreateElicitationRequest`. Returns `null` when the request can't
@@ -89,13 +90,6 @@ function questionCustomFieldKey(index) {
  * extensions (`_claude/...`).
  */
 const OPTION_META_KEY = "_claude/askUserQuestionOption";
-/**
- * Shared `_meta` key for marking a per-question free-text field as the custom
- * answer companion for a select question. This intentionally has no
- * agent-specific namespace so ACP clients can recognize the same marker across
- * Codex, Claude, and other AskUserQuestion bridges.
- */
-const CUSTOM_ANSWER_META_KEY = "_askUserQuestionCustomAnswer";
 /**
  * Render the AskUserQuestion tool's questions as an ACP form elicitation.
  *
@@ -114,7 +108,7 @@ const CUSTOM_ANSWER_META_KEY = "_askUserQuestionCustomAnswer";
  * marked required, so the user can also just skip — matching the built-in tool,
  * which always offers Skip + a free-text box.
  */
-export function askUserQuestionsToCreateRequest(questions, sessionId, toolCallId) {
+export function askUserQuestionsToCreateRequest(questions, sessionId, toolCallId, airClient = false) {
     const single = questions.length === 1;
     const properties = {};
     questions.forEach((question, index) => {
@@ -148,12 +142,16 @@ export function askUserQuestionsToCreateRequest(questions, sessionId, toolCallId
             description: question.multiSelect
                 ? "Type your own answer to add to your selection above (optional)."
                 : "Type your own answer, or add a note to the option you chose above (optional).",
-            _meta: {
-                [CUSTOM_ANSWER_META_KEY]: {
-                    questionId: questionFieldKey(index),
-                    isCustomAnswer: true,
-                },
-            },
+            // Marks the field as the custom answer companion of a select question,
+            // under `_meta.jetbrains.air.customAnswer`. Only AIR gets the marker.
+            ...(airClient
+                ? {
+                    _meta: withAirMeta(undefined, AIR_CUSTOM_ANSWER_KEY, {
+                        questionId: questionFieldKey(index),
+                        isCustomAnswer: true,
+                    }),
+                }
+                : {}),
         };
     });
     const requestedSchema = {