Skip to content

Claude Code. Any Model. The most powerful AI coding agent now speaks every language.

fix(sse): surface an upstream error carried inside a 200 stream

Jack Rudenko321c2f040da7
diff --git a/packages/cli/src/format-translation.test.ts b/packages/cli/src/format-translation.test.ts
index f63d6f9a..dee3137a 100644
--- a/packages/cli/src/format-translation.test.ts
+++ b/packages/cli/src/format-translation.test.ts
@@ -194,6 +194,58 @@ function createMockContext(): any {
// ─── OpenAI SSE Parser Tests ────────────────────────────────────────────────
+describe("describeInStreamError", () => {
+ async function getFormatter() {
+ const mod = await import("./handlers/shared/stream-parsers/openai-sse.js");
+ return mod.describeInStreamError;
+ }
+
+ test("describes the production OpenRouter refusal with provider, code, type, and message", async () => {
+ const describeInStreamError = await getFormatter();
+ const productionFrame = {
+ id: "gen-1789563247-…",
+ object: "chat.completion.chunk",
+ created: 1789563247,
+ model: "unknown",
+ provider: "Google AI Studio",
+ choices: [],
+ error: {
+ code: 400,
+ message: "SYNTHETIC upstream message (real text unknown)",
+ metadata: {
+ error_type: "invalid_request",
+ provider_code: "400",
+ },
+ },
+ };
+
+ expect(describeInStreamError(productionFrame)).toBe(
+ "[Google AI Studio] 400 invalid_request SYNTHETIC upstream message (real text unknown)"
+ );
+ });
+
+ test("returns undefined for a normal content frame", async () => {
+ const describeInStreamError = await getFormatter();
+
+ expect(
+ describeInStreamError({
+ choices: [{ index: 0, delta: { content: "healthy content" }, finish_reason: null }],
+ })
+ ).toBeUndefined();
+ });
+
+ test("handles bare-string and message-only errors", async () => {
+ const describeInStreamError = await getFormatter();
+
+ expect(describeInStreamError({ error: "gateway refused the request" })).toBe(
+ "gateway refused the request"
+ );
+ expect(describeInStreamError({ error: { message: "signature missing" } })).toBe(
+ "signature missing"
+ );
+ });
+});
+
describe("OpenAI SSE → Claude SSE (createStreamingResponseHandler)", () => {
// Dynamic import to avoid circular dependency issues at module level
async function getParser() {
@@ -271,6 +323,83 @@ describe("OpenAI SSE → Claude SSE (createStreamingResponseHandler)", () => {
// Should end with tool_use
expect(extractStopReason(events)).toBe("tool_use");
});
+
+ test("REGRESSION: an OpenRouter error frame with empty choices emits error and no message_stop", async () => {
+ const createStreamingResponseHandler = await getParser();
+ const adapter = await getDefaultAdapter();
+ const fixture = fixtureToResponse(
+ join(FIXTURES_DIR, "regression-openrouter-google-ai-studio-empty-choices-error.sse")
+ );
+
+ const response = createStreamingResponseHandler(
+ createMockContext(),
+ fixture,
+ adapter,
+ "test-model",
+ null,
+ undefined,
+ undefined
+ );
+ const events = await parseClaudeSseStream(response);
+ const errorEvent = events.find((event) => event.event === "error");
+
+ expect(errorEvent?.data?.type).toBe("error");
+ expect(errorEvent?.data?.error?.type).toBe("api_error");
+ expect(errorEvent?.data?.error?.message).toBe(
+ "[Google AI Studio] 400 invalid_request SYNTHETIC upstream message (real text unknown)"
+ );
+ expect(events.some((event) => event.data?.type === "message_stop")).toBe(false);
+ });
+
+ test("REGRESSION: content before an in-stream error is preserved and followed by error", async () => {
+ const createStreamingResponseHandler = await getParser();
+ const adapter = await getDefaultAdapter();
+ const fixture = fixtureToResponse(
+ join(FIXTURES_DIR, "regression-openrouter-google-ai-studio-content-then-error.sse")
+ );
+
+ const response = createStreamingResponseHandler(
+ createMockContext(),
+ fixture,
+ adapter,
+ "test-model",
+ null,
+ undefined,
+ undefined
+ );
+ const events = await parseClaudeSseStream(response);
+ const textEventIndex = events.findIndex(
+ (event) =>
+ event.data?.type === "content_block_delta" && event.data?.delta?.type === "text_delta"
+ );
+ const errorEventIndex = events.findIndex((event) => event.event === "error");
+
+ expect(extractText(events)).toBe("Earlier content survives.");
+ expect(textEventIndex).toBeGreaterThan(-1);
+ expect(errorEventIndex).toBeGreaterThan(textEventIndex);
+ expect(events.some((event) => event.data?.type === "message_stop")).toBe(false);
+ });
+
+ test("CONTROL: a healthy stream still emits message_delta and message_stop without error", async () => {
+ const createStreamingResponseHandler = await getParser();
+ const adapter = await getDefaultAdapter();
+ const fixture = fixtureToResponse(join(FIXTURES_DIR, "SEED-openai-text-only.sse"));
+
+ const response = createStreamingResponseHandler(
+ createMockContext(),
+ fixture,
+ adapter,
+ "test-model",
+ null,
+ undefined,
+ undefined
+ );
+ const events = await parseClaudeSseStream(response);
+
+ expect(events.some((event) => event.event === "error")).toBe(false);
+ expect(events.some((event) => event.data?.type === "message_delta")).toBe(true);
+ expect(events.some((event) => event.data?.type === "message_stop")).toBe(true);
+ });
});
// ─── Anthropic SSE Parser Tests ─────────────────────────────────────────────
diff --git a/packages/cli/src/handlers/shared/stream-parsers/openai-sse.ts b/packages/cli/src/handlers/shared/stream-parsers/openai-sse.ts
index 59b2a9a7..56dbaaee 100644
--- a/packages/cli/src/handlers/shared/stream-parsers/openai-sse.ts
+++ b/packages/cli/src/handlers/shared/stream-parsers/openai-sse.ts
@@ -117,6 +117,66 @@ export interface ToolState {
ref: BlockRef | null;
}
+/**
+ * Render an error carried INSIDE a 200 stream into one readable line.
+ *
+ * ## Why this exists
+ *
+ * OpenRouter answers HTTP 200 and then reports the upstream's refusal as a
+ * frame in the body:
+ *
+ * data: {"id":"…","model":"unknown","provider":"Google AI Studio",
+ * "choices":[],"error":{"code":400,"message":"…",
+ * "metadata":{"error_type":"invalid_request","provider_code":"400"}}}
+ *
+ * The frame has an EMPTY `choices` array, so every field the parser reads
+ * (`choices[0].delta`, `choices[0].finish_reason`) is undefined and the frame
+ * matched nothing at all. It was dropped without a log line, the stream ended
+ * with no content and no `finish_reason`, and the turn looked like a model that
+ * simply had nothing to say. Measured 2026-09-16: a 105-second session ended
+ * `exit 0` with zero bytes of output twice in a row, after billing the tokens
+ * its earlier successful turns had spent.
+ *
+ * Claudish already learned this lesson twice on other wires —
+ * `stream-head-sniffer.ts` for the Codex Responses backend and
+ * `devin-stream-head-sniffer.ts` for Devin, both of which open by noting that
+ * "every retry hook in claudish keys off the HTTP status". The OpenAI-shaped
+ * wire, which is the most used one, never got the same treatment.
+ *
+ * Returns undefined when the frame carries no error, so the caller can test the
+ * result directly rather than duplicating the shape-sniffing.
+ */
+export function describeInStreamError(chunk: unknown): string | undefined {
+ if (!chunk || typeof chunk !== "object") return undefined;
+ const error = (chunk as { error?: unknown }).error;
+ if (!error) return undefined;
+
+ // Some gateways send a bare string; most send an object.
+ if (typeof error === "string") return error;
+ if (typeof error !== "object") return String(error);
+
+ const e = error as Record<string, unknown>;
+ const metadata = (e.metadata ?? {}) as Record<string, unknown>;
+
+ const parts: string[] = [];
+ // The vendor that actually refused, when the aggregator names it. Without
+ // this the message reads as though the aggregator itself rejected the call.
+ const provider = (chunk as { provider?: unknown }).provider;
+ if (typeof provider === "string" && provider) parts.push(`[${provider}]`);
+
+ const code = e.code ?? metadata.provider_code;
+ const type = e.type ?? metadata.error_type;
+ const label = [code, type].filter((v) => v !== undefined && v !== null && v !== "").join(" ");
+ if (label) parts.push(label);
+
+ const message = e.message ?? metadata.raw;
+ parts.push(
+ typeof message === "string" && message.trim() ? message : JSON.stringify(error).slice(0, 500)
+ );
+
+ return parts.join(" ");
+}
+
/**
* Validate tool call arguments against the tool schema
* Now includes automatic repair of missing parameters
@@ -797,6 +857,23 @@ export function createStreamingResponseHandler(
);
}
+ // An error carried inside the 200 body. Checked AFTER `usage`
+ // so the tokens the turn already spent are still reported, and
+ // BEFORE the `choices[0]` reads below, which an error frame's
+ // empty `choices` array silently fails to match.
+ //
+ // `finalize("error", …)` emits an SSE `error` event, which is
+ // the only thing that makes Claude Code surface the failure. The
+ // alternative — turning it into an assistant text block — is the
+ // mistake `stream-head-sniffer.ts` documents: it freezes a
+ // provider failure into the transcript as a successful answer.
+ const inStreamError = describeInStreamError(chunk);
+ if (inStreamError) {
+ log(`[Streaming] Upstream error inside a 200 stream: ${inStreamError}`);
+ await finalize("error", inStreamError);
+ return;
+ }
+
const delta = chunk.choices?.[0]?.delta;
const finishReason = chunk.choices?.[0]?.finish_reason;
if (finishReason) state.finishReason = finishReason;
diff --git a/packages/cli/src/test-fixtures/sse-responses/regression-openrouter-google-ai-studio-content-then-error.sse b/packages/cli/src/test-fixtures/sse-responses/regression-openrouter-google-ai-studio-content-then-error.sse
new file mode 100644
index 00000000..d0d1f0f4
--- /dev/null
+++ b/packages/cli/src/test-fixtures/sse-responses/regression-openrouter-google-ai-studio-content-then-error.sse
@@ -0,0 +1,10 @@
+: FRAME SHAPE observed 2026-09-16, ~/.claudish/logs/claudish_2026-09-16_12-52-57.log
+: route or@google/gemini-3.8-flash. HTTP was 200; the 400 rides inside the body.
+: The empty "choices" array is the load-bearing part — it is why every
+: choices[0] read returned undefined and the frame was dropped silently.
+: The error MESSAGE text is NOT observed. The log redacts it to "<28 chars>",
+: so the string below is synthetic. Do not quote it as upstream wording.
+: See ai-docs/reports/gemini-openrouter-instream-400-20260917.md
+data: {"id":"gen-1789563247-…","object":"chat.completion.chunk","created":1789563247,"model":"unknown","provider":"Google AI Studio","choices":[{"index":0,"delta":{"role":"assistant","content":"Earlier content survives."},"finish_reason":null}]}
+
+data: {"id":"gen-1789563247-…","object":"chat.completion.chunk","created":1789563247,"model":"unknown","provider":"Google AI Studio","choices":[],"error":{"code":400,"message":"SYNTHETIC upstream message (real text unknown)","metadata":{"error_type":"invalid_request","provider_code":"400"}}}
diff --git a/packages/cli/src/test-fixtures/sse-responses/regression-openrouter-google-ai-studio-empty-choices-error.sse b/packages/cli/src/test-fixtures/sse-responses/regression-openrouter-google-ai-studio-empty-choices-error.sse
new file mode 100644
index 00000000..3a839fbb
--- /dev/null
+++ b/packages/cli/src/test-fixtures/sse-responses/regression-openrouter-google-ai-studio-empty-choices-error.sse
@@ -0,0 +1,8 @@
+: FRAME SHAPE observed 2026-09-16, ~/.claudish/logs/claudish_2026-09-16_12-52-57.log
+: route or@google/gemini-3.8-flash. HTTP was 200; the 400 rides inside the body.
+: The empty "choices" array is the load-bearing part — it is why every
+: choices[0] read returned undefined and the frame was dropped silently.
+: The error MESSAGE text is NOT observed. The log redacts it to "<28 chars>",
+: so the string below is synthetic. Do not quote it as upstream wording.
+: See ai-docs/reports/gemini-openrouter-instream-400-20260917.md
+data: {"id":"gen-1789563247-…","object":"chat.completion.chunk","created":1789563247,"model":"unknown","provider":"Google AI Studio","choices":[],"error":{"code":400,"message":"SYNTHETIC upstream message (real text unknown)","metadata":{"error_type":"invalid_request","provider_code":"400"}}}