npm - @bitkyc08/opencodex - Versions diffs - 0.2.2 → 1.9.1 - Mend

@bitkyc08/opencodex 0.2.2 → 1.9.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (30) hide show

package/README.md +3 -1
package/gui/dist/assets/{index-Dt5t57MW.js → index-CDhJ0DI7.js} +1 -1
package/gui/dist/index.html +1 -1
package/package.json +3 -1
package/src/abort.ts +29 -0
package/src/adapters/anthropic.ts +15 -5
package/src/adapters/google.ts +27 -11
package/src/adapters/openai-chat.ts +38 -12
package/src/adapters/openai-responses.ts +18 -1
package/src/bridge.ts +155 -17
package/src/cli.ts +0 -0
package/src/codex-catalog.ts +102 -11
package/src/codex-inject.ts +47 -4
package/src/config.ts +5 -0
package/src/debug.ts +10 -0
package/src/errors.ts +47 -0
package/src/generated/jawcode-model-metadata.ts +69 -0
package/src/init.ts +5 -32
package/src/oauth/index.ts +19 -33
package/src/oauth/key-providers.ts +2 -63
package/src/providers/derive.ts +163 -0
package/src/providers/registry.ts +140 -0
package/src/responses/parser.ts +6 -1
package/src/server.ts +182 -9
package/src/types.ts +6 -0
package/src/vision/describe.ts +6 -1
package/src/vision/index.ts +2 -1
package/src/web-search/executor.ts +6 -1
package/src/web-search/loop.ts +9 -3
package/src/ws-bridge.ts +359 -0

package/gui/dist/index.html CHANGED Viewed

@@ -6,7 +6,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <meta name="color-scheme" content="dark" />
     <title>opencodex · proxy dashboard</title>
-    <script type="module" crossorigin src="/assets/index-Dt5t57MW.js"></script>
+    <script type="module" crossorigin src="/assets/index-CDhJ0DI7.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-C1wlp1SM.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@bitkyc08/opencodex",
-  "version": "0.2.2",
+  "version": "1.9.1",
   "description": "Universal provider proxy for OpenAI Codex — use any LLM with Codex CLI/App/SDK",
   "type": "module",
   "main": "src/index.ts",
@@ -21,7 +21,9 @@
   "scripts": {
     "dev": "bun run src/cli.ts start",
     "start": "bun run src/cli.ts start",
+    "test": "bun test tests",
     "typecheck": "bun x tsc --noEmit",
+    "generate:jawcode-metadata": "bun scripts/generate-jawcode-metadata.ts",
     "build:gui": "cd gui && bun install && bun run build",
     "postinstall": "node scripts/postinstall.mjs",
     "prepublishOnly": "bun run typecheck && bun run build:gui",

package/src/abort.ts ADDED Viewed

@@ -0,0 +1,29 @@
+export interface LinkedAbortSignal {
+  signal: AbortSignal;
+  cleanup: () => void;
+}
+export function signalWithTimeout(timeoutMs: number, parent?: AbortSignal): LinkedAbortSignal {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => {
+    if (!controller.signal.aborted) controller.abort(new DOMException("Timeout elapsed", "TimeoutError"));
+  }, timeoutMs);
+  const abortFromParent = () => {
+    if (!controller.signal.aborted) controller.abort(parent?.reason);
+  };
+  if (parent?.aborted) {
+    abortFromParent();
+  } else {
+    parent?.addEventListener("abort", abortFromParent, { once: true });
+  }
+  return {
+    signal: controller.signal,
+    cleanup: () => {
+      clearTimeout(timeout);
+      parent?.removeEventListener("abort", abortFromParent);
+    },
+  };
+}

package/src/adapters/anthropic.ts CHANGED Viewed

@@ -1,4 +1,5 @@
 import type { ProviderAdapter } from "./base";
