vanspod 0.0.0-stage → 0.1.2

package/dist/codexWire/freeform-wrapper-scan.js

@@ -0,0 +1,326 @@
+"use strict";
+// Bounded classification of a PARTIAL freeform tool-call wrapper.
+//
+// `unwrapFreeformToolInput` decides the completed input with `JSON.parse`, which does not care
+// what order an object's properties arrive in or how their names are spelled. The streaming side
+// has to reach the same answer from a prefix, and it used to do that by comparing the buffer
+// against the literal `{"input":"`. Spellings `JSON.parse` calls identical therefore matched no
+// wrapper at all, streamed as raw JSON, and then completed as the unwrapped body:
+// `{"metadata":1,"input":"cmd"}` and `{"\u0069nput":"cmd"}` both previewed the whole object and
+// completed as `cmd` (#5151). #5047 and #5129 closed the compact and whitespace spellings of the
+// same disagreement; reordering and escaping are the two the literal matcher could never see,
+// because RFC 8259 objects are unordered and their names are strings with escapes.
+//
+// So the prefix is scanned as JSON instead of matched as text. The scan answers one question —
+// which wrapper, if any, the completed text will unwrap to — and it answers it three ways:
+//
+//   `input`  the canonical key is present with a string value, whatever preceded it and however
+//            its name was spelled. Its value can be decoded progressively, because
+//            `unwrapFreeformToolInput` gives an own `input` precedence over every other property.
+//   `raw`    no wrapper can apply, because the text is not an object or because it is one that
+//            `JSON.parse` will reject. Completion returns the buffer, so streaming it agrees.
+//   `hold`   undecided. A key that has not arrived yet can still change the answer, so nothing
+//            is published until the object closes — where the scan itself already holds the
+//            member table completion's own rule consults, so no parse of the buffer is needed.
+//
+// The bound matters as much as the classification. A scan that walks the whole buffer on every
+// delta is quadratic in the argument size, so classification gives up after
+// `MAX_FREEFORM_WRAPPER_SCAN_CHARS` and holds. Giving up costs preview, never agreement: a held
+// buffer is still resolved by the authoritative parse at completion.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_FREEFORM_WRAPPER_SCAN_CHARS = exports.JSON_ESCAPES = exports.JSON_WHITESPACE = void 0;
+exports.scanFreeformWrapper = scanFreeformWrapper;
+/** The insignificant whitespace `JSON.parse` accepts between tokens. */
+exports.JSON_WHITESPACE = new Set([" ", "\t", "\n", "\r"]);
+/** The two-character escapes JSON defines, and nothing else. */
+exports.JSON_ESCAPES = new Map([
+    ['"', '"'], ["\\", "\\"], ["/", "/"],
+    ["b", "\b"], ["f", "\f"], ["n", "\n"], ["r", "\r"], ["t", "\t"],
+]);
+/**
+ * How far a classification scan walks before it gives up and holds.
+ *
+ * A wrapper's own structure — its property names and the small scalar siblings a model puts
+ * beside the body — lives at the front of the object. A buffer still undecided after this much
+ * scanning is one whose preceding values are large, and holding it is what the routed
+ * restoration path already does for every unrecognized object.
+ */
+exports.MAX_FREEFORM_WRAPPER_SCAN_CHARS = 4096;
+const CANONICAL_KEY = "input";
+/** The buffer ends inside a token: what follows can still change the answer. */
+const HOLD = -1;
+/** `JSON.parse` will reject this text no matter what is appended to it. */
+const NEVER = -2;
+/** Index of the first non-whitespace character at or after `from`, or HOLD past the end. */
+function skipWhitespace(text, from) {
+    let i = from;
+    while (i < text.length && exports.JSON_WHITESPACE.has(text[i]))
+        i++;
+    return i < text.length ? i : HOLD;
+}
+/**
+ * Index just past the complete JSON string opening at `from`, or HOLD / NEVER.
+ *
+ * This reports a BOUNDARY where `decodeJsonStringPrefix` reports a decoded PREFIX: one has to
+ * fail on a truncated string and the other has to return what it decoded so far. They answer
+ * different questions about the same bytes and share one escape table so they cannot disagree
+ * about which escapes exist.
+ */
+function scanString(text, from) {
+    let i = from + 1;
+    while (i < text.length) {
+        const c = text[i];
+        if (c === '"')
+            return i + 1;
+        if (c === "\\") {
+            const n = text[i + 1];
+            if (n === undefined)
+                return HOLD;
+            if (n === "u") {
+                const hex = text.slice(i + 2, i + 6);
+                if (hex.length < 4)
+                    return HOLD;
+                if (!/^[0-9a-fA-F]{4}$/.test(hex))
+                    return NEVER;
+                i += 6;
+                continue;
+            }
+            if (!exports.JSON_ESCAPES.has(n))
+                return NEVER;
+            i += 2;
+            continue;
+        }
+        // A literal control character is not legal inside a JSON string.
+        if (c.charCodeAt(0) <= 0x1f)
+            return NEVER;
+        i++;
+    }
+    return HOLD;
+}
+const JSON_NUMBER_CHARS = /[-+0-9.eE]/;
+const JSON_NUMBER = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$/;
+/** Index just past one complete scalar at `from`, or HOLD / NEVER. */
+function scanScalar(text, from) {
+    const c = text[from];
+    if (c === '"')
+        return scanString(text, from);
+    if (c === "t" || c === "f" || c === "n") {
+        const literal = c === "t" ? "true" : c === "f" ? "false" : "null";
+        if (text.startsWith(literal, from))
+            return from + literal.length;
+        return literal.startsWith(text.slice(from)) ? HOLD : NEVER;
+    }
+    let end = from;
+    while (end < text.length && JSON_NUMBER_CHARS.test(text[end]))
+        end++;
+    if (end === from)
+        return NEVER;
+    // A number running to the end of the buffer can still grow another digit or exponent.
+    if (end >= text.length)
+        return HOLD;
+    return JSON_NUMBER.test(text.slice(from, end)) ? end : NEVER;
+}
+/** Index where the value of the member whose name opens at `from` begins, or HOLD / NEVER. */
+function scanMemberKey(text, from) {
+    if (text[from] !== '"')
+        return NEVER;
+    const nameEnd = scanString(text, from);
+    if (nameEnd < 0)
+        return nameEnd;
+    const colon = skipWhitespace(text, nameEnd);
+    if (colon === HOLD)
+        return HOLD;
+    if (text[colon] !== ":")
+        return NEVER;
+    return skipWhitespace(text, colon + 1);
+}
+/**
+ * Index just past one complete JSON value at `from`, or HOLD / NEVER.
+ *
+ * Containers are walked with an explicit stack rather than recursion: the value being skipped
+ * is provider-controlled, and a deeply nested one must not be able to exhaust the call stack.
+ */
+function scanValue(text, from) {
+    const closers = [];
+    let i = from;
+    for (;;) {
+        const c = text[i];
+        if (c === "{" || c === "[") {
+            const closer = c === "{" ? "}" : "]";
+            closers.push(closer);
+            const first = skipWhitespace(text, i + 1);
+            if (first === HOLD)
+                return HOLD;
+            if (text[first] === closer) {
+                closers.pop();
+                i = first + 1;
+            }
+            else if (closer === "}") {
+                const value = scanMemberKey(text, first);
+                if (value < 0)
+                    return value;
+                i = value;
+                continue;
+            }
+            else {
+                i = first;
+                continue;
+            }
+        }
+        else {
+            const end = scanScalar(text, i);
+            if (end < 0)
+                return end;
+            i = end;
+        }
+        // One value is complete: close whatever it finished and find the next value, if any.
+        for (;;) {
+            if (closers.length === 0)
+                return i;
+            const at = skipWhitespace(text, i);
+            if (at === HOLD)
+                return HOLD;
+            const closer = closers[closers.length - 1];
+            if (text[at] === closer) {
+                closers.pop();
+                i = at + 1;
+                continue;
+            }
+            if (text[at] !== ",")
+                return NEVER;
+            const next = skipWhitespace(text, at + 1);
+            if (next === HOLD)
+                return HOLD;
+            if (closer === "}") {
+                const value = scanMemberKey(text, next);
+                if (value < 0)
+                    return value;
+                i = value;
+            }
+            else {
+                i = next;
+            }
+            break;
+        }
+    }
+}
+/**
+ * Which wrapper the completed text will unwrap to, as far as this prefix can say.
+ *
+ * `fallbackKeys` is the tool's alternate-field vocabulary — `freeformFallbackKeys`, the same
+ * list `unwrapFreeformToolInput` filters against. No open prefix can decide a fallback key,
+ * because it unwraps only as the SINGLE string field and a second one can still arrive; so the
+ * scan keeps a table of the members it has already walked and consults it once, at the close.
+ */
+function scanFreeformWrapper(text, fallbackKeys) {
+    // One clamp rather than a budget threaded through every helper. Every helper already holds
+    // when it runs off the end of what it can see, so a buffer whose classification needs more
+    // than this holds for exactly the right reason, and no scan can cost more than this many
+    // characters however large the arguments grow. Indices into the clamp are indices into the
+    // full text, because the clamp is a prefix of it.
+    const wholeText = text.length <= exports.MAX_FREEFORM_WRAPPER_SCAN_CHARS;
+    const bounded = wholeText ? text : text.slice(0, exports.MAX_FREEFORM_WRAPPER_SCAN_CHARS);
+    const hold = () => ({ kind: "hold" });
+    const open = skipWhitespace(bounded, 0);
+    if (open === HOLD)
+        return hold();
+    // Not an object, so no wrapper rule reaches it: arrays, scalars and ordinary bodies all
+    // complete as themselves.
+    if (bounded[open] !== "{")
+        return { kind: "raw" };
+    // Every top-level member is recorded as the scan passes it, last occurrence winning — the
+    // keep-last rule `JSON.parse` applies to duplicate keys. When the object closes, this table
+    // answers the only question completion asks of it — which members carried strings — so the
+    // closed object classifies directly instead of reparsing a buffer the scan just walked.
+    const members = new Map();
+    let i = open + 1;
+    for (;;) {
+        const at = skipWhitespace(bounded, i);
+        if (at === HOLD)
+            return hold();
+        if (bounded[at] === "}")
+            return afterTopLevelClose(bounded, at + 1, members, fallbackKeys, wholeText);
+        if (bounded[at] !== '"')
+            return { kind: "raw" };
+        const nameEnd = scanString(bounded, at);
+        if (nameEnd === HOLD)
+            return hold();
+        if (nameEnd === NEVER)
+            return { kind: "raw" };
+        let name;
+        try {
+            // The authoritative decoder for the name, so `{"\u0069nput":...}` resolves to the same
+            // key completion sees. Decoding it by hand here is the second implementation that would
+            // drift from `JSON.parse`, which is how this defect existed in the first place.
+            name = JSON.parse(bounded.slice(at, nameEnd));
+        }
+        catch {
+            return { kind: "raw" };
+        }
+        const colon = skipWhitespace(bounded, nameEnd);
+        if (colon === HOLD)
+            return hold();
+        if (bounded[colon] !== ":")
+            return { kind: "raw" };
+        const valueAt = skipWhitespace(bounded, colon + 1);
+        if (valueAt === HOLD)
+            return hold();
+        if (name === CANONICAL_KEY) {
+            // An own `input` wins over everything else in the object, so this is decidable now. A
+            // non-string value is decidable too, in the other direction: completion hands back the
+            // argument text unchanged rather than unwrapping a value it cannot use.
+            return bounded[valueAt] === '"'
+                ? { kind: "input", valueStart: valueAt + 1 }
+                : { kind: "raw" };
+        }
+        members.set(name, { stringValue: bounded[valueAt] === '"', valueStart: valueAt + 1 });
+        const valueEnd = scanValue(bounded, valueAt);
+        if (valueEnd === HOLD)
+            return hold();
+        if (valueEnd === NEVER)
+            return { kind: "raw" };
+        const next = skipWhitespace(bounded, valueEnd);
+        if (next === HOLD)
+            return hold();
+        if (bounded[next] === ",") {
+            // A comma promises another member, so the next non-whitespace character must open a
+            // member name. `{"code":"cmd",}` is not a completed object — `JSON.parse` rejects the
+            // trailing comma — and treating its `}` as the close would unwrap a preview completion
+            // hands back unchanged. Nested members already reject this through `scanMemberKey`;
+            // the top level has to ask the same question itself.
+            const member = skipWhitespace(bounded, next + 1);
+            if (member === HOLD)
+                return hold();
+            if (bounded[member] !== '"')
+                return { kind: "raw" };
+            i = member;
+            continue;
+        }
+        if (bounded[next] === "}")
+            return afterTopLevelClose(bounded, next + 1, members, fallbackKeys, wholeText);
+        return { kind: "raw" };
+    }
+}
+/**
+ * The object closed without a canonical key. Only whitespace may follow one that parses, so
+ * anything else makes the text raw. Whitespace to the end IS legal, but the member table
+ * already says which way completion goes on it: exactly one string-valued fallback field is
+ * the wrapper's value, and any other member shape streams the raw text — byte-exact through
+ * whatever trailing whitespace arrived, where a reparsed growing buffer was quadratic work on
+ * every whitespace delta and a held one swallowed the whitespace bytes entirely.
+ */
+function afterTopLevelClose(text, from, members, fallbackKeys, wholeText) {
+    const trailing = skipWhitespace(text, from);
+    if (trailing !== HOLD)
+        return { kind: "raw" };
+    // A clamped prefix ends inside this whitespace, so what follows is unseen: hold rather than
+    // guess at a tail that could still invalidate the close. When the whole text fit, the object
+    // plus its trailing whitespace is complete — and its members decide it without a parse.
+    if (!wholeText)
+        return { kind: "hold" };
+    const candidates = fallbackKeys.filter(key => members.get(key)?.stringValue === true);
+    if (candidates.length === 1) {
+        return { kind: "input", valueStart: members.get(candidates[0]).valueStart };
+    }
+    return { kind: "raw" };
+}

