@bitkyc08/opencodex 0.1.0

package/src/adapters/image.ts

@@ -0,0 +1,23 @@
+import type { OcxContentPart } from "../types";
+
+/**
+ * Parse a `data:<media-type>;base64,<data>` URL into its parts. Codex sends inline images as base64
+ * data URLs (`into_data_url()`), which Anthropic/Google need split into media_type + raw base64.
+ * Returns null for non-data URLs (e.g. a remote https image), which callers pass through differently.
+ */
+export function parseDataUrl(url: string): { mediaType: string; base64: string } | null {
+  const m = url.match(/^data:([^;,]+);base64,(.*)$/s);
+  if (!m) return null;
+  return { mediaType: m[1], base64: m[2] };
+}
+
+/**
+ * Flatten tool-result content to a string for chat/Gemini tool messages (which are text-only). After
+ * the vision sidecar runs, images are already text; this is the fallback for an undescribed image
+ * (vision model via view_image): a short marker, never the token-exploding image_url.
+ */
+export function contentPartsToText(content: string | OcxContentPart[]): string {
+  if (typeof content === "string") return content;
+  const text = content.map(p => (p.type === "text" ? p.text : "[image]")).join("");
+  return text || "[image]";
+}

package/src/adapters/openai-chat.ts

@@ -0,0 +1,265 @@
+import type { ProviderAdapter } from "./base";
+import type { AdapterEvent, OcxAssistantMessage, OcxContentPart, OcxMessage, OcxParsedRequest, OcxProviderConfig, OcxTextContent, OcxToolCall } from "../types";
+import { namespacedToolName } from "../types";
+import { contentPartsToText } from "./image";
+
+function messagesToChatFormat(parsed: OcxParsedRequest): unknown[] {
+  const out: unknown[] = [];
+  const { context, options } = parsed;
+
+  if (context.systemPrompt && context.systemPrompt.length > 0) {
+    // Codex sends its GPT-5 identity prompt for EVERY model (the per-model catalog
+    // base_instructions is ignored at request time). Neutralize that one identity line
+    // so routed, non-OpenAI models don't misreport themselves as GPT-5 / OpenAI.
+    const sys = context.systemPrompt.join("\n\n").replace(
+      "You are Codex, a coding agent based on GPT-5.",
+      `You are a coding agent (underlying model: ${parsed.modelId}) running via the opencodex proxy. Do not claim to be GPT-5 or to be made by OpenAI.`,
+    );
+    out.push({ role: "system", content: sys });
+  }
+
+  for (const msg of context.messages) {
+    switch (msg.role) {
+      case "user":
+      case "developer": {
+        const role = msg.role === "developer" ? "system" : "user";
+        if (typeof msg.content === "string") {
+          out.push({ role, content: msg.content });
+        } else {
+          const parts = msg.content as OcxContentPart[];
+          if (!parts.some(p => p.type === "image")) {
+            out.push({ role, content: parts.map(p => (p as OcxTextContent).text).join("") });
+          } else {
+            // Vision: chat-completions content-parts array. Images are only valid on the user role,
+            // and the data URL goes straight into image_url.url (never the token-exploding text path).
+            const chatParts = parts.map(p => p.type === "image"
+              ? { type: "image_url", image_url: { url: p.imageUrl, ...(p.detail ? { detail: p.detail } : {}) } }
+              : { type: "text", text: (p as OcxTextContent).text });
+            out.push({ role: "user", content: chatParts });
+          }
+        }
+        break;
+      }
+      case "assistant": {
+        const aMsg = msg as OcxAssistantMessage;
+        const textParts = aMsg.content.filter(p => p.type === "text") as OcxTextContent[];
+        const toolCalls = aMsg.content.filter(p => p.type === "toolCall") as OcxToolCall[];
+        const chatMsg: Record<string, unknown> = { role: "assistant" };
+        if (textParts.length > 0) {
+          chatMsg.content = textParts.map(p => p.text).join("");
+        }
+        if (toolCalls.length > 0) {
+          chatMsg.tool_calls = toolCalls.map(tc => ({
+            id: tc.id,
+            type: "function",
+            function: { name: namespacedToolName(tc.namespace, tc.name), arguments: JSON.stringify(tc.arguments) },
+          }));
+          if (!chatMsg.content) chatMsg.content = null;
+        }
+        // Skip empty assistant messages (e.g. reasoning-only history items): chat APIs
+        // like DeepSeek reject an assistant message with neither content nor tool_calls.
+        if (chatMsg.content === undefined && chatMsg.tool_calls === undefined) break;
+        out.push(chatMsg);
+        break;
+      }
+      case "toolResult": {
+        out.push({
+          role: "tool",
+          tool_call_id: msg.toolCallId,
+          content: contentPartsToText(msg.content),
+        });
+        break;
+      }
+    }
+  }
+
+  return out;
+}
+
+function toolsToChatFormat(parsed: OcxParsedRequest): unknown[] | undefined {
+  if (!parsed.context.tools || parsed.context.tools.length === 0) return undefined;
+  return parsed.context.tools.map(t => ({
+    type: "function",
+    function: {
+      name: namespacedToolName(t.namespace, t.name),
+      description: t.description,
+      parameters: t.parameters,
+      ...(t.strict !== undefined ? { strict: t.strict } : {}),
+    },
+  }));
+}
+
+function toolChoiceToChatFormat(tc: OcxParsedRequest["options"]["toolChoice"]): unknown {
+  if (!tc) return undefined;
+  if (tc === "auto" || tc === "none" || tc === "required") return tc;
+  if ("name" in tc) return { type: "function", function: { name: tc.name } };
+  return undefined;
+}
+
+export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAdapter {
+  return {
+    name: "openai-chat",
+
+    buildRequest(parsed: OcxParsedRequest) {
+      const messages = messagesToChatFormat(parsed);
+      const tools = toolsToChatFormat(parsed);
+      const toolChoice = toolChoiceToChatFormat(parsed.options.toolChoice);
+
+      const body: Record<string, unknown> = {
+        model: parsed.modelId,
+        messages,
+        stream: parsed.stream,
+      };
+      if (tools) body.tools = tools;
+      if (toolChoice !== undefined) body.tool_choice = toolChoice;
+      if (parsed.options.maxOutputTokens !== undefined) body.max_tokens = parsed.options.maxOutputTokens;
+      if (parsed.options.temperature !== undefined) body.temperature = parsed.options.temperature;
+      if (parsed.options.topP !== undefined) body.top_p = parsed.options.topP;
+      if (parsed.options.stopSequences !== undefined) body.stop = parsed.options.stopSequences;
+      // Some models reject a reasoning/thinking param entirely (e.g. xAI grok-build-0.1,
+      // grok-composer-2.5-fast). Drop reasoning_effort for them even if Codex selected an effort.
+      if (parsed.options.reasoning !== undefined && !provider.noReasoningModels?.includes(parsed.modelId)) {
+        // Forward the reasoning ladder (low/medium/high/xhigh) as-is. "minimal" (Codex-native lowest,
+        // widely unsupported downstream) maps to "low"; "max" isn't a real tier (no longer advertised)
+        // so it folds to "xhigh".
+        const r = parsed.options.reasoning;
+        body.reasoning_effort = r === "minimal" ? "low" : r === "max" ? "xhigh" : r;
+      }
+      if (parsed.options.presencePenalty !== undefined) body.presence_penalty = parsed.options.presencePenalty;
+      if (parsed.options.frequencyPenalty !== undefined) body.frequency_penalty = parsed.options.frequencyPenalty;
+
+      if (parsed.stream) {
+        body.stream_options = { include_usage: true };
+      }
+
+      const url = `${provider.baseUrl}/chat/completions`;
+      const headers: Record<string, string> = { "Content-Type": "application/json" };
+      if (provider.apiKey) headers["Authorization"] = `Bearer ${provider.apiKey}`;
+      if (provider.headers) Object.assign(headers, provider.headers);
+
+      return { url, method: "POST", headers, body: JSON.stringify(body) };
+    },
+
+    async *parseStream(response: Response): AsyncGenerator<AdapterEvent> {
+      if (!response.body) {
+        yield { type: "error", message: "No response body" };
+        return;
+      }
+
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let currentToolCallId = "";
+      let currentToolCallName = "";
+      let pendingUsage: { inputTokens: number; outputTokens: number } | undefined;
+
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+
+          for (const line of lines) {
+            if (!line.startsWith("data: ")) continue;
+            const payload = line.slice(6).trim();
+            if (payload === "[DONE]") {
+              if (currentToolCallId) {
+                yield { type: "tool_call_end" };
+                currentToolCallId = "";
+              }
+              yield { type: "done", usage: pendingUsage };
+              return;
+            }
+
+            let chunk: Record<string, unknown>;
+            try {
+              chunk = JSON.parse(payload) as Record<string, unknown>;
+            } catch {
+              continue;
+            }
+
+            if (chunk.usage) {
+              const u = chunk.usage as Record<string, number>;
+              pendingUsage = {
+                inputTokens: u.prompt_tokens ?? 0,
+                outputTokens: u.completion_tokens ?? 0,
+              };
+              continue;
+            }
+
+            const choices = chunk.choices as { delta?: Record<string, unknown>; finish_reason?: string }[] | undefined;
+            if (!choices || choices.length === 0) continue;
+            const delta = choices[0].delta;
+            if (!delta) continue;
+
+            if (typeof delta.content === "string" && delta.content.length > 0) {
+              yield { type: "text_delta", text: delta.content };
+            }
+
+            if (typeof delta.reasoning_content === "string" && delta.reasoning_content.length > 0) {
+              yield { type: "thinking_delta", thinking: delta.reasoning_content };
+            }
+
+            const toolCalls = delta.tool_calls as { index: number; id?: string; function?: { name?: string; arguments?: string } }[] | undefined;
+            if (toolCalls) {
+              for (const tc of toolCalls) {
+                if (tc.id && tc.id !== currentToolCallId) {
+                  if (currentToolCallId) yield { type: "tool_call_end" };
+                  currentToolCallId = tc.id;
+                  currentToolCallName = tc.function?.name ?? "";
+                  yield { type: "tool_call_start", id: tc.id, name: currentToolCallName };
+                }
+                if (tc.function?.arguments) {
+                  yield { type: "tool_call_delta", arguments: tc.function.arguments };
+                }
+              }
+            }
+
+            if (choices[0].finish_reason === "tool_calls" && currentToolCallId) {
+              yield { type: "tool_call_end" };
+              currentToolCallId = "";
+            }
+          }
+        }
+
+        if (currentToolCallId) {
+          yield { type: "tool_call_end" };
+        }
+        yield { type: "done" };
+      } finally {
+        reader.releaseLock();
+      }
+    },
+
+    async parseResponse(response: Response): Promise<AdapterEvent[]> {
+      const json = await response.json() as Record<string, unknown>;
+      const events: AdapterEvent[] = [];
+      const choices = json.choices as { message?: Record<string, unknown> }[] | undefined;
+      if (choices && choices.length > 0) {
+        const msg = choices[0].message;
+        if (msg) {
+          if (typeof msg.content === "string") {
+            events.push({ type: "text_delta", text: msg.content });
+          }
+          const toolCalls = msg.tool_calls as { id: string; function: { name: string; arguments: string } }[] | undefined;
+          if (toolCalls) {
+            for (const tc of toolCalls) {
+              events.push({ type: "tool_call_start", id: tc.id, name: tc.function.name });
+              events.push({ type: "tool_call_delta", arguments: tc.function.arguments });
+              events.push({ type: "tool_call_end" });
+            }
+          }
+        }
+      }
+      const usage = json.usage as Record<string, number> | undefined;
+      events.push({
+        type: "done",
+        usage: usage ? { inputTokens: usage.prompt_tokens ?? 0, outputTokens: usage.completion_tokens ?? 0 } : undefined,
+      });
+      return events;
+    },
+  };
+}