+import { debugDroppedFrame } from "../debug";
 import type {
   AdapterEvent,
   OcxAssistantMessage,
@@ -9,6 +10,7 @@ import type {
   OcxTextContent,
   OcxThinkingContent,
   OcxToolCall,
+  OcxUsage,
 } from "../types";
 import { ANTHROPIC_OAUTH_BETA, CLAUDE_CODE_SYSTEM_INSTRUCTION, applyClaudeToolPrefix, stripClaudeToolPrefix } from "../oauth/anthropic";
 import { parseDataUrl } from "./image";
@@ -48,6 +50,16 @@ function reasoningBudget(effort: string): number {
   }
 }
+function usageFromAnthropic(usage: Record<string, number> | undefined): OcxUsage | undefined {
+  if (!usage) return undefined;
+  const hasCache = usage.cache_read_input_tokens !== undefined || usage.cache_creation_input_tokens !== undefined;
+  return {
+    inputTokens: usage.input_tokens ?? 0,
+    outputTokens: usage.output_tokens ?? 0,
+    ...(hasCache ? { cachedInputTokens: (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0) } : {}),
+  };
+}
 function messagesToAnthropicFormat(parsed: OcxParsedRequest, isOAuth: boolean): { system: string | undefined; messages: unknown[] } {
   const system = parsed.context.systemPrompt?.join("\n\n") || undefined;
   const messages: unknown[] = [];
@@ -215,6 +227,7 @@ export function createAnthropicAdapter(provider: OcxProviderConfig): ProviderAda
             try {
               data = JSON.parse(payload) as Record<string, unknown>;
             } catch {
+              debugDroppedFrame("anthropic", payload);
               continue;
             }
@@ -255,10 +268,7 @@ export function createAnthropicAdapter(provider: OcxProviderConfig): ProviderAda
                 if (usage) {
                   yield {
                     type: "done",
-                    usage: {
-                      inputTokens: usage.input_tokens ?? 0,
-                      outputTokens: usage.output_tokens ?? 0,
-                    },
+                    usage: usageFromAnthropic(usage),
                   };
                 }
                 break;
@@ -298,7 +308,7 @@ export function createAnthropicAdapter(provider: OcxProviderConfig): ProviderAda
       const usage = json.usage as Record<string, number> | undefined;
       events.push({
         type: "done",
-        usage: usage ? { inputTokens: usage.input_tokens ?? 0, outputTokens: usage.output_tokens ?? 0 } : undefined,
+        usage: usageFromAnthropic(usage),
       });
       return events;
     },

package/src/adapters/google.ts CHANGED Viewed

@@ -1,4 +1,5 @@
 import type { ProviderAdapter } from "./base";
+import { debugDroppedFrame } from "../debug";
 import type {
   AdapterEvent,
   OcxAssistantMessage,
@@ -7,6 +8,7 @@ import type {
   OcxProviderConfig,
   OcxTextContent,
   OcxToolCall,
+  OcxUsage,
 } from "../types";
 import { contentPartsToText, parseDataUrl } from "./image";
@@ -74,6 +76,16 @@ function toolsToGeminiFormat(parsed: OcxParsedRequest): unknown[] | undefined {
   }];
 }