package/dist/codexWire/progressive-freeform-input.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.progressiveFreeformInput = progressiveFreeformInput;
+const apply_patch_envelope_1 = require("./apply-patch-envelope");
+const freeform_wrapper_scan_1 = require("./freeform-wrapper-scan");
+/**
+ * Whether a body could still grow into one complete outer Markdown fence.
+ *
+ * `stripMarkdownCodeFence` removes such a fence at completion for exactly the two tools that
+ * own the grammar, so a fenced body's streamed bytes and its completed input disagree unless
+ * the stream holds. A buffer that does not open with a fence can never acquire one, so
+ * ordinary bodies are unaffected; a buffer that does keeps its preview suppressed for the
+ * whole call, because a closing fence can still be followed by more text that withdraws it.
+ */
+function mayBecomeFencedBody(text, toolName) {
+    if (toolName !== "exec" && toolName !== "apply_patch")
+        return false;
+    const head = text.trimStart();
+    if (head === "")
+        return true;
+    return head.startsWith("```") || "```".startsWith(head);
+}
+const LOW_SURROGATE_ESCAPE = /^\\u[dD][c-fC-F][0-9a-fA-F]{2}$/;
+/**
+ * The decoded prefix of a JSON string body, stopping at the first byte it cannot resolve.
+ *
+ * Every stop is a hold rather than a guess, because `JSON.parse` decides the completed value
+ * and anything invented here would be retracted. Three of them are not obvious:
+ *
+ * An escape JSON does not define makes the whole wrapper unparseable no matter what arrives
+ * next, so completion falls back to the raw text. Returning `null` for that case stops the
+ * preview rather than continuing to decode a value the completed item will never carry.
+ * `\\b` and `\\f` are defined, and were previously decoded to the letters b and f.
+ *
+ * A lone high surrogate is not a character. Emitting one alone puts an unpaired code unit in a
+ * delta the client has to decode by itself, so the pair is emitted together or not at all.
+ */
+function decodeJsonStringPrefix(body) {
+    let out = "";
+    for (let i = 0; i < body.length; i++) {
+        const c = body[i];
+        if (c === '"')
+            break; // unescaped closing quote: value complete
+        if (c !== "\\") {
+            // A literal control character is not legal inside a JSON string, so `JSON.parse` will
+            // reject this wrapper and completion will return the raw text. Emitting the decoded value
+            // first is the disagreement this decoder exists to prevent, so stop instead.
+            if (c.charCodeAt(0) <= 0x1f)
+                return null;
+            out += c;
+            continue;
+        }
+        const n = body[i + 1];
+        if (n === undefined)
+            break; // escape split across chunks: wait for more
+        if (n === "u") {
+            const hex = body.slice(i + 2, i + 6);
+            if (hex.length < 4)
+                break; // split across chunks: wait for more
+            if (!/^[0-9a-fA-F]{4}$/.test(hex))
+                return null; // never parses
+            const code = parseInt(hex, 16);
+            if (code >= 0xd800 && code <= 0xdbff) {
+                const low = body.slice(i + 6, i + 12);
+                if (!LOW_SURROGATE_ESCAPE.test(low))
+                    break;
+                out += String.fromCharCode(code, parseInt(low.slice(2), 16));
+                i += 11;
+                continue;
+            }
+            out += String.fromCharCode(code);
+            i += 5;
+            continue;
+        }
+        const escaped = freeform_wrapper_scan_1.JSON_ESCAPES.get(n);
+        if (escaped === undefined)
+            return null; // never parses
+        out += escaped;
+        i += 1;
+    }
+    return out;
+}
+/**
+ * The value to stream so far, or `null` to HOLD because nothing can be decided yet.
+ *
+ * `input` is decidable from its prefix: `unwrapFreeformToolInput` returns it whenever the
+ * key is present, whatever else the object carries, so its value can be unescaped
+ * progressively and never retracted.
+ *
+ * One case escapes that claim and is accepted rather than fixed: a duplicate `input` key.
+ * `JSON.parse` keeps the last one, so `{"input":"a","input":"b"}` streams a and completes with
+ * b. Closing it means holding every canonical wrapper until its object parses, which is the
+ * progressive streaming this path exists to provide. The completed item stays authoritative,
+ * and no model emits a duplicate key in practice.
+ *
+ * A wrapper that turns invalid AFTER streaming has committed has the same shape and the same
+ * answer. `{"input":"a` followed by `\\qb"}` has already published a when the undefined escape
+ * arrives, and completion returns the raw text because nothing parses. The preview stops
+ * there: no rewind, and no decoded text the completed item does not contain. Bounding the
+ * damage is what is available without giving up progressive streaming, and the args are
+ * unusable in that case whichever representation wins.
+ *
+ * A fallback key decides only at the object's close. It unwraps as the SINGLE string field,
+ * and a second key can still arrive while the object is open — so a value emitted early would
+ * have to be taken back. The scan therefore keeps a member table and consults it at the
+ * close, publishing the wrapped value (or the raw text) without ever reparsing the buffer.
+ * The routed passthrough in `responses-custom-tool-repair.ts` already holds any object prefix
+ * for the same reason (#5047).
+ *
+ * An object that has not reached a canonical key YET is in exactly that position, and used to
+ * be treated as raw because it did not match the literal `{"input":"`. It holds now: `input`
+ * can still arrive after other properties, or wearing an escaped spelling, and completion would
+ * then unwrap a body whose wrapper syntax had already been published as deltas (#5151). The
+ * cost of holding is preview on an object body that turns out not to be a wrapper; the cost of
+ * not holding was publishing bytes the completed item removes.
+ */
+function progressiveFreeformInput(args, toolName) {
+    const scan = (0, freeform_wrapper_scan_1.scanFreeformWrapper)(args, (0, apply_patch_envelope_1.freeformFallbackKeys)(toolName));
+    if (scan.kind === "input") {
+        const decoded = decodeJsonStringPrefix(args.slice(scan.valueStart));
+        if (decoded === null)
+            return null;
+        return mayBecomeFencedBody(decoded, toolName) ? null : decoded;
+    }
+    if (scan.kind === "raw")
+        return mayBecomeFencedBody(args, toolName) ? null : args;
+    // Undecided: an incomplete object, or a close whose tail is clamped out of view. Both stay
+    // held — the first is provably incomplete, and re-walking a budget-exhausted buffer on every
+    // delta is work for a preview that arrives in the same instant as the authoritative
+    // completion behind it. A closed object the scan could see whole never reaches here: its
+    // member table already resolved it to `input` or `raw`.
+    return null;
+}