package/src/adapters/openai-responses.ts

@@ -0,0 +1,43 @@
+import type { IncomingMeta, ProviderAdapter } from "./base";
+import type { AdapterEvent, OcxParsedRequest, OcxProviderConfig } from "../types";
+
+// Headers relayed verbatim from the caller in OAuth-passthrough ("forward") mode.
+// Exported so the web-search sidecar reuses the exact same forwarded-auth set for its ChatGPT call.
+export const FORWARD_HEADERS = ["authorization", "chatgpt-account-id", "openai-beta", "originator", "session_id"];
+
+export function createResponsesPassthroughAdapter(provider: OcxProviderConfig): ProviderAdapter & { passthrough: true } {
+  return {
+    name: "openai-responses",
+    passthrough: true as const,
+
+    buildRequest(parsed: OcxParsedRequest, incoming?: IncomingMeta) {
+      const headers: Record<string, string> = { "Content-Type": "application/json" };
+      let url: string;
+
+      if (provider.authMode === "forward") {
+        // OAuth passthrough: ChatGPT backend path is `${baseUrl}/responses` (no /v1).
+        url = `${provider.baseUrl}/responses`;
+        if (provider.headers) Object.assign(headers, provider.headers); // static headers first…
+        for (const h of FORWARD_HEADERS) {
+          const v = incoming?.headers.get(h);
+          if (v) headers[h] = v;                                        // …so forwarded auth always wins.
+        }
+      } else {
+        url = `${provider.baseUrl}/v1/responses`;
+        if (provider.apiKey) headers["Authorization"] = `Bearer ${provider.apiKey}`;
+        if (provider.headers) Object.assign(headers, provider.headers);
+      }
+
+      return {
+        url,
+        method: "POST",
+        headers,
+        body: JSON.stringify(parsed._rawBody),
+      };
+    },
+
+    async *parseStream(): AsyncGenerator<AdapterEvent> {
+      yield { type: "error", message: "passthrough adapter should not parse stream" };
+    },
+  };
+}

