fix: handle error SSE events from Codex API instead of silently dropping them

When the Codex API returns `event: error` or `event: response.failed`,
the proxy now surfaces the error message to clients instead of returning
empty responses. Also detects non-SSE JSON error bodies from upstream.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src/proxy/codex-api.ts

@@ -302,6 +302,7 @@ export class CodexApi {
 
     const MAX_SSE_BUFFER = 10 * 1024 * 1024; // 10MB
     let buffer = "";
+    let yieldedAny = false;
     try {
       while (true) {
         const { done, value } = await reader.read();
@@ -317,14 +318,40 @@ export class CodexApi {
         for (const part of parts) {
           if (!part.trim()) continue;
           const evt = this.parseSSEBlock(part);
-          if (evt) yield evt;
+          if (evt) {
+            yieldedAny = true;
+            yield evt;
+          }
         }
       }
 
       // Process remaining buffer
       if (buffer.trim()) {
         const evt = this.parseSSEBlock(buffer);
-        if (evt) yield evt;
+        if (evt) {
+          yieldedAny = true;
+          yield evt;
+        }
+      }
+
+      // Non-SSE response detection: if the entire stream yielded no SSE events
+      // but has content, the upstream likely returned a plain JSON error body.
+      if (!yieldedAny && buffer.trim()) {
+        let errorMessage = buffer.trim();
+        try {
+          const parsed = JSON.parse(errorMessage) as Record<string, unknown>;
+          const errObj = typeof parsed.error === "object" && parsed.error !== null
+            ? (parsed.error as Record<string, unknown>)
+            : undefined;
+          errorMessage =
+            (typeof parsed.detail === "string" ? parsed.detail : null)
+            ?? (typeof errObj?.message === "string" ? errObj.message : null)
+            ?? errorMessage;
+        } catch { /* use raw text */ }
+        yield {
+          event: "error",
+          data: { error: { type: "error", code: "non_sse_response", message: errorMessage } },
+        };
       }
     } finally {
       reader.releaseLock();

src/translation/codex-event-extractor.ts

@@ -38,6 +38,7 @@ export interface ExtractedEvent {
   responseId?: string;
   textDelta?: string;
   usage?: UsageInfo;
+  error?: { code: string; message: string };
   functionCallStart?: FunctionCallStart;
   functionCallDelta?: FunctionCallDelta;
   functionCallDone?: FunctionCallDone;
@@ -108,6 +109,15 @@ export async function* iterateCodexEvents(
         if (typed.response.id) extracted.responseId = typed.response.id;
         if (typed.response.usage) extracted.usage = typed.response.usage;
         break;
+
+      case "error":
+        extracted.error = { code: typed.error.code, message: typed.error.message };
+        break;
+
+      case "response.failed":
+        extracted.error = { code: typed.error.code, message: typed.error.message };
+        if (typed.response.id) extracted.responseId = typed.response.id;
+        break;
     }
 
     yield extracted;

src/translation/codex-to-anthropic.ts

@@ -74,6 +74,29 @@ export async function* streamCodexToAnthropic(
   for await (const evt of iterateCodexEvents(codexApi, rawResponse)) {
     if (evt.responseId) onResponseId?.(evt.responseId);
 
+    // Handle upstream error events
+    if (evt.error) {
+      // Close current text block if open
+      if (textBlockStarted) {
+        yield formatSSE("content_block_delta", {
+          type: "content_block_delta",
+          index: contentIndex,
+          delta: { type: "text_delta", text: `[Error] ${evt.error.code}: ${evt.error.message}` },
+        });
+        yield formatSSE("content_block_stop", {
+          type: "content_block_stop",
+          index: contentIndex,
+        });
+        textBlockStarted = false;
+      }
+      yield formatSSE("error", {
+        type: "error",
+        error: { type: "api_error", message: `${evt.error.code}: ${evt.error.message}` },
+      });
+      yield formatSSE("message_stop", { type: "message_stop" });
+      return;
+    }
+
     // Handle function call start → close text block, open tool_use block
     if (evt.functionCallStart) {
       hasToolCalls = true;
@@ -207,6 +230,9 @@ export async function collectCodexToAnthropicResponse(
 
   for await (const evt of iterateCodexEvents(codexApi, rawResponse)) {
     if (evt.responseId) responseId = evt.responseId;
+    if (evt.error) {
+      throw new Error(`Codex API error: ${evt.error.code}: ${evt.error.message}`);
+    }
     if (evt.textDelta) fullText += evt.textDelta;
     if (evt.usage) {
       inputTokens = evt.usage.input_tokens;

src/translation/codex-to-gemini.ts

@@ -39,6 +39,25 @@ export async function* streamCodexToGemini(
   for await (const evt of iterateCodexEvents(codexApi, rawResponse)) {
     if (evt.responseId) onResponseId?.(evt.responseId);
 
+    // Handle upstream error events
+    if (evt.error) {
+      const errorChunk: GeminiGenerateContentResponse = {
+        candidates: [
+          {
+            content: {
+              parts: [{ text: `[Error] ${evt.error.code}: ${evt.error.message}` }],
+              role: "model",
+            },
+            finishReason: "OTHER",
+            index: 0,
+          },
+        ],
+        modelVersion: model,
+      };
+      yield `data: ${JSON.stringify(errorChunk)}\n\n`;
+      return;
+    }
+
     // Function call done → emit as a candidate with functionCall part
     if (evt.functionCallDone) {
       let args: Record<string, unknown> = {};
@@ -140,6 +159,9 @@ export async function collectCodexToGeminiResponse(
 
   for await (const evt of iterateCodexEvents(codexApi, rawResponse)) {
     if (evt.responseId) responseId = evt.responseId;
+    if (evt.error) {
+      throw new Error(`Codex API error: ${evt.error.code}: ${evt.error.message}`);
+    }
     if (evt.textDelta) fullText += evt.textDelta;
     if (evt.usage) {
       inputTokens = evt.usage.input_tokens;

src/translation/codex-to-openai.ts

@@ -66,6 +66,38 @@ export async function* streamCodexToOpenAI(
   for await (const evt of iterateCodexEvents(codexApi, rawResponse)) {
     if (evt.responseId) onResponseId?.(evt.responseId);
 
+    // Handle upstream error events
+    if (evt.error) {
+      yield formatSSE({
+        id: chunkId,
+        object: "chat.completion.chunk",
+        created,
+        model,
+        choices: [
+          {
+            index: 0,
+            delta: { content: `[Error] ${evt.error.code}: ${evt.error.message}` },
+            finish_reason: null,
+          },
+        ],
+      });
+      yield formatSSE({
+        id: chunkId,
+        object: "chat.completion.chunk",
+        created,
+        model,
+        choices: [
+          {
+            index: 0,
+            delta: {},
+            finish_reason: "stop",
+          },
+        ],
+      });
+      yield "data: [DONE]\n\n";
+      return;
+    }
+
     // Handle function call events
     if (evt.functionCallStart) {
       hasToolCalls = true;
@@ -213,6 +245,9 @@ export async function collectCodexResponse(
 
   for await (const evt of iterateCodexEvents(codexApi, rawResponse)) {
     if (evt.responseId) responseId = evt.responseId;
+    if (evt.error) {
+      throw new Error(`Codex API error: ${evt.error.code}: ${evt.error.message}`);
+    }
     if (evt.textDelta) fullText += evt.textDelta;
     if (evt.usage) {
       promptTokens = evt.usage.input_tokens;

src/types/codex-events.ts

@@ -70,6 +70,17 @@ export interface CodexFunctionCallArgsDoneEvent {
   name: string;
 }
 
+export interface CodexErrorEvent {
+  type: "error";
+  error: { type: string; code: string; message: string };
+}
+
+export interface CodexResponseFailedEvent {
+  type: "response.failed";
+  error: { type: string; code: string; message: string };
+  response: CodexResponseData;
+}
+
 export interface CodexUnknownEvent {
   type: "unknown";
   raw: unknown;
@@ -84,6 +95,8 @@ export type TypedCodexEvent =
   | CodexOutputItemAddedEvent
   | CodexFunctionCallArgsDeltaEvent
   | CodexFunctionCallArgsDoneEvent
+  | CodexErrorEvent
+  | CodexResponseFailedEvent
   | CodexUnknownEvent;
 
 // ── Type guard / parser ──────────────────────────────────────────
@@ -204,6 +217,39 @@ export function parseCodexEvent(evt: CodexSSEEvent): TypedCodexEvent {
       }
       return { type: "unknown", raw: data };
     }
+    case "error": {
+      if (isRecord(data)) {
+        const err = isRecord(data.error) ? data.error : data;
+        return {
+          type: "error",
+          error: {
+            type: typeof err.type === "string" ? err.type : "error",
+            code: typeof err.code === "string" ? err.code : "unknown",
+            message: typeof err.message === "string" ? err.message : JSON.stringify(data),
+          },
+        };
+      }
+      return {
+        type: "error",
+        error: { type: "error", code: "unknown", message: String(data) },
+      };
+    }
+    case "response.failed": {
+      const resp = parseResponseData(data);
+      if (isRecord(data)) {
+        const err = isRecord(data.error) ? data.error : {};
+        return {
+          type: "response.failed",
+          error: {
+            type: typeof err.type === "string" ? err.type : "error",
+            code: typeof err.code === "string" ? err.code : "unknown",
+            message: typeof err.message === "string" ? err.message : JSON.stringify(data),
+          },
+          response: resp ?? {},
+        };
+      }
+      return { type: "unknown", raw: data };
+    }
     default:
       return { type: "unknown", raw: data };
   }