vanspod 0.0.0-stage → 0.1.2

package/dist/responsesChat.js

@@ -0,0 +1,835 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponsesSse = void 0;
+exports.decodeRequestBody = decodeRequestBody;
+exports.toolKindsFromResponses = toolKindsFromResponses;
+exports.responsesToChatBody = responsesToChatBody;
+const request_1 = require("./codexWire/request");
+const tool_guidance_1 = require("./codexWire/tool-guidance");
+const node_buffer_1 = require("node:buffer");
+const node_zlib_1 = require("node:zlib");
+const apply_patch_envelope_1 = require("./codexWire/apply-patch-envelope");
+const progressive_freeform_input_1 = require("./codexWire/progressive-freeform-input");
+const chat_tools_1 = require("./codexWire/chat-tools");
+const chat_options_1 = require("./codexWire/chat-options");
+const types_1 = require("./adapters/types");
+const tool_arguments_1 = require("./codexWire/tool-arguments");
+const ZSTD_MAGIC = node_buffer_1.Buffer.from([0x28, 0xb5, 0x2f, 0xfd]);
+function decodeRequestBody(bytes, encoding) {
+    const enc = (encoding ?? "").toLowerCase();
+    let decoded = bytes;
+    if (enc.includes("zstd") || bytes.subarray(0, 4).equals(ZSTD_MAGIC)) {
+        decoded = (0, node_zlib_1.zstdDecompressSync)(bytes);
+    }
+    else if (enc.includes("gzip")) {
+        decoded = (0, node_zlib_1.gunzipSync)(bytes);
+    }
+    else if (enc.includes("deflate")) {
+        decoded = (0, node_zlib_1.inflateSync)(bytes);
+    }
+    return decoded.toString("utf8");
+}
+function textFromContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    return content
+        .map((part) => {
+        if (typeof part === "string") {
+            return part;
+        }
+        if (!part || typeof part !== "object") {
+            return "";
+        }
+        const text = part.text;
+        return typeof text === "string" ? text : "";
+    })
+        .join("");
+}
+function toolKindsFromResponses(raw) {
+    const kinds = new Map();
+    let parsed = {};
+    try {
+        const value = JSON.parse(raw);
+        parsed = (0, types_1.object)(value, "Responses 正文");
+    }
+    catch {
+        return kinds;
+    }
+    parsed = (0, chat_tools_1.codexChatTools)(parsed).body;
+    if (!Array.isArray(parsed.tools)) {
+        return kinds;
+    }
+    for (const tool of parsed.tools) {
+        if (!tool || typeof tool !== "object") {
+            continue;
+        }
+        const record = tool;
+        const fn = record.function && typeof record.function === "object"
+            ? record.function
+            : record;
+        const name = typeof fn.name === "string" ? fn.name : "";
+        if (!name) {
+            continue;
+        }
+        kinds.set(name, record.type === "custom" ? "custom" : "function");
+    }
+    return kinds;
+}
+function chatTool(tool) {
+    if (!tool || typeof tool !== "object") {
+        return undefined;
+    }
+    const record = tool;
+    if (record.type !== "function" && record.type !== "custom") {
+        return undefined;
+    }
+    const fn = record.function && typeof record.function === "object"
+        ? record.function
+        : record;
+    const name = typeof fn.name === "string" ? fn.name : "";
+    if (!name) {
+        return undefined;
+    }
+    return {
+        type: "function",
+        function: {
+            name,
+            ...(typeof fn.strict === "boolean" ? { strict: fn.strict } : {}),
+            ...(typeof fn.description === "string"
+                ? { description: fn.description }
+                : {}),
+            parameters: record.type === "custom"
+                ? {
+                    type: "object",
+                    properties: {
+                        input: { type: "string", description: record.format ? `The tool input must follow this format definition: ${JSON.stringify(record.format)}` : "The tool input." },
+                    },
+                    required: ["input"],
+                }
+                : fn.parameters ?? { type: "object", properties: {} },
+        },
+    };
+}
+// Content parts are read by projection, as opencodex does: unknown fields on a
+// known part are dropped. Part types Chat cannot carry still fail, so a file,
+// audio or video attachment never vanishes silently.
+function chatContent(content, toolOutput = false) {
+    if (typeof content === "string")
+        return content;
+    const parts = (0, types_1.list)(content, "Responses content").map(part => {
+        const value = (0, types_1.object)(part, "Responses content part");
+        if (value.type === "input_text" || value.type === "output_text") {
+            if (Array.isArray(value.annotations) && value.annotations.length)
+                throw new types_1.AdapterError("Chat 無法保留文字 annotations。");
+            return { type: "text", text: (0, types_1.string)(value.text, "text") };
+        }
+        if (value.type === "input_image") {
+            return { type: "image_url", image_url: { url: (0, types_1.string)(value.image_url, "image_url"), detail: value.detail === "original" ? "high" : value.detail ?? "auto" } };
+        }
+        // codex-rs FunctionCallOutputContentItem::EncryptedContent is opaque to a
+        // routed model; say so instead of failing the whole turn.
+        if (toolOutput && value.type === "encrypted_content")
+            return { type: "text", text: "[encrypted content omitted]" };
+        throw new types_1.AdapterError(`Chat 無法轉換內容類型 ${String(value.type)}。`);
+    });
+    return parts.every(part => part.type === "text") ? parts.map(part => part.text).join("") : parts;
+}
+function chatToolArguments(raw, custom) {
+    if (!raw) {
+        return "{}";
+    }
+    if (!custom) {
+        try {
+            JSON.parse(raw);
+            return raw;
+        }
+        catch {
+            return JSON.stringify({ input: raw });
+        }
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed &&
+            typeof parsed === "object" &&
+            !Array.isArray(parsed) &&
+            typeof parsed.input === "string") {
+            return raw;
+        }
+    }
+    catch {
+        // 腳本原文，包回模型看過的 input 欄。
+    }
+    return JSON.stringify({ input: raw });
+}
+function pushFunctionCall(messages, record) {
+    const id = typeof record.call_id === "string" ? record.call_id : "";
+    const name = typeof record.name === "string" ? record.name : "";
+    if (!id || !name) {
+        return;
+    }
+    const rawArguments = typeof record.arguments === "string" && record.arguments
+        ? record.arguments
+        : typeof record.input === "string"
+            ? record.input
+            : "";
+    const call = {
+        id,
+        type: "function",
+        function: {
+            name,
+            arguments: chatToolArguments(rawArguments, record.type === "custom_tool_call"),
+        },
+    };
+    const last = messages[messages.length - 1];
+    if (last?.role === "assistant" && last.tool_calls) {
+        last.tool_calls.push(call);
+        return;
+    }
+    messages.push({ role: "assistant", content: null, tool_calls: [call] });
+}
+// Replayed reasoning rides on the assistant message it preceded, in the same
+// reasoning_content field the upstream returned it in. It must never be written
+// into content: a model that sees tagged reasoning in its own earlier answers
+// starts writing its reasoning into the visible answer the same way. Reasoning
+// with no assistant message after it has nothing to ride on and is dropped.
+function foldReasoning(messages) {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const held = messages[index];
+        if (held.role !== "assistant" || held.content !== null || held.tool_calls || held.reasoning_content === undefined)
+            continue;
+        const next = messages[index + 1];
+        if (next?.role === "assistant")
+            next.reasoning_content = held.reasoning_content + (next.reasoning_content ?? "");
+        messages.splice(index, 1);
+    }
+}
+const COMPACTION_ITEM_TYPES = new Set(["compaction", "compaction_summary", "context_compaction"]);
+const OPAQUE_COMPACTION_NOTE = "[earlier conversation was compacted; the summary is stored in a format this model cannot read]";
+const UNPAIRABLE_ITEM_TYPES = new Set(["local_shell_call", "tool_search_call", "tool_search_output"]);
+// Chat tool messages are text-only, so an image returned by a tool (such as
+// Codex view_image) cannot ride in role:"tool" content. As opencodex does, keep
+// the text in the tool message and carry the images in a user message placed
+// after the run of tool results they belong to.
+function liftToolResultImages(messages) {
+    let pending = [];
+    for (let index = 0; index <= messages.length; index++) {
+        const message = messages[index];
+        if (message?.role === "tool") {
+            if (!Array.isArray(message.content))
+                continue;
+            const parts = message.content;
+            const images = parts.filter(part => part.type === "image_url");
+            pending.push(...images);
+            message.content = parts.filter(part => part.type === "text").map(part => part.text).join("") || "[image]".repeat(images.length);
+            continue;
+        }
+        if (!pending.length)
+            continue;
+        messages.splice(index, 0, { role: "user", content: [{ type: "text", text: "[VansPod] image output from the preceding tool result(s):" }, ...pending] });
+        pending = [];
+    }
+}
+function responsesToChatBody(raw, model) {
+    let parsed = {};
+    try {
+        const value = JSON.parse(raw);
+        parsed = (0, types_1.object)(value, "Responses 正文");
+    }
+    catch {
+        throw new types_1.AdapterError("Responses 正文必須是 JSON 物件。");
+    }
+    const source = (0, request_1.normalizeCodexRequest)(parsed);
+    parsed = (0, chat_tools_1.codexChatTools)(source).body;
+    const guidance = (0, tool_guidance_1.codexToolGuidance)(source, Array.isArray(parsed.tools) ? parsed.tools.map(value => String((0, types_1.object)(value, "tool").name)) : []);
+    const options = (0, chat_options_1.codexChatOptions)(parsed, chatResponseFormat);
+    if (parsed.tools !== undefined)
+        for (const tool of (0, types_1.list)(parsed.tools, "tools")) {
+            const record = (0, types_1.object)(tool, "tool");
+            if (record.type !== "function" && record.type !== "custom")
+                throw new types_1.AdapterError(`Chat 無法轉換工具類型 ${String(record.type)}。`);
+            (0, types_1.allowedFields)(record, record.type === "custom" ? ["type", "name", "description", "format"] : ["type", "name", "description", "parameters", "strict", "function"], "Chat tool");
+            if (record.function)
+                (0, types_1.allowedFields)((0, types_1.object)(record.function, "function"), ["name", "description", "parameters", "strict"], "Chat function");
+            const fn = record.function ? (0, types_1.object)(record.function, "function") : record;
+            (0, types_1.string)(fn.name, "tool name");
+            if (record.type === "custom" && record.format !== undefined) {
+                const format = (0, types_1.object)(record.format, "custom format");
+                if (format.type === "grammar") {
+                    (0, types_1.allowedFields)(format, ["type", "syntax", "definition"], "custom grammar");
+                    if (format.syntax !== "lark" && format.syntax !== "regex")
+                        throw new types_1.AdapterError("Chat 無法轉換此自訂 grammar syntax。");
+                    (0, types_1.string)(format.definition, "grammar definition");
+                }
+                else if (format.type === "text")
+                    (0, types_1.allowedFields)(format, ["type"], "custom format");
+                else
+                    throw new types_1.AdapterError("Chat 無法轉換此自訂工具格式。");
+            }
+        }
+    const messages = [];
+    if (typeof parsed.instructions === "string" && parsed.instructions) {
+        messages.push({ role: "system", content: parsed.instructions });
+    }
+    const input = parsed.input;
+    if (typeof input === "string") {
+        messages.push({ role: "user", content: input });
+    }
+    else if (Array.isArray(input)) {
+        // Match opencodex's Responses parser: each input item is read by projection.
+        // Only the fields Chat can express are taken; unknown item-level fields
+        // (ids, status, phase, client metadata, future extensions) neither reach
+        // Chat nor reject the turn. Content parts are projected the same way.
+        for (const item of input) {
+            const record = (0, types_1.object)(item, "Responses input item");
+            if (record.type === "reasoning") {
+                // Readable summary/content text is replayed. Native encrypted_content is
+                // opaque to a Chat upstream: an encrypted-only item is skipped and no
+                // plaintext is invented from it.
+                const summary = (record.summary == null ? [] : (0, types_1.list)(record.summary, "reasoning summary")).map(value => {
+                    const part = (0, types_1.object)(value, "reasoning summary part");
+                    if (part.type !== "summary_text")
+                        throw new types_1.AdapterError("Chat 無法轉換此 reasoning summary 類型。");
+                    return (0, types_1.string)(part.text, "reasoning summary text");
+                }).join("") + (record.content == null ? "" : (0, types_1.list)(record.content, "reasoning content").map(value => {
+                    const part = (0, types_1.object)(value, "reasoning content part");
+                    if (part.type !== "reasoning_text")
+                        throw new types_1.AdapterError("Chat 無法轉換此 reasoning content 類型。");
+                    return (0, types_1.string)(part.text, "reasoning text");
+                }).join(""));
+                // Held as a content-less assistant message until foldReasoning attaches
+                // it to the turn it belongs to.
+                if (summary)
+                    messages.push({ role: "assistant", content: null, reasoning_content: summary });
+                continue;
+            }
+            if (record.type === "input_text" || record.type === "output_text") {
+                const text = (0, types_1.string)(record.text, "text");
+                if (text) {
+                    messages.push({
+                        role: record.type === "output_text" ? "assistant" : "user",
+                        content: text,
+                    });
+                }
+                continue;
+            }
+            if (record.type === "function_call" || record.type === "custom_tool_call") {
+                if (!record.call_id || !record.name)
+                    throw new types_1.AdapterError("工具呼叫缺少 call_id 或 name。");
+                pushFunctionCall(messages, record);
+                continue;
+            }
+            if (record.type === "function_call_output" ||
+                record.type === "custom_tool_call_output") {
+                const id = (0, types_1.string)(record.call_id, "call_id");
+                const output = typeof record.output === "string" ? record.output : chatContent(record.output, true);
+                if (id) {
+                    messages.push({ role: "tool", tool_call_id: id, content: output });
+                }
+                continue;
+            }
+            if (COMPACTION_ITEM_TYPES.has(String(record.type))) {
+                // A stored summary from an earlier compaction. Its encrypted_content can
+                // only be read by the backend that minted it, so the model is told the
+                // earlier conversation was compacted. A context_compaction without a
+                // payload is a pure marker: the summary follows as its own user message.
+                if (record.type === "context_compaction" && typeof record.encrypted_content !== "string")
+                    continue;
+                messages.push({ role: "user", content: OPAQUE_COMPACTION_NOTE });
+                continue;
+            }
+            if (record.type === "agent_message") {
+                // External input delivered to the parent agent; keep it as a user turn.
+                const content = record.content == null ? "" : chatContent(record.content);
+                messages.push({ role: "user", content: content.length ? content : "(sub-agent message received)" });
+                continue;
+            }
+            // A typeless item with a role is a message, as in opencodex. The type, not
+            // an incidental role field, decides everything else.
+            if (record.type === undefined ? typeof record.role !== "string" : record.type !== "message") {
+                // These would leave a tool call or result Chat cannot pair up.
+                if (record.type === undefined || UNPAIRABLE_ITEM_TYPES.has(String(record.type)))
+                    throw new types_1.AdapterError(`Chat 無法轉換輸入類型 ${String(record.type)}。`);
+                // Anything else (web_search_call, future item types) has no Chat form and
+                // is skipped, as opencodex does, so one item cannot block every later turn.
+                continue;
+            }
+            if (!["assistant", "system", "developer", "user"].includes(String(record.role)))
+                throw new types_1.AdapterError("Chat 無法轉換此 message role。");
+            const role = record.role === "assistant"
+                ? "assistant"
+                : record.role === "system" || record.role === "developer"
+                    ? "system"
+                    : "user";
+            const content = chatContent(record.content);
+            if (!content) {
+                continue;
+            }
+            messages.push({ role, content });
+        }
+    }
+    else if (input !== undefined)
+        throw new types_1.AdapterError("Responses input 必須是文字或陣列。");
+    foldReasoning(messages);
+    liftToolResultImages(messages);
+    const tools = Array.isArray(parsed.tools)
+        ? parsed.tools.flatMap((tool) => {
+            const converted = chatTool(tool);
+            return converted ? [converted] : [];
+        })
+        : [];
+    if (guidance.catalog) {
+        const instructions = typeof parsed.instructions === "string" ? parsed.instructions : "";
+        const guided = (0, tool_guidance_1.appendToolInstructions)(instructions, [guidance.catalog]);
+        if (instructions)
+            messages[0] = { role: "system", content: guided };
+        else
+            messages.unshift({ role: "system", content: guided });
+    }
+    for (const tool of tools)
+        if (guidance.execNames.has(tool.function.name)) {
+            const parameters = (0, types_1.object)(tool.function.parameters, "parameters");
+            const input = (0, types_1.object)((0, types_1.object)(parameters.properties, "properties").input, "input");
+            input.description = (0, tool_guidance_1.codeModeInputDescription)(typeof input.description === "string" ? input.description : undefined);
+        }
+    return JSON.stringify({
+        model,
+        messages,
+        stream: parsed.stream ?? true,
+        ...options,
+        ...(parsed.tool_choice !== undefined ? { tool_choice: chatToolChoice(parsed.tool_choice) } : {}),
+        ...(tools.length > 0 ? { tools } : {}),
+    });
+}
+function chatToolChoice(value) {
+    if (typeof value === "string" && ["auto", "none", "required"].includes(value))
+        return value;
+    const choice = (0, types_1.object)(value, "tool_choice");
+    (0, types_1.allowedFields)(choice, ["type", "name"], "Chat tool_choice");
+    if (choice.type === "function" || choice.type === "custom")
+        return { type: "function", function: { name: (0, types_1.string)(choice.name, "tool_choice.name") } };
+    throw new types_1.AdapterError("Chat 無法轉換 tool_choice。");
+}
+function chatResponseFormat(value) {
+    const format = (0, types_1.object)(value, "text.format");
+    if (format.type === "text" || format.type === "json_object") {
+        (0, types_1.allowedFields)(format, ["type"], "text.format");
+        return format;
+    }
+    if (format.type === "json_schema") {
+        (0, types_1.allowedFields)(format, ["type", "name", "description", "schema", "strict"], "text.format");
+        const { type, ...schema } = format;
+        return { type, json_schema: schema };
+    }
+    throw new types_1.AdapterError("Chat 無法轉換 text.format。");
+}
+function randomId() {
+    return Math.random().toString(16).slice(2, 14);
+}
+function sse(name, sequence, data) {
+    return `event: ${name}\ndata: ${JSON.stringify({
+        type: name,
+        sequence_number: sequence,
+        ...data,
+    })}\n\n`;
+}
+class ResponsesSse {
+    model;
+    toolKinds;
+    toolIdentity;
+    hideReasoningSummary;
+    reasoning = "";
+    reasoningIndex = -1;
+    reasoningId = `rs_${randomId()}`;
+    finishReason;
+    usage = null;
+    sequence = 0;
+    opened = false;
+    textClosed = false;
+    text = "";
+    textIndex = 0;
+    nextIndex = 0;
+    responseId = `resp_${randomId()}`;
+    itemId = `msg_${randomId()}`;
+    createdAt = Math.floor(Date.now() / 1000);
+    buffer = "";
+    tools = new Map();
+    constructor(model, toolKinds = new Map(), toolIdentity = name => ({ name }), hideReasoningSummary = false) {
+        this.model = model;
+        this.toolKinds = toolKinds;
+        this.toolIdentity = toolIdentity;
+        this.hideReasoningSummary = hideReasoningSummary;
+    }
+    created() {
+        return this.frame("response.created", {
+            response: this.snapshot("in_progress", []),
+        });
+    }
+    pushChatChunk(chunk) {
+        this.buffer += chunk;
+        const lines = this.buffer.split("\n");
+        this.buffer = lines.pop() ?? "";
+        let out = "";
+        for (const line of lines) {
+            out += this.pushChatLine(line);
+        }
+        return out;
+    }
+    finish() {
+        if (this.buffer.trim()) {
+            const tail = this.pushChatLine(this.buffer);
+            this.buffer = "";
+            return tail + this.completed();
+        }
+        return this.completed();
+    }
+    pushChatLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("data:")) {
+            return "";
+        }
+        const data = trimmed.slice(5).trim();
+        if (!data || data === "[DONE]") {
+            return "";
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(data);
+        }
+        catch {
+            return "";
+        }
+        const choice = parsed.choices?.[0];
+        if (choice?.finish_reason != null)
+            this.finishReason = choice.finish_reason;
+        const usage = parsed.usage;
+        if (usage)
+            this.usage = { input_tokens: usage.prompt_tokens ?? 0, output_tokens: usage.completion_tokens ?? 0, total_tokens: usage.total_tokens ?? 0 };
+        let out = "";
+        const reasoning = choice?.delta?.reasoning ?? choice?.delta?.reasoning_content;
+        if (typeof reasoning === "string" && reasoning) {
+            if (this.reasoningIndex < 0) {
+                this.reasoningIndex = this.nextIndex++;
+                out += this.frame("response.output_item.added", { output_index: this.reasoningIndex, item: { type: "reasoning", id: this.reasoningId, summary: [], status: "in_progress" } });
+                if (!this.hideReasoningSummary)
+                    out += this.frame("response.reasoning_summary_part.added", { item_id: this.reasoningId, output_index: this.reasoningIndex, summary_index: 0, part: { type: "summary_text", text: "" } });
+            }
+            this.reasoning += reasoning;
+            if (!this.hideReasoningSummary)
+                out += this.frame("response.reasoning_summary_text.delta", { item_id: this.reasoningId, output_index: this.reasoningIndex, summary_index: 0, delta: reasoning });
+        }
+        const content = choice?.delta?.content;
+        if (typeof content === "string" && content) {
+            out += this.delta(content);
+        }
+        for (const call of choice?.delta?.tool_calls ?? []) {
+            out += this.toolDelta(call);
+        }
+        return out;
+    }
+    toolDelta(call) {
+        const index = call.index ?? 0;
+        const byId = call.id
+            ? [...this.tools.values()].find((tool) => tool.id === call.id)
+            : undefined;
+        let tool = byId ?? this.tools.get(index);
+        if (!tool) {
+            tool = {
+                id: call.id || `call_${randomId()}`,
+                name: "",
+                args: "",
+                inputEmitted: "",
+                itemId: `fc_${randomId()}`,
+                outputIndex: 0,
+                started: false,
+                custom: false,
+            };
+            this.tools.set(index, tool);
+        }
+        if (call.id) {
+            tool.id = call.id;
+        }
+        if (call.function?.name) {
+            tool.name = tool.name
+                ? call.function.name.startsWith(tool.name)
+                    ? call.function.name
+                    : tool.name + call.function.name
+                : call.function.name;
+        }
+        if (call.function?.arguments) {
+            tool.args += call.function.arguments;
+        }
+        let out = "";
+        if (!tool.started && tool.name) {
+            tool.started = true;
+            tool.custom = this.toolKinds.get(tool.name) === "custom";
+            tool.outputIndex = this.nextIndex;
+            this.nextIndex += 1;
+            out += this.frame("response.output_item.added", {
+                output_index: tool.outputIndex,
+                item: tool.custom
+                    ? {
+                        type: "custom_tool_call",
+                        id: tool.itemId,
+                        call_id: tool.id,
+                        name: tool.name,
+                        input: "",
+                        status: "in_progress",
+                    }
+                    : {
+                        type: "function_call",
+                        id: tool.itemId,
+                        call_id: tool.id,
+                        name: tool.name,
+                        arguments: "",
+                        status: "in_progress",
+                    },
+            });
+        }
+        if (tool.started &&
+            !tool.custom &&
+            call.function?.arguments &&
+            (0, tool_arguments_1.toolCallArgumentsCouldBeJson)(tool.args)) {
+            out += this.frame("response.function_call_arguments.delta", {
+                item_id: tool.itemId,
+                output_index: tool.outputIndex,
+                delta: call.function.arguments,
+            });
+        }
+        if (tool.started && tool.custom) {
+            const identity = this.toolIdentity(tool.name);
+            const ownsGrammar = identity.namespace === undefined || identity.namespace === "functions";
+            const full = (0, progressive_freeform_input_1.progressiveFreeformInput)(tool.args, ownsGrammar ? identity.name : "");
+            if (full !== null) {
+                const holdPatch = ownsGrammar && identity.name === "apply_patch" && (0, apply_patch_envelope_1.mayBecomePatchEnvelope)(full);
+                if (!holdPatch &&
+                    full.startsWith(tool.inputEmitted) &&
+                    full.length > tool.inputEmitted.length) {
+                    const delta = full.slice(tool.inputEmitted.length);
+                    tool.inputEmitted = full;
+                    out += this.frame("response.custom_tool_call_input.delta", {
+                        item_id: tool.itemId,
+                        output_index: tool.outputIndex,
+                        delta,
+                    });
+                }
+            }
+        }
+        return out;
+    }
+    delta(piece) {
+        let out = this.ensureOpen();
+        this.text += piece;
+        out += this.frame("response.output_text.delta", {
+            item_id: this.itemId,
+            output_index: this.textIndex,
+            content_index: 0,
+            delta: piece,
+        });
+        return out;
+    }
+    ensureOpen() {
+        if (this.opened) {
+            return "";
+        }
+        this.opened = true;
+        this.textIndex = this.nextIndex;
+        this.nextIndex += 1;
+        return (this.frame("response.output_item.added", {
+            output_index: this.textIndex,
+            item: {
+                type: "message",
+                id: this.itemId,
+                status: "in_progress",
+                role: "assistant",
+                content: [],
+            },
+        }) +
+            this.frame("response.content_part.added", {
+                item_id: this.itemId,
+                output_index: this.textIndex,
+                content_index: 0,
+                part: { type: "output_text", text: "", annotations: [] },
+            }));
+    }
+    closeText() {
+        if (!this.opened || this.textClosed) {
+            return "";
+        }
+        this.textClosed = true;
+        const item = {
+            type: "message",
+            id: this.itemId,
+            status: "completed",
+            role: "assistant",
+            content: [{ type: "output_text", text: this.text, annotations: [] }],
+        };
+        return (this.frame("response.output_text.done", {
+            item_id: this.itemId,
+            output_index: this.textIndex,
+            content_index: 0,
+            text: this.text,
+        }) +
+            this.frame("response.content_part.done", {
+                item_id: this.itemId,
+                output_index: this.textIndex,
+                content_index: 0,
+                part: { type: "output_text", text: this.text, annotations: [] },
+            }) +
+            this.frame("response.output_item.done", {
+                output_index: this.textIndex,
+                item,
+            }));
+    }
+    closeTools() {
+        let frames = "";
+        const items = [];
+        const seen = new Set();
+        for (const tool of this.tools.values()) {
+            if (!tool.name || seen.has(tool.id)) {
+                continue;
+            }
+            seen.add(tool.id);
+            if (!tool.custom && !(0, tool_arguments_1.toolCallArgumentsUsable)(tool.args)) {
+                frames += this.frame("response.failed", {
+                    response: {
+                        ...this.snapshot("failed", items),
+                        error: {
+                            type: "upstream_error",
+                            message: "upstream stream produced malformed tool call arguments",
+                        },
+                    },
+                });
+                return { frames, items, failed: true };
+            }
+            const args = tool.custom
+                ? (0, apply_patch_envelope_1.repairFreeformToolInput)(tool.args, this.toolIdentity(tool.name).name, this.toolIdentity(tool.name).namespace)
+                : tool.args || "{}";
+            const item = tool.custom
+                ? {
+                    type: "custom_tool_call",
+                    id: tool.itemId,
+                    call_id: tool.id,
+                    name: tool.name,
+                    input: args,
+                    status: "completed",
+                }
+                : {
+                    type: "function_call",
+                    id: tool.itemId,
+                    call_id: tool.id,
+                    name: tool.name,
+                    arguments: args,
+                    status: "completed",
+                };
+            let framesForTool = "";
+            if (!tool.started) {
+                tool.custom = this.toolKinds.get(tool.name) === "custom";
+                tool.outputIndex = this.nextIndex;
+                this.nextIndex += 1;
+                framesForTool += this.frame("response.output_item.added", {
+                    output_index: tool.outputIndex,
+                    item: tool.custom
+                        ? { ...item, status: "in_progress", input: "" }
+                        : { ...item, status: "in_progress", arguments: "" },
+                });
+            }
+            framesForTool += this.frame(tool.custom
+                ? "response.custom_tool_call_input.done"
+                : "response.function_call_arguments.done", tool.custom
+                ? {
+                    item_id: tool.itemId,
+                    output_index: tool.outputIndex,
+                    input: args,
+                }
+                : {
+                    item_id: tool.itemId,
+                    output_index: tool.outputIndex,
+                    arguments: args,
+                });
+            framesForTool += this.frame("response.output_item.done", {
+                output_index: tool.outputIndex,
+                item,
+            });
+            frames += framesForTool;
+            items.push(item);
+        }
+        return { frames, items, failed: false };
+    }
+    completed() {
+        const status = this.finishReason === "length" ? "incomplete" : "completed";
+        const terminalEvent = status === "incomplete" ? "response.incomplete" : "response.completed";
+        const textFrames = this.opened ? this.closeText() : "";
+        const reasoningItem = { type: "reasoning", id: this.reasoningId, status: "completed", summary: this.hideReasoningSummary ? [] : [{ type: "summary_text", text: this.reasoning }],
+            ...(this.hideReasoningSummary ? { content: [{ type: "reasoning_text", text: this.reasoning }] } : {}) };
+        const reasoningFrames = this.reasoningIndex < 0 ? "" :
+            (this.hideReasoningSummary ? "" : this.frame("response.reasoning_summary_text.done", { item_id: this.reasoningId, output_index: this.reasoningIndex, summary_index: 0, text: this.reasoning }) +
+                this.frame("response.reasoning_summary_part.done", { item_id: this.reasoningId, output_index: this.reasoningIndex, summary_index: 0, part: reasoningItem.summary[0] })) +
+                this.frame("response.output_item.done", { output_index: this.reasoningIndex, item: reasoningItem });
+        const tools = this.closeTools();
+        if (tools.failed) {
+            return textFrames + tools.frames;
+        }
+        const output = [
+            ...(this.reasoningIndex >= 0 ? [reasoningItem] : []),
+            ...(this.opened
+                ? [
+                    {
+                        type: "message",
+                        id: this.itemId,
+                        status: "completed",
+                        role: "assistant",
+                        content: [{ type: "output_text", text: this.text, annotations: [] }],
+                    },
+                ]
+                : []),
+            ...tools.items,
+        ];
+        const indexOf = (item) => item.id === this.reasoningId ? this.reasoningIndex : item.id === this.itemId ? this.textIndex : [...this.tools.values()].find(tool => tool.itemId === item.id)?.outputIndex ?? 0;
+        output.sort((left, right) => indexOf(left) - indexOf(right));
+        if (output.length === 0) {
+            return (this.ensureOpen() +
+                this.closeText() +
+                this.frame(terminalEvent, {
+                    response: this.snapshot(status, [
+                        {
+                            type: "message",
+                            id: this.itemId,
+                            status: "completed",
+                            role: "assistant",
+                            content: [{ type: "output_text", text: "", annotations: [] }],
+                        },
+                    ]),
+                }) +
+                "data: [DONE]\n\n");
+        }
+        return (reasoningFrames +
+            textFrames +
+            tools.frames +
+            this.frame(terminalEvent, {
+                response: this.snapshot(status, output),
+            }) +
+            "data: [DONE]\n\n");
+    }
+    snapshot(status, output) {
+        return {
+            id: this.responseId,
+            object: "response",
+            created_at: this.createdAt,
+            status,
+            model: this.model,
+            output,
+            usage: this.usage,
+            ...(status === "incomplete" ? { incomplete_details: { reason: "max_output_tokens" } } : {}),
+        };
+    }
+    frame(name, data) {
+        const sequence = this.sequence;
+        this.sequence += 1;
+        return sse(name, sequence, data);
+    }
+}
+exports.ResponsesSse = ResponsesSse;