package/dist/codexWire/request.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeCodexRequest = normalizeCodexRequest;
+exports.codexResponsesUpstreamBody = codexResponsesUpstreamBody;
+const tool_guidance_1 = require("./tool-guidance");
+const types_1 = require("../adapters/types");
+/** Move Codex's inline tool catalog into the standard Responses tools field. */
+function normalizeCodexRequest(body) {
+    if (!Array.isArray(body.input))
+        return body;
+    const tools = body.tools === undefined ? [] : [...(0, types_1.list)(body.tools, "tools")];
+    const input = [];
+    let changed = false;
+    for (const item of body.input) {
+        if (!item || typeof item !== "object" || item.type !== "additional_tools") {
+            input.push(item);
+            continue;
+        }
+        const group = (0, types_1.object)(item, "additional_tools");
+        (0, types_1.allowedFields)(group, ["type", "id", "role", "tools"], "additional_tools");
+        tools.push(...(0, types_1.list)(group.tools, "additional_tools.tools"));
+        changed = true;
+    }
+    return changed ? { ...body, input, tools } : body;
+}
+/** Router's Responses input accepts function history, so lower freeform tools
+ * consistently across declarations, selectors, calls and paired results. */
+function codexResponsesUpstreamBody(body) {
+    // This Codex private account selector is not part of the Router's Responses
+    // contract. Other unknown fields remain intact for upstream extensions.
+    const { access_programs: _accessPrograms, ...publicBody } = body;
+    const guidance = (0, tool_guidance_1.codexToolGuidance)(body);
+    const tool = (value, namespace) => {
+        const record = (0, types_1.object)(value, "tool");
+        if (record.type === "namespace")
+            return { ...record, tools: (0, types_1.list)(record.tools, "namespace tools").map(value => tool(value, String(record.name))) };
+        if (record.type !== "custom")
+            return record;
+        const { format, ...rest } = record;
+        const codeMode = guidance.codeMode && record.name === "exec" && (namespace === undefined || namespace === "functions");
+        const description = `Raw input for ${String(record.name)}.${format === undefined ? "" : ` The input must follow this format definition: ${JSON.stringify(format)}`}`;
+        return { ...rest, type: "function", parameters: { type: "object", properties: { input: {
+                        type: "string", description: codeMode ? (0, tool_guidance_1.codeModeInputDescription)(description) : description,
+                    } }, required: ["input"], additionalProperties: false } };
+    };
+    const choice = (value) => {
+        if (!value || typeof value !== "object")
+            return value;
+        const record = (0, types_1.object)(value, "tool_choice");
+        if (record.type === "custom")
+            return { ...record, type: "function" };
+        if (record.type === "allowed_tools")
+            return { ...record, tools: (0, types_1.list)(record.tools, "allowed tools").map(choice) };
+        return record;
+    };
+    return { ...publicBody,
+        ...(guidance.codeMode ? { instructions: (0, tool_guidance_1.appendToolInstructions)(typeof body.instructions === "string" ? body.instructions : "", [tool_guidance_1.CODE_MODE_RESULT_ECHO_SENTENCE, tool_guidance_1.CODE_MODE_HOST_CONTRACT_SENTENCE]) } : {}),
+        ...(body.tools === undefined ? {} : { tools: (0, types_1.list)(body.tools, "tools").map(value => tool(value)) }),
+        ...(body.tool_choice === undefined ? {} : { tool_choice: choice(body.tool_choice) }),
+        ...(Array.isArray(body.input) ? { input: body.input.map(value => {
+                const item = (0, types_1.object)(value, "input item");
+                if (item.type === "custom_tool_call") {
+                    const { input, id: _id, ...rest } = item;
+                    return { ...rest, type: "function_call", arguments: JSON.stringify({ input: (0, types_1.string)(input, "custom tool input") }) };
+                }
+                if (item.type === "custom_tool_call_output") {
+                    const { id: _id, ...rest } = item;
+                    return { ...rest, type: "function_call_output" };
+                }
+                return item;
+            }) } : {}),
+    };
+}

