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.tsindex 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 levelasync function getParser() {@@ -271,6 +323,83 @@ describe("OpenAI SSE → Claude SSE (createStreamingResponseHandler)", () => {// Should end with tool_useexpect(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.tsindex 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.ssenew file mode 100644index 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.ssenew file mode 100644index 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"}}}