package/src/bridge.ts

@@ -0,0 +1,296 @@
+import type { AdapterEvent, OcxUsage } from "./types";
+
+function uuid(): string {
+  return crypto.randomUUID().replace(/-/g, "");
+}
+
+function sseEvent(name: string, data: Record<string, unknown>): string {
+  return `event: ${name}\ndata: ${JSON.stringify(data)}\n\n`;
+}
+
+interface OutputItem {
+  type: string;
+  id: string;
+  [key: string]: unknown;
+}
+
+export function bridgeToResponsesSSE(
+  events: AsyncIterable<AdapterEvent>,
+  modelId: string,
+  toolNsMap?: Map<string, { namespace: string; name: string }>,
+  freeformToolNames?: Set<string>,
+  toolSearchToolNames?: Set<string>,
+): ReadableStream<Uint8Array> {
+  // Freeform/custom tools (apply_patch) carry their body in `input`; the model is given a
+  // function with `{input:string}`, so unwrap it here when relaying back as a custom_tool_call.
+  const freeformInput = (args: string): string => {
+    try { const o = JSON.parse(args); if (o && typeof o.input === "string") return o.input; } catch { /* raw */ }
+    return args;
+  };
+  // tool_search_call carries arguments as a JSON object ({query, limit}); parse the model's arg string.
+  const parseArgsObj = (args: string): Record<string, unknown> => {
+    try { const o = JSON.parse(args); return o && typeof o === "object" ? o : {}; } catch { return {}; }
+  };
+  const encoder = new TextEncoder();
+  const responseId = `resp_${uuid()}`;
+  let seq = 0;
+
+  return new ReadableStream<Uint8Array>({
+    async start(controller) {
+      const emit = (name: string, data: Record<string, unknown>) => {
+        controller.enqueue(encoder.encode(sseEvent(name, { type: name, sequence_number: seq++, ...data })));
+      };
+      const emitDone = () => controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+
+      const createdAt = Math.floor(Date.now() / 1000);
+      let outputIndex = 0;
+      const finishedItems: OutputItem[] = [];
+
+      const responseSnapshot = (status: string, output: OutputItem[]) => ({
+        id: responseId, object: "response", created_at: createdAt,
+        status, model: modelId, output, usage: null,
+      });
+
+      emit("response.created", { response: responseSnapshot("in_progress", []) });
+
+      let currentMsg: { itemId: string; outputIndex: number; text: string } | null = null;
+      let currentReasoning: { itemId: string; outputIndex: number; text: string } | null = null;
+      let currentToolCall: { itemId: string; outputIndex: number; callId: string; name: string; args: string; namespace?: string; freeform?: boolean; toolSearch?: boolean } | null = null;
+
+      const closeCurrentMessage = () => {
+        if (!currentMsg) return;
+        // Finalize the text part (Responses protocol). Without these .done events Codex never
+        // commits the content part and renders the message as truncated / cut off.
+        emit("response.output_text.done", {
+          item_id: currentMsg.itemId, output_index: currentMsg.outputIndex, content_index: 0, text: currentMsg.text,
+        });
+        emit("response.content_part.done", {
+          item_id: currentMsg.itemId, output_index: currentMsg.outputIndex, content_index: 0,
+          part: { type: "output_text", text: currentMsg.text, annotations: [] },
+        });
+        const item = {
+          type: "message", id: currentMsg.itemId, status: "completed", role: "assistant",
+          content: [{ type: "output_text", text: currentMsg.text, annotations: [] }],
+        };
+        emit("response.output_item.done", { output_index: currentMsg.outputIndex, item });
+        finishedItems.push(item as OutputItem);
+        outputIndex++;
+        currentMsg = null;
+      };
+
+      const closeCurrentReasoning = () => {
+        if (!currentReasoning) return;
+        emit("response.reasoning_summary_text.done", {
+          item_id: currentReasoning.itemId, output_index: currentReasoning.outputIndex, summary_index: 0, text: currentReasoning.text,
+        });
+        emit("response.reasoning_summary_part.done", {
+          item_id: currentReasoning.itemId, output_index: currentReasoning.outputIndex, summary_index: 0,
+          part: { type: "summary_text", text: currentReasoning.text },
+        });
+        const item = {
+          type: "reasoning", id: currentReasoning.itemId,
+          summary: [{ type: "summary_text", text: currentReasoning.text }],
+        };
+        emit("response.output_item.done", { output_index: currentReasoning.outputIndex, item });
+        finishedItems.push(item as OutputItem);
+        outputIndex++;
+        currentReasoning = null;
+      };
+
+      const closeCurrentToolCall = () => {
+        if (!currentToolCall) return;
+        // Empty input (no-arg tools like computer_use get_app_state / list_apps) must serialize as
+        // "{}", never "" — Codex echoes the call back as a function_call next turn, and JSON.parse("")
+        // would 400 the whole session ("invalid JSON arguments"), poisoning all later turns.
+        const argsStr = currentToolCall.args || "{}";
+        // Finalize streamed function-call arguments so Codex commits the call (incl. MCP / computer_use).
+        if (!currentToolCall.freeform && !currentToolCall.toolSearch) {
+          emit("response.function_call_arguments.done", {
+            item_id: currentToolCall.itemId, output_index: currentToolCall.outputIndex, arguments: argsStr,
+          });
+        }
+        const item = currentToolCall.toolSearch
+          ? {
+              type: "tool_search_call", id: currentToolCall.itemId,
+              call_id: currentToolCall.callId, execution: "client",
+              arguments: parseArgsObj(currentToolCall.args), status: "completed",
+            }
+          : currentToolCall.freeform
+          ? {
+              type: "custom_tool_call", id: currentToolCall.itemId,
+              call_id: currentToolCall.callId, name: currentToolCall.name,
+              input: freeformInput(currentToolCall.args), status: "completed",
+            }
+          : {
+              type: "function_call", id: currentToolCall.itemId,
+              call_id: currentToolCall.callId, name: currentToolCall.name,
+              arguments: argsStr, status: "completed",
+              ...(currentToolCall.namespace ? { namespace: currentToolCall.namespace } : {}),
+            };
+        emit("response.output_item.done", { output_index: currentToolCall.outputIndex, item });
+        finishedItems.push(item as OutputItem);
+        outputIndex++;
+        currentToolCall = null;
+      };
+
+      try {
+        for await (const event of events) {
+          switch (event.type) {
+            case "text_delta": {
+              if (currentReasoning) closeCurrentReasoning();
+              if (currentToolCall) closeCurrentToolCall();
+              if (!currentMsg) {
+                const itemId = `msg_${uuid()}`;
+                const item = {
+                  type: "message", id: itemId, status: "in_progress", role: "assistant",
+                  content: [] as { type: string; text: string; annotations: never[] }[],
+                };
+                emit("response.output_item.added", { output_index: outputIndex, item });
+                emit("response.content_part.added", {
+                  item_id: itemId, output_index: outputIndex, content_index: 0,
+                  part: { type: "output_text", text: "", annotations: [] },
+                });
+                currentMsg = { itemId, outputIndex, text: "" };
+              }
+              currentMsg.text += event.text;
+              emit("response.output_text.delta", {
+                item_id: currentMsg.itemId, output_index: currentMsg.outputIndex,
+                content_index: 0, delta: event.text,
+              });
+              break;
+            }
+            case "thinking_delta": {
+              if (currentMsg) closeCurrentMessage();
+              if (currentToolCall) closeCurrentToolCall();
+              if (!currentReasoning) {
+                const itemId = `rs_${uuid()}`;
+                const item = { type: "reasoning", id: itemId, summary: [] as { type: string; text: string }[] };
+                emit("response.output_item.added", { output_index: outputIndex, item });
+                emit("response.reasoning_summary_part.added", {
+                  item_id: itemId, output_index: outputIndex, summary_index: 0,
+                  part: { type: "summary_text", text: "" },
+                });
+                currentReasoning = { itemId, outputIndex, text: "" };
+              }
+              currentReasoning.text += event.thinking;
+              emit("response.reasoning_summary_text.delta", {
+                item_id: currentReasoning.itemId, output_index: currentReasoning.outputIndex,
+                summary_index: 0, delta: event.thinking,
+              });
+              break;
+            }
+            case "tool_call_start": {
+              if (currentMsg) closeCurrentMessage();
+              if (currentReasoning) closeCurrentReasoning();
+              if (currentToolCall) closeCurrentToolCall();
+              const itemId = `fc_${uuid()}`;
+              const mapped = toolNsMap?.get(event.name);
+              const realName = mapped?.name ?? event.name;
+              const ns = mapped?.namespace;
+              const toolSearch = toolSearchToolNames?.has(realName) ?? false;
+              const freeform = !toolSearch && (freeformToolNames?.has(realName) ?? false);
+              const item = toolSearch
+                ? { type: "tool_search_call", id: itemId, call_id: event.id, execution: "client", arguments: {}, status: "in_progress" }
+                : freeform
+                ? { type: "custom_tool_call", id: itemId, call_id: event.id, name: realName, input: "", status: "in_progress" }
+                : { type: "function_call", id: itemId, call_id: event.id, name: realName, arguments: "", status: "in_progress", ...(ns ? { namespace: ns } : {}) };
+              emit("response.output_item.added", { output_index: outputIndex, item });
+              currentToolCall = { itemId, outputIndex, callId: event.id, name: realName, args: "", namespace: ns, freeform, toolSearch };
+              break;
+            }
+            case "tool_call_delta": {
+              if (currentToolCall) {
+                currentToolCall.args += event.arguments;
+                if (!currentToolCall.freeform && !currentToolCall.toolSearch) {
+                  emit("response.function_call_arguments.delta", {
+                    item_id: currentToolCall.itemId, output_index: currentToolCall.outputIndex,
+                    delta: event.arguments,
+                  });
+                }
+              }
+              break;
+            }
+            case "tool_call_end": {
+              closeCurrentToolCall();
+              break;
+            }
+            case "done": {
+              if (currentMsg) closeCurrentMessage();
+              if (currentReasoning) closeCurrentReasoning();
+              if (currentToolCall) closeCurrentToolCall();
+              const usage = event.usage ? {
+                input_tokens: event.usage.inputTokens,
+                output_tokens: event.usage.outputTokens,
+                total_tokens: event.usage.inputTokens + event.usage.outputTokens,
+              } : { input_tokens: 0, output_tokens: 0, total_tokens: 0 };
+              emit("response.completed", {
+                response: { ...responseSnapshot("completed", finishedItems), usage },
+              });
+              break;
+            }
+            case "error": {
+              if (currentMsg) closeCurrentMessage();
+              if (currentReasoning) closeCurrentReasoning();
+              if (currentToolCall) closeCurrentToolCall();
+              emit("response.failed", {
+                response: {
+                  ...responseSnapshot("failed", finishedItems),
+                  last_error: { type: "upstream_error", message: event.message },
+                },
+              });
+              break;
+            }
+          }
+        }
+      } catch (err) {
+        emit("response.failed", {
+          response: {
+            ...responseSnapshot("failed", finishedItems),
+            last_error: { type: "proxy_error", message: err instanceof Error ? err.message : String(err) },
+          },
+        });
+      }
+
+      emitDone();
+      controller.close();
+    },
+  });
+}
+
+export function buildResponseJSON(
+  events: AdapterEvent[],
+  modelId: string,
+): Record<string, unknown> {
+  const responseId = `resp_${uuid()}`;
+  const output: OutputItem[] = [];
+  let text = "";
+  let usage: OcxUsage | undefined;
+
+  for (const e of events) {
+    if (e.type === "text_delta") text += e.text;
+    if (e.type === "done") usage = e.usage;
+  }
+
+  if (text) {
+    output.push({
+      type: "message", id: `msg_${uuid()}`, role: "assistant", status: "completed",
+      content: [{ type: "output_text", text, annotations: [] }],
+    });
+  }
+
+  return {
+    id: responseId, object: "response",
+    created_at: Math.floor(Date.now() / 1000),
+    status: "completed", model: modelId, output,
+    usage: usage ? {
+      input_tokens: usage.inputTokens, output_tokens: usage.outputTokens,
+      total_tokens: usage.inputTokens + usage.outputTokens,
+    } : { input_tokens: 0, output_tokens: 0, total_tokens: 0 },
+  };
+}
+
+export function formatErrorResponse(status: number, type: string, message: string): Response {
+  return new Response(JSON.stringify({ error: { message, type, code: null } }), {
+    status, headers: { "Content-Type": "application/json" },
+  });
+}