+function usageFromGemini(usage: Record<string, number> | undefined): OcxUsage | undefined {
+  if (!usage) return undefined;
+  return {
+    inputTokens: usage.promptTokenCount ?? 0,
+    outputTokens: usage.candidatesTokenCount ?? 0,
+    ...(usage.cachedContentTokenCount !== undefined ? { cachedInputTokens: usage.cachedContentTokenCount } : {}),
+    ...(usage.thoughtsTokenCount !== undefined ? { reasoningOutputTokens: usage.thoughtsTokenCount } : {}),
+  };
+}
 export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapter {
   return {
     name: "google",
@@ -113,6 +125,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       const reader = response.body.getReader();
       const decoder = new TextDecoder();
       let buffer = "";
+      let pendingUsage: OcxUsage | undefined;
       try {
         while (true) {
@@ -129,7 +142,14 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
             if (!payload) continue;
             let chunk: Record<string, unknown>;
-            try { chunk = JSON.parse(payload); } catch { continue; }
+            try { chunk = JSON.parse(payload); } catch { debugDroppedFrame("google", payload); continue; }
+            // Inline provider error inside a 200 stream → terminal error (see openai-chat.ts).
+            if (chunk.error) {
+              const err = chunk.error as { message?: string } | undefined;
+              yield { type: "error", message: err?.message ?? "upstream error" };
+              return;
+            }
             const candidates = chunk.candidates as { content?: { parts?: unknown[] }; finishReason?: string }[] | undefined;
             if (!candidates?.length) continue;
@@ -150,18 +170,14 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
             }
             const usageMeta = chunk.usageMetadata as Record<string, number> | undefined;
-            if (candidates[0].finishReason && usageMeta) {
-              yield {
-                type: "done",
-                usage: {
-                  inputTokens: usageMeta.promptTokenCount ?? 0,
-                  outputTokens: usageMeta.candidatesTokenCount ?? 0,
-                },
-              };
+            if (usageMeta) {
+              // Accumulate usage; emit a single terminal `done` post-loop so usage is never
+              // dropped on EOF and the stream never yields two `done` events.
+              pendingUsage = usageFromGemini(usageMeta);
             }
           }
         }
-        yield { type: "done" };
+        yield { type: "done", usage: pendingUsage };
       } finally {
         reader.releaseLock();
       }
@@ -187,7 +203,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       const usage = json.usageMetadata as Record<string, number> | undefined;
       events.push({
         type: "done",
-        usage: usage ? { inputTokens: usage.promptTokenCount ?? 0, outputTokens: usage.candidatesTokenCount ?? 0 } : undefined,
+        usage: usageFromGemini(usage),
       });
       return events;
     },

package/src/adapters/openai-chat.ts CHANGED Viewed

@@ -1,5 +1,6 @@
 import type { ProviderAdapter } from "./base";
-import type { AdapterEvent, OcxAssistantMessage, OcxContentPart, OcxMessage, OcxParsedRequest, OcxProviderConfig, OcxTextContent, OcxToolCall } from "../types";
+import { debugDroppedFrame } from "../debug";
+import type { AdapterEvent, OcxAssistantMessage, OcxContentPart, OcxMessage, OcxParsedRequest, OcxProviderConfig, OcxTextContent, OcxToolCall, OcxUsage } from "../types";
 import { namespacedToolName } from "../types";
 import { contentPartsToText } from "./image";
@@ -96,6 +97,18 @@ function toolChoiceToChatFormat(tc: OcxParsedRequest["options"]["toolChoice"]):
   return undefined;
 }