package/dist/codexWire/responses-tools.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexResponsesTools = void 0;
+const apply_patch_envelope_1 = require("./apply-patch-envelope");
+const types_1 = require("../adapters/types");
+/** Restore only tools explicitly declared as freeform in the client's request. */
+class CodexResponsesTools {
+    tools = [];
+    calls = new Map();
+    constructor(body) {
+        const collect = (tools, namespace) => {
+            for (const raw of tools) {
+                const tool = (0, types_1.object)(raw, "tool");
+                if (tool.type === "namespace")
+                    collect((0, types_1.list)(tool.tools, "namespace tools"), (0, types_1.string)(tool.name, "namespace"));
+                else if (tool.type === "function" || tool.type === "custom") {
+                    const name = (0, types_1.string)(tool.name, "tool name");
+                    if (this.tools.some(tool => tool.name === name && tool.namespace === namespace))
+                        throw new types_1.AdapterError("Responses 工具宣告的 namespace/name 識別重複。");
+                    this.tools.push({ name, namespace, custom: tool.type === "custom" });
+                }
+            }
+        };
+        if (body.tools !== undefined)
+            collect((0, types_1.list)(body.tools, "tools"));
+    }
+    get hasCustomTools() { return this.tools.some(tool => tool.custom); }
+    identity(item) {
+        if ((item.type !== "function_call" && item.type !== "custom_tool_call") || typeof item.name !== "string")
+            return;
+        let matches = this.tools.filter(tool => tool.name === item.name && tool.namespace === item.namespace);
+        if (!matches.length && item.namespace === undefined)
+            matches = this.tools.filter(tool => tool.name === item.name || (tool.namespace && `${tool.namespace}.${tool.name}` === item.name));
+        if (matches.length > 1)
+            throw new types_1.AdapterError("上游工具識別不明確；缺少可唯一判定的 namespace。", 502);
+        return matches.length === 1 && matches[0].custom ? matches[0] : undefined;
+    }
+    convertItem(value) {
+        const item = (0, types_1.object)(value, "Responses output item");
+        const tool = this.identity(item);
+        if (!tool)
+            return item;
+        const { arguments: args, input, ...rest } = item;
+        return { ...rest, type: "custom_tool_call", name: tool.name,
+            ...(tool.namespace ? { namespace: tool.namespace } : {}), input: (0, apply_patch_envelope_1.repairFreeformToolInput)((0, types_1.string)(item.type === "custom_tool_call" ? input : args, "tool input"), tool.name, tool.namespace) };
+    }
+    response(body) {
+        return Array.isArray(body.output) ? { ...body, output: body.output.map(item => this.convertItem(item)) } : body;
+    }
+    events(data) {
+        if (data.type === "response.output_item.added") {
+            const item = (0, types_1.object)(data.item, "output item");
+            if (this.identity(item)) {
+                this.calls.set((0, types_1.string)(item.id, "item id"), { item, args: typeof (item.arguments ?? item.input) === "string" ? String(item.arguments ?? item.input) : "", finished: false });
+                return [{ ...data, item: this.convertItem({ ...item, arguments: "", input: "" }) }];
+            }
+        }
+        const state = typeof data.item_id === "string" ? this.calls.get(data.item_id) : undefined;
+        if (state && (data.type === "response.function_call_arguments.delta" || data.type === "response.custom_tool_call_input.delta")) {
+            state.args += (0, types_1.string)(data.delta, "arguments delta");
+            return []; // Hold the JSON wrapper until the complete freeform input is known.
+        }
+        if (state && (data.type === "response.function_call_arguments.done" || data.type === "response.custom_tool_call_input.done")) {
+            const input = this.convertItem({ ...state.item, arguments: data.arguments ?? state.args, input: data.input ?? state.args }).input;
+            state.finished = true;
+            const { arguments: _args, input: _input, ...rest } = data;
+            return [{ ...rest, type: "response.custom_tool_call_input.delta", delta: input },
+                { ...rest, type: "response.custom_tool_call_input.done", input }];
+        }
+        if (data.type === "response.output_item.done") {
+            const item = (0, types_1.object)(data.item, "output item"), converted = this.convertItem(item);
+            if (converted !== item) {
+                const state = typeof item.id === "string" ? this.calls.get(item.id) : undefined;
+                const prefix = state?.finished ? [] : [
+                    { type: "response.custom_tool_call_input.delta", item_id: item.id, output_index: data.output_index, delta: converted.input },
+                    { type: "response.custom_tool_call_input.done", item_id: item.id, output_index: data.output_index, input: converted.input },
+                ];
+                if (state)
+                    state.finished = true;
+                return [...prefix, { ...data, item: converted }];
+            }
+        }
+        if ((data.type === "response.completed" || data.type === "response.incomplete") && data.response)
+            return [{ ...data, response: this.response((0, types_1.object)(data.response, "response")) }];
+        return [data];
+    }
+}
+exports.CodexResponsesTools = CodexResponsesTools;

package/dist/codexWire/tool-arguments.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolCallArgumentsUsable = toolCallArgumentsUsable;
+exports.toolCallArgumentsCouldBeJson = toolCallArgumentsCouldBeJson;
+/**
+ * Whether assembled function-call arguments are usable JSON.
+ * An empty buffer is valid (no-arg tools send no deltas). Non-empty must parse.
+ */
+function toolCallArgumentsUsable(args) {
+    if (args.length === 0)
+        return true;
+    const trimmed = args.trim();
+    if (!trimmed)
+        return false;
+    try {
+        JSON.parse(args);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Whether an in-progress function-call argument buffer could still become valid JSON.
+ * The first non-whitespace byte must be one that can begin a JSON value.
+ */
+function toolCallArgumentsCouldBeJson(args) {
+    const first = args.trimStart().charAt(0);
+    if (first === "")
+        return true;
+    return first === "{"
+        || first === "["
+        || first === "\""
+        || first === "-"
+        || (first >= "0" && first <= "9")
+        || first === "t"
+        || first === "f"
+        || first === "n";
+}