+function usageFromOpenAIChat(usage: Record<string, unknown> | undefined): OcxUsage | undefined {
+  if (!usage) return undefined;
+  const promptDetails = usage.prompt_tokens_details as Record<string, number> | undefined;
+  const completionDetails = usage.completion_tokens_details as Record<string, number> | undefined;
+  return {
+    inputTokens: typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : 0,
+    outputTokens: typeof usage.completion_tokens === "number" ? usage.completion_tokens : 0,
+    ...(promptDetails?.cached_tokens !== undefined ? { cachedInputTokens: promptDetails.cached_tokens } : {}),
+    ...(completionDetails?.reasoning_tokens !== undefined ? { reasoningOutputTokens: completionDetails.reasoning_tokens } : {}),
+  };
+}
 export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAdapter {
   return {
     name: "openai-chat",
@@ -151,7 +164,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
       let buffer = "";
       let currentToolCallId = "";
       let currentToolCallName = "";
-      let pendingUsage: { inputTokens: number; outputTokens: number } | undefined;
+      let pendingUsage: OcxUsage | undefined;
       try {
         while (true) {
@@ -178,16 +191,25 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
             try {
               chunk = JSON.parse(payload) as Record<string, unknown>;
             } catch {
+              debugDroppedFrame("openai-chat", payload);
               continue;
             }
+            // A 200/OK chat-completions stream may carry an inline provider error envelope
+            // instead of a clean [DONE]. Surface it as a terminal error so the bridge emits a
+            // classified response.failed (bridge case "error") — never a truncated completion.
+            if (chunk.error) {
+              const err = chunk.error as { message?: string } | undefined;
+              if (currentToolCallId) yield { type: "tool_call_end" };
+              yield { type: "error", message: err?.message ?? "upstream error" };
+              return;
+            }
             if (chunk.usage) {
-              const u = chunk.usage as Record<string, number>;
-              pendingUsage = {
-                inputTokens: u.prompt_tokens ?? 0,
-                outputTokens: u.completion_tokens ?? 0,
-              };
-              continue;
+              // Record usage but keep parsing: some providers send usage and the final content
+              // delta in the SAME chunk; a `continue` here would drop that content. The choices
+              // guard below no-ops a usage-only chunk.
+              pendingUsage = usageFromOpenAIChat(chunk.usage as Record<string, unknown>);
             }
             const choices = chunk.choices as { delta?: Record<string, unknown>; finish_reason?: string }[] | undefined;
@@ -200,7 +222,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
             }
             if (typeof delta.reasoning_content === "string" && delta.reasoning_content.length > 0) {
-              yield { type: "thinking_delta", thinking: delta.reasoning_content };
+              yield { type: "reasoning_raw_delta", text: delta.reasoning_content };
             }
             const toolCalls = delta.tool_calls as { index: number; id?: string; function?: { name?: string; arguments?: string } }[] | undefined;
@@ -228,7 +250,8 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
         if (currentToolCallId) {
           yield { type: "tool_call_end" };
         }
-        yield { type: "done" };
+        // EOF without a [DONE] sentinel: still surface any usage accumulated mid-stream.
+        yield { type: "done", usage: pendingUsage };
       } finally {
         reader.releaseLock();
       }
@@ -244,6 +267,9 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
           if (typeof msg.content === "string") {
             events.push({ type: "text_delta", text: msg.content });
           }
+          if (typeof msg.reasoning_content === "string" && msg.reasoning_content.length > 0) {
+            events.push({ type: "reasoning_raw_delta", text: msg.reasoning_content });
+          }
           const toolCalls = msg.tool_calls as { id: string; function: { name: string; arguments: string } }[] | undefined;
           if (toolCalls) {
             for (const tc of toolCalls) {
@@ -254,10 +280,10 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
           }
         }
       }
-      const usage = json.usage as Record<string, number> | undefined;
+      const usage = json.usage as Record<string, unknown> | undefined;
       events.push({
         type: "done",
-        usage: usage ? { inputTokens: usage.prompt_tokens ?? 0, outputTokens: usage.completion_tokens ?? 0 } : undefined,
+        usage: usageFromOpenAIChat(usage),
       });
       return events;
     },

package/src/adapters/openai-responses.ts CHANGED Viewed

@@ -3,7 +3,24 @@ 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 const FORWARD_HEADERS = [
+  "authorization",
+  "chatgpt-account-id",
+  "openai-beta",
+  "originator",
+  "session_id",
+  "session-id",
+  "thread-id",
+  "x-client-request-id",
+  "x-codex-beta-features",
+  "x-codex-installation-id",
+  "x-codex-parent-thread-id",
+  "x-codex-turn-metadata",
+  "x-codex-turn-state",
+  "x-codex-window-id",
+  "x-oai-attestation",
+  "x-responsesapi-include-timing-metrics",
+];
 export function createResponsesPassthroughAdapter(provider: OcxProviderConfig): ProviderAdapter & { passthrough: true } {
   return {

package/src/bridge.ts CHANGED Viewed

@@ -1,4 +1,5 @@
 import type { AdapterEvent, OcxUsage } from "./types";
+import { classifyError, type OcxErrorPayload } from "./errors";
 function uuid(): string {
   return crypto.randomUUID().replace(/-/g, "");
@@ -8,6 +9,26 @@ function sseEvent(name: string, data: Record<string, unknown>): string {
   return `event: ${name}\ndata: ${JSON.stringify(data)}\n\n`;
 }
+function responsesUsage(usage: OcxUsage | undefined): Record<string, unknown> {
+  if (!usage) return { input_tokens: 0, output_tokens: 0, total_tokens: 0 };
+  const out: Record<string, unknown> = {
+    input_tokens: usage.inputTokens,
+    output_tokens: usage.outputTokens,
+    total_tokens: usage.inputTokens + usage.outputTokens,
+  };
+  if (usage.cachedInputTokens !== undefined) {
+    out.input_tokens_details = { cached_tokens: usage.cachedInputTokens };
+  }
+  if (usage.reasoningOutputTokens !== undefined) {
+    out.output_tokens_details = { reasoning_tokens: usage.reasoningOutputTokens };
+  }
+  return out;
+}
+function responseError(status: number, type: string, message: string): OcxErrorPayload {
+  return classifyError(status, type, message);
+}
 interface OutputItem {
   type: string;
   id: string;
@@ -20,6 +41,9 @@ export function bridgeToResponsesSSE(
   toolNsMap?: Map<string, { namespace: string; name: string }>,
   freeformToolNames?: Set<string>,
   toolSearchToolNames?: Set<string>,
+  onCancel?: () => void,
+  heartbeatMs = 2_000,
+  options?: { responseId?: 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.
@@ -32,15 +56,38 @@ export function bridgeToResponsesSSE(
     try { const o = JSON.parse(args); return o && typeof o === "object" ? o : {}; } catch { return {}; }
   };
   const encoder = new TextEncoder();
-  const responseId = `resp_${uuid()}`;
+  const responseId = options?.responseId ?? `resp_${uuid()}`;
   let seq = 0;
+  // Set once the client is gone (cancel) or an enqueue throws on a torn-down controller, so we
+  // never enqueue again and never throw a second time inside start() — the RC2 double-throw that
+  // otherwise surfaced as proxy-side stream noise on every client disconnect.
+  let closed = false;
+  // RC3 keep-alive: Codex's idle timer is timeout(idle_timeout, stream.next()) over an
+  // eventsource_stream; ANY received event re-arms it, while an unknown type is ignored
+  // (responses.rs `_ => Ok(None)`). We emit a real, parser-ignored `response.heartbeat` only during
+  // upstream silence so a stalled routed provider never trips "idle timeout waiting for SSE".
+  let activity = false;
+  let beat: ReturnType<typeof setInterval> | undefined;
   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 })));
+        if (closed) return;
+        activity = true;
+        try {
+          controller.enqueue(encoder.encode(sseEvent(name, { type: name, sequence_number: seq++, ...data })));
+        } catch {
+          closed = true;
+        }
+      };
+      const emitDone = () => {
+        if (closed) return;
+        try {
+          controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+        } catch {
+          closed = true;
+        }
       };
-      const emitDone = () => controller.enqueue(encoder.encode("data: [DONE]\n\n"));
       const createdAt = Math.floor(Date.now() / 1000);
       let outputIndex = 0;
@@ -53,8 +100,18 @@ export function bridgeToResponsesSSE(
       emit("response.created", { response: responseSnapshot("in_progress", []) });
+      // Re-arm Codex's idle timer during silence with a parser-ignored heartbeat (RC3). Skips a tick
+      // whenever a real event was emitted since the last tick, so it only fires on a genuine stall.
+      const heartbeatFrame = encoder.encode('event: response.heartbeat\ndata: {"type":"response.heartbeat"}\n\n');
+      beat = setInterval(() => {
+        if (closed) return;
+        if (activity) { activity = false; return; }
+        try { controller.enqueue(heartbeatFrame); } catch { closed = true; }
+      }, heartbeatMs);
       let currentMsg: { itemId: string; outputIndex: number; text: string } | null = null;
       let currentReasoning: { itemId: string; outputIndex: number; text: string } | null = null;
+      let currentRawReasoning: { 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 = () => {
@@ -97,6 +154,18 @@ export function bridgeToResponsesSSE(
         currentReasoning = null;
       };
+      const closeCurrentRawReasoning = () => {
+        if (!currentRawReasoning) return;
+        const item = {
+          type: "reasoning", id: currentRawReasoning.itemId, summary: [],
+          content: [{ type: "reasoning_text", text: currentRawReasoning.text }],
+        };
+        emit("response.output_item.done", { output_index: currentRawReasoning.outputIndex, item });
+        finishedItems.push(item as OutputItem);
+        outputIndex++;
+        currentRawReasoning = null;
+      };
       const closeCurrentToolCall = () => {
         if (!currentToolCall) return;
         // Empty input (no-arg tools like computer_use get_app_state / list_apps) must serialize as
@@ -133,11 +202,18 @@ export function bridgeToResponsesSSE(
         currentToolCall = null;
       };
+      // RC1: guarantee the Responses stream always ends with exactly one terminal event. Set true
+      // when a done/error/catch terminal is emitted; if the adapter generator returns without one
+      // we synthesize response.completed below, so Codex never hits the parser's
+      // "stream closed before response.completed" (responses.rs) -> ApiError::Stream.
+      let terminated = false;
       try {
         for await (const event of events) {
           switch (event.type) {
             case "text_delta": {
               if (currentReasoning) closeCurrentReasoning();
+              if (currentRawReasoning) closeCurrentRawReasoning();
               if (currentToolCall) closeCurrentToolCall();
               if (!currentMsg) {
                 const itemId = `msg_${uuid()}`;
@@ -161,6 +237,7 @@ export function bridgeToResponsesSSE(
             }
             case "thinking_delta": {
               if (currentMsg) closeCurrentMessage();
+              if (currentRawReasoning) closeCurrentRawReasoning();
               if (currentToolCall) closeCurrentToolCall();
               if (!currentReasoning) {
                 const itemId = `rs_${uuid()}`;
@@ -179,9 +256,27 @@ export function bridgeToResponsesSSE(
               });
               break;
             }
+            case "reasoning_raw_delta": {
+              if (currentMsg) closeCurrentMessage();
+              if (currentReasoning) closeCurrentReasoning();
+              if (currentToolCall) closeCurrentToolCall();
+              if (!currentRawReasoning) {
+                const itemId = `rs_${uuid()}`;
+                const item = { type: "reasoning", id: itemId, summary: [] as never[], content: [] as { type: string; text: string }[] };
+                emit("response.output_item.added", { output_index: outputIndex, item });
+                currentRawReasoning = { itemId, outputIndex, text: "" };
+              }
+              currentRawReasoning.text += event.text;
+              emit("response.reasoning_text.delta", {
+                item_id: currentRawReasoning.itemId, output_index: currentRawReasoning.outputIndex,
+                content_index: 0, delta: event.text,
+              });
+              break;
+            }
             case "tool_call_start": {
               if (currentMsg) closeCurrentMessage();
               if (currentReasoning) closeCurrentReasoning();
+              if (currentRawReasoning) closeCurrentRawReasoning();
               if (currentToolCall) closeCurrentToolCall();
               const itemId = `fc_${uuid()}`;
               const mapped = toolNsMap?.get(event.name);
@@ -217,27 +312,27 @@ export function bridgeToResponsesSSE(
             case "done": {
               if (currentMsg) closeCurrentMessage();
               if (currentReasoning) closeCurrentReasoning();
+              if (currentRawReasoning) closeCurrentRawReasoning();
               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 },
+                response: { ...responseSnapshot("completed", finishedItems), usage: responsesUsage(event.usage) },
               });
+              terminated = true;
               break;
             }
             case "error": {
               if (currentMsg) closeCurrentMessage();
               if (currentReasoning) closeCurrentReasoning();
+              if (currentRawReasoning) closeCurrentRawReasoning();
               if (currentToolCall) closeCurrentToolCall();
               emit("response.failed", {
                 response: {
                   ...responseSnapshot("failed", finishedItems),
-                  last_error: { type: "upstream_error", message: event.message },
+                  error: responseError(502, "upstream_error", event.message),
+                  last_error: responseError(502, "upstream_error", event.message),
                 },
               });
+              terminated = true;
               break;
             }
           }
@@ -246,13 +341,41 @@ export function bridgeToResponsesSSE(
         emit("response.failed", {
           response: {
             ...responseSnapshot("failed", finishedItems),
-            last_error: { type: "proxy_error", message: err instanceof Error ? err.message : String(err) },
+            error: responseError(500, "proxy_error", err instanceof Error ? err.message : String(err)),
+            last_error: responseError(500, "proxy_error", err instanceof Error ? err.message : String(err)),
           },
         });
+        terminated = true;
+      }
+      if (beat) clearInterval(beat);
+      if (!terminated) {
+        // The adapter generator ended without a done/error event (e.g. an upstream that closes
+        // after message_stop, or a routed provider that drops the connection cleanly). Close any
+        // open items and synthesize a clean completion so the stream is never terminal-less.
+        if (currentMsg) closeCurrentMessage();
+        if (currentReasoning) closeCurrentReasoning();
+        if (currentRawReasoning) closeCurrentRawReasoning();
+        if (currentToolCall) closeCurrentToolCall();
+        emit("response.completed", {
+          response: { ...responseSnapshot("completed", finishedItems), usage: responsesUsage(undefined) },
+        });
       }
       emitDone();
-      controller.close();
+      try {
+        controller.close();
+      } catch {
+        /* already closed (e.g. client cancelled) */
+      }
+    },
+    cancel() {
+      // Client (Codex) disconnected. Stop emitting and let the caller abort the upstream fetch so a
+      // cancelled turn does not leak the upstream stream or keep draining tokens (RC2).
+      closed = true;
+      if (beat) clearInterval(beat);
+      onCancel?.();
     },
   });
 }
@@ -264,13 +387,31 @@ export function buildResponseJSON(
   const responseId = `resp_${uuid()}`;
   const output: OutputItem[] = [];
   let text = "";
+  let summaryReasoning = "";
+  let rawReasoning = "";
   let usage: OcxUsage | undefined;
   for (const e of events) {
     if (e.type === "text_delta") text += e.text;
+    if (e.type === "thinking_delta") summaryReasoning += e.thinking;
+    if (e.type === "reasoning_raw_delta") rawReasoning += e.text;
     if (e.type === "done") usage = e.usage;
   }
+  if (rawReasoning) {
+    output.push({
+      type: "reasoning", id: `rs_${uuid()}`, summary: [],
+      content: [{ type: "reasoning_text", text: rawReasoning }],
+    });
+  }
+  if (summaryReasoning) {
+    output.push({
+      type: "reasoning", id: `rs_${uuid()}`,
+      summary: [{ type: "summary_text", text: summaryReasoning }],
+    });
+  }
   if (text) {
     output.push({
       type: "message", id: `msg_${uuid()}`, role: "assistant", status: "completed",
@@ -282,15 +423,12 @@ export function buildResponseJSON(
     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 },
+    usage: responsesUsage(usage),
   };
 }
 export function formatErrorResponse(status: number, type: string, message: string): Response {
-  return new Response(JSON.stringify({ error: { message, type, code: null } }), {
+  return new Response(JSON.stringify({ error: classifyError(status, type, message) }), {
     status, headers: { "Content-Type": "application/json" },
   });
 }

package/src/cli.ts CHANGED Viewed

File without changes