cartethyia 2.7.3 → 2.7.5

package/src/protocol/request/messages.ts

@@ -2,6 +2,7 @@
  * Canonical → Claude Messages request builder.
  */
 import { allParts, type CanonicalRequest, type ContentPart } from "../canonical-model";
+import type { DialectPolicy } from "../translation/dialect/types";
 import { buildAnthropicThinkingPayload } from "../../protocol/reasoning";
 import { anthropicCacheControl } from "../../protocol/translation/cache-controls";
 import {
@@ -28,14 +29,17 @@ import {
 } from "../codecs";
 import { log } from "../../observability/logger";
 import { base64DecodedByteLength, clampImage } from "../image-clamp";
-import { clampReasoningEffort, claudeUsesAdaptiveThinking, LEVEL_TO_BUDGET, resolveSupportedReasoningEfforts } from "../../protocol/translation/thinking";
+import { LEVEL_TO_BUDGET } from "../../protocol/translation/thinking";
+import type { ThinkingConfig } from "../../protocol/translation/dialect/thinking-ladder";
+import { clampThinkingLevelForModel } from "../../protocol/translation/dialect/model-thinking";
+import { resolveThinkingForModel } from "../../protocol/translation/dialect/thinking-ladder";
 import { claudeResponseToEvents, parseClaudeSseStream } from "../response/messages";
 
 /**
  * Gateway default when the caller sent no max_tokens (Anthropic requires
  * the field). Explicit and warned at the call site — never silent.
  */
-export const ANTHROPIC_DEFAULT_MAX_TOKENS = WIRE_TOKEN_BOUNDS["messages"]?.defaultMaxTokens ?? 4_096;
+const ANTHROPIC_DEFAULT_MAX_TOKENS = WIRE_TOKEN_BOUNDS["messages"]?.defaultMaxTokens ?? 4_096;
 
 /** Anthropic Messages' documented base64-image media-type allowlist. */
 const ANTHROPIC_IMAGE_MEDIA_TYPES = new Set([
@@ -556,7 +560,13 @@ export function claudeFallbacksChain(
 
 export function canonicalToClaudeMessagesPayload(
   request: CanonicalRequest,
-  options: { isOAuth?: boolean; maxBytesOverride?: number } = {},
+  options: {
+    isOAuth?: boolean;
+    maxBytesOverride?: number;
+    dialectPolicy?: DialectPolicy;
+    thinking?: ThinkingConfig;
+    maxOutputTokens?: number;
+  } = {},
 ): ClaudeWireObject {
   const seen = new Map<string, number>();
   const idMap = new Map<string, string>();
@@ -653,7 +663,11 @@ export function canonicalToClaudeMessagesPayload(
   const normalizedControls = normalizeWireMaxTokens(request.generation_controls);
   const requestedMax = normalizedControls.max_tokens;
   const hasTools = (request.tools?.length ?? 0) > 0;
-  let maxTokens = resolveWireMaxTokens("messages", { max_tokens: requestedMax }, { hasTools, isOAuth }) ?? ANTHROPIC_DEFAULT_MAX_TOKENS;
+  let maxTokens = resolveWireMaxTokens("messages", { max_tokens: requestedMax }, {
+    hasTools,
+    isOAuth,
+    ...(options.maxOutputTokens === undefined ? {} : { maxOutputTokens: options.maxOutputTokens }),
+  }) ?? ANTHROPIC_DEFAULT_MAX_TOKENS;
   if (requestedMax === undefined) {
     log.warn("claude: max_tokens absent, defaulting", {
       max_tokens: maxTokens,
@@ -665,21 +679,32 @@ export function canonicalToClaudeMessagesPayload(
     });
   }
   const thinkingEnabled = isThinkingEnabled(request);
+  // Real ceilings (P2-12): an impossible thinking budget surfaces as a typed
+  // local 400 instead of an over-ceiling max_tokens that 400s opaquely upstream.
+  // Non-OAuth caps at the model's catalog output limit (when known) so the
+  // thinking guard can fire instead of shipping an over-catalog-limit
+  // `max_tokens`; OAuth keeps its own ceiling per the table.
+  const maxAllowed = isOAuth
+    ? WIRE_TOKEN_BOUNDS["messages"]?.oauthCeiling ?? Number.MAX_SAFE_INTEGER
+    : options.maxOutputTokens ?? Number.MAX_SAFE_INTEGER;
   if (thinkingEnabled && request.reasoning?.budget_tokens !== undefined) {
     maxTokens = ensureMaxTokensForThinking(
       maxTokens,
       request.reasoning.budget_tokens,
-      Number.MAX_SAFE_INTEGER,
+      maxAllowed,
     );
   }
   // Whether this model speaks adaptive thinking (`type: "adaptive"` +
   // `output_config.effort`) or budget thinking (`type: "enabled"` +
   // `budget_tokens`). The two generations reject each other's shape, so the
-  // choice is made from the model id, not from the caller's canonical intent —
-  // a chat/responses caller states only an effort, and a budget-era model
-  // answers the adaptive shape with "adaptive thinking is not supported on this
-  // model" (verified live: opus-4-5/sonnet-4-5/haiku-4-5).
-  const adaptiveThinking = claudeUsesAdaptiveThinking(request.model);
+  // choice is made from the resolved thinking config, not from the caller's
+  // canonical intent — a chat/responses caller states only an effort, and a
+  // budget-era model answers the adaptive shape with "adaptive thinking is not
+  // supported on this model" (verified live: opus-4-5/sonnet-4-5/haiku-4-5).
+  // When no config is supplied (direct-route callers), fall back to resolving
+  // it from the model/wire — the resolved `mode` IS the generation answer.
+  const resolvedThinking = options.thinking ?? resolveThinkingForModel(request.model, "", "messages");
+  const adaptiveThinking = resolvedThinking.mode === "anthropic-adaptive";
   let effectiveBudgetTokens = request.reasoning?.budget_tokens;
   // Derive a budget from the level whenever a budget-era model is asked to
   // reason by effort alone. The gate is NOT `isThinkingEnabled`: a chat/responses
@@ -699,7 +724,13 @@ export function canonicalToClaudeMessagesPayload(
   if (!adaptiveThinking && effectiveBudgetTokens !== undefined) {
     // The upstream requires the budget to stay below `max_tokens`; raise
     // max_tokens to leave room for the answer rather than let it 400.
-    maxTokens = ensureMaxTokensForThinking(maxTokens, effectiveBudgetTokens, Number.MAX_SAFE_INTEGER);
+    maxTokens = ensureMaxTokensForThinking(maxTokens, effectiveBudgetTokens, maxAllowed);
+  }
+  // Final clamp to the model's catalog output limit: thinking may have raised
+  // `max_tokens` (e.g. under an OAuth ceiling wider than the catalog limit), so
+  // the value that ships must never exceed what the model can actually emit.
+  if (options.maxOutputTokens !== undefined && maxTokens > options.maxOutputTokens) {
+    maxTokens = options.maxOutputTokens;
   }
   const payload: ClaudeWireObject = {
     model: request.model,
@@ -748,7 +779,8 @@ export function canonicalToClaudeMessagesPayload(
   }
   const parallelToolCallsDisabled =
     request.generation_controls.parallel_tool_calls === false;
-  if (rawToolChoice !== undefined || parallelToolCallsDisabled) {
+  const supportsToolChoice = options.dialectPolicy?.supportsToolChoice ?? true;
+  if (supportsToolChoice && (rawToolChoice !== undefined || parallelToolCallsDisabled)) {
     const baseChoice = rawToolChoice as Record<string, unknown> | undefined;
     const choice: Record<string, unknown> = baseChoice
       ? { ...baseChoice }
@@ -835,9 +867,9 @@ export function canonicalToClaudeMessagesPayload(
     // is NOT a wire field — display rides on `thinking.display` above.
     // Clamp to the model's published ladder exactly like the chat/Responses
     // codecs: an out-of-ladder tier is an upstream 4xx.
-    const effort = clampReasoningEffort(
+    const effort = clampThinkingLevelForModel(
+      resolvedThinking,
       request.reasoning.effort,
-      resolveSupportedReasoningEfforts(request.model, "messages"),
     );
     const taskBudget = request.reasoning.task_budget;
     // `output_config.effort` rides every generation: budget-era models accept it

package/src/protocol/request/responses.ts

@@ -7,10 +7,10 @@ import { markLatestBreakpoint } from "../../protocol/translation/cache-controls"
 import { pickWireSupportedControls } from "../../protocol/translation/capabilities";
 import { normalizeGenerationControls } from "../../protocol/translation/normalize";
 import { resolveWireMaxTokens } from "../../protocol/translation/quirks";
-import {
-  clampReasoningEffort,
-  resolveSupportedReasoningEfforts,
-} from "../../protocol/translation/thinking";
+import type { DialectPolicy } from "../../protocol/translation/dialect/types";
+import type { ThinkingConfig } from "../../protocol/translation/dialect/thinking-ladder";
+import { resolveThinkingForModel } from "../../protocol/translation/dialect/thinking-ladder";
+import { clampThinkingLevelForModel } from "../../protocol/translation/dialect/model-thinking";
 import { isClaudeBillingHeaderText, resolveImageSource, resolveOutputVerbosity } from "../codecs";
 import { resolvePromptCacheKey } from "../../providers/operations/session-resolution";
 import { reasoningEffortFromIntent } from "../../protocol/reasoning";
@@ -27,7 +27,7 @@ const RESPONSES_CACHEABLE_BLOCK_TYPES: ReadonlySet<string> = new Set([
 ]);
 
 /** Marks the latest stable input block with an explicit prompt-cache breakpoint. */
-export function markLatestResponsesCacheBreakpoint(input: Array<Record<string, unknown>>): void {
+function markLatestResponsesCacheBreakpoint(input: Array<Record<string, unknown>>): void {
   markLatestBreakpoint(input, {
     isInputItem: (item) =>
       item["type"] === "message" && (item["role"] === "user" || item["role"] === "developer"),
@@ -63,9 +63,13 @@ export function canonicalToResponsesPayload(
   options: {
     readonly supportsPromptCaching?: boolean;
     readonly promptCacheKey?: string;
+    readonly dialectPolicy?: DialectPolicy;
+    readonly thinking?: ThinkingConfig;
+    readonly maxOutputTokens?: number;
   } = {},
 ): Record<string, unknown> {
   const supportsPromptCaching = options.supportsPromptCaching ?? true;
+  const resolvedThinking = options.thinking ?? resolveThinkingForModel(request.model, "", "responses");
   const input: Array<Record<string, unknown>> = [];
   // `pending_safety_checks` have no canonical content-part representation, so
   // `parseResponsesRequest` retains them per-item in the scoped item-metadata
@@ -317,10 +321,7 @@ export function canonicalToResponsesPayload(
     // this wire. Codex already derives its tier this way.
     const requestedEffort = reasoningEffortFromIntent(request.reasoning);
     if (requestedEffort !== undefined) {
-      const effort = clampReasoningEffort(
-        requestedEffort,
-        resolveSupportedReasoningEfforts(request.model, "responses"),
-      );
+      const effort = clampThinkingLevelForModel(resolvedThinking, requestedEffort);
       if (effort !== undefined) reasoning.effort = effort;
     }
     if (request.reasoning.mode !== undefined) reasoning.mode = request.reasoning.mode;
@@ -328,6 +329,12 @@ export function canonicalToResponsesPayload(
     if (request.reasoning.summary_mode !== undefined)
       reasoning.summary = request.reasoning.summary_mode;
     else if (request.reasoning.summary !== undefined) reasoning.summary = request.reasoning.summary;
+    else if (requestedEffort !== undefined) reasoning.summary = "detailed";
+    // When the caller asked for reasoning effort but expressed no summary
+    // preference, request a detailed summary. Upstreams (GitHub Copilot's
+    // gpt-6-luna etc.) only stream `reasoning_summary_text` when the request
+    // asks for it — without this the reasoning is present on the wire yet
+    // never reaches the client.
     if (Object.keys(reasoning).length > 0) payload.reasoning = reasoning;
   }
   const picked = pickWireSupportedControls(normalizeGenerationControls(request.generation_controls), "responses");
@@ -338,7 +345,9 @@ export function canonicalToResponsesPayload(
   // Resolved unconditionally so the wire's `defaultMaxTokens` applies: an
   // omitted limit must reach the upstream as a real number, not as an absent
   // field (see the worked "wkwk" case in the WIRE_TOKEN_BOUNDS comment).
-  const bounded = resolveWireMaxTokens("responses", { max_tokens: requested });
+  const bounded = resolveWireMaxTokens("responses", { max_tokens: requested }, {
+    ...(options.maxOutputTokens === undefined ? {} : { maxOutputTokens: options.maxOutputTokens }),
+  });
   if (bounded !== undefined) picked["max_output_tokens"] = bounded;
   Object.assign(payload, picked);
   // Responses top-level params carried as `extension:responses.<field>` and

package/src/protocol/response/chat.ts

@@ -9,13 +9,15 @@ import { gatewayErrorFromStreamError } from "../stream-error-frames";
 import { mergeResponsesUsage } from "./responses";
 import { usageFromProvider, readReasoningText } from "../../providers/provider-usage";
 import { createToolEmitLedger } from "../tool-identity";
-import { MimoThinkSplitter, stripThinkingTags } from "../../providers/integrations/xiaomi-mimo/think-stream";
-import { DsmlToolCallParser, parseDsmlToolCalls } from "./dsml";
+import { ThinkSplitter, stripThinkingTags } from "../think-split";
+import { DsmlStreamParser, parseDsmlToolCalls } from "../dsml";
 import {
   OmpToolCallMarkupParser,
   parseOmpToolCallMarkup,
   type OmpTextToolCall,
 } from "./omp-tool-call-markup";
+import type { DialectPolicy } from "../translation/dialect/types";
+import { QwenToolCallScanner } from "../translation/dialect/qwen";
 
 
 export function mapChatStopReason(
@@ -83,11 +85,16 @@ export function parseChatResponseToEvents(
     const contentWithoutMarkup = recoveredMarkup?.text ?? content;
     const recovered =
       typeof contentWithoutMarkup === "string"
-        ? parseDsmlToolCalls(contentWithoutMarkup, declaredToolNames)
+        ? parseDsmlToolCalls(contentWithoutMarkup, { allowedNames: declaredToolNames })
         : undefined;
-    const visible = recovered === undefined ? contentWithoutMarkup : recovered.text;
+    const visible =
+      recovered === undefined
+        ? contentWithoutMarkup
+        : "text" in recovered
+          ? recovered.text
+          : recovered.clean;
     if (typeof visible === "string" && visible.includes("<think")) {
-      const think = new MimoThinkSplitter();
+      const think = new ThinkSplitter();
       const split = think.push(visible);
       const rest = think.flush();
       const reasoning = `${split.reasoning}${rest.reasoning}`;
@@ -237,10 +244,12 @@ export async function* decodeChatSseStream(
   body: ReadableStream<Uint8Array>,
   request: CanonicalRequest,
   signal?: AbortSignal,
+  options?: { readonly dialectPolicy?: DialectPolicy },
 ): AsyncIterable<CanonicalEvent> {
   let seq = 1;
   let finishReason: unknown;
   let rawUsage: Record<string, unknown> | undefined;
+  const inbandDialect = options?.dialectPolicy?.inband;
   // Last seen tool-call id (and name) per wire index. OpenAI streams the id
   // (and name) only on the first fragment of each call; later fragments carry
   // just `function.arguments`. Without this memory every continuation fragment
@@ -257,11 +266,11 @@ export async function* decodeChatSseStream(
   const recoveredMarkupCalls: OmpTextToolCall[] = [];
   // Single emission ledger: one entry per logical call.
   const ledger = createToolEmitLedger();
-  const think = new MimoThinkSplitter();
+  const think = new ThinkSplitter();
   // Separate splitter for the reasoning channel: `reasoning_content` is its own
   // stream, and interleaving it into the answer splitter would let a tag in one
   // channel swallow the other's text.
-  const reasoningThink = new MimoThinkSplitter();
+  const reasoningThink = new ThinkSplitter();
   const declaredToolNames = declaredToolNamesForRequest(request);
   const callableToolNames = callableToolNamesForRequest(request);
   const contentMarkup =
@@ -269,7 +278,13 @@ export async function* decodeChatSseStream(
   const reasoningMarkup =
     (request.tools?.length ?? 0) > 0 ? new OmpToolCallMarkupParser(declaredToolNames) : undefined;
   const dsmlMarkup =
-    (request.tools?.length ?? 0) > 0 ? new DsmlToolCallParser(declaredToolNames) : undefined;
+    (request.tools?.length ?? 0) > 0 && inbandDialect !== "qwen"
+      ? new DsmlStreamParser({ allowedNames: declaredToolNames })
+      : undefined;
+  const qwenMarkup =
+    (request.tools?.length ?? 0) > 0 && inbandDialect === "qwen"
+      ? new QwenToolCallScanner(declaredToolNames)
+      : undefined;
   yield {
     type: "response_start",
     sequence_number: seq++,
@@ -315,7 +330,7 @@ export async function* decodeChatSseStream(
           const raw = delta["content"] as string;
           const markup = contentMarkup?.push(raw);
           if (markup !== undefined) recoveredMarkupCalls.push(...markup.calls);
-          const recovered = dsmlMarkup?.push(markup?.text ?? raw);
+          const recovered = (qwenMarkup ?? dsmlMarkup)?.push(markup?.text ?? raw);
           const visible = recovered?.text ?? markup?.text ?? raw;
           const split = think.push(visible);
           if (split.reasoning.length > 0) {
@@ -472,8 +487,8 @@ export async function* decodeChatSseStream(
         "platform_unavailable",
         502,
         error instanceof Error
-          ? `Malformed SSE event: ${error.message}`
-          : "Malformed SSE event",
+          ? `Malformed SSE event: ${error.message} (request {requestId}). The upstream sent something we can't read — retry 🌙`
+          : `Malformed SSE event (request {requestId}). The upstream sent something we can't read — retry 🌙`,
         {},
         "upstream",
       );
@@ -500,7 +515,7 @@ export async function* decodeChatSseStream(
       }
     }
   }
-  const dsmlMarkupTail = dsmlMarkup?.flush();
+  const dsmlMarkupTail = (qwenMarkup ?? dsmlMarkup)?.flush();
   if (dsmlMarkupTail !== undefined) {
     if (dsmlMarkupTail.text.length > 0) {
       const split = think.push(dsmlMarkupTail.text);

package/src/protocol/response/codex.ts

@@ -15,7 +15,7 @@ import { usageFromProvider, readResponsesReasoningDelta } from '../../providers/
 import { canonicalTerminal, decodeCodexToolCallId, isRecord, readOutputIndex } from '../codecs';
 import { gatewayErrorFromStreamError } from '../stream-error-frames';
 
-export function mapCodexStopReason(
+function mapCodexStopReason(
   status: unknown,
   hasToolCall: boolean,
   endTurn?: unknown,
@@ -364,7 +364,7 @@ export class CodexStreamFrameProcessor {
       throw new GatewayError(
         "tool_call_loop_detected",
         502,
-        "Codex whitespace-loop guard tripped: tool call emitted only whitespace argument deltas past the safety threshold",
+        "Codex whitespace-loop guard tripped (request {requestId}): tool call emitted only whitespace argument deltas past the safety threshold. Caught in a loop — breaking the cycle 🔁",
         { call_key: key, event_count: next.count, char_count: next.chars },
       );
     }

package/src/protocol/response/gemini.ts

@@ -124,7 +124,7 @@ export function decodeGeminiStreamEvent(
     throw new GatewayError(
       "platform_unavailable",
       502,
-      error instanceof Error ? `Malformed SSE event: ${error.message}` : "Malformed SSE event",
+      error instanceof Error ? `Malformed SSE event: ${error.message} (request {requestId}). The upstream sent something we can't read — retry 🌙` : `Malformed SSE event (request {requestId}). The upstream sent something we can't read — retry 🌙`,
       {},
       "upstream",
     );

package/src/protocol/response/messages.ts

@@ -51,7 +51,7 @@ export function parseClaudeContent(value: unknown, isOAuth = false): ContentPart
       throw new GatewayError(
         "platform_unavailable",
         502,
-        "Claude response tool_use is missing id or name",
+        "Claude response tool_use is missing id or name (request {requestId}). The upstream came back empty-handed — retry 🌙",
         {},
         "upstream",
       );
@@ -69,7 +69,7 @@ export function parseClaudeContent(value: unknown, isOAuth = false): ContentPart
       throw new GatewayError(
         "platform_unavailable",
         502,
-        "Claude response tool_result is missing tool_use_id",
+        "Claude response tool_result is missing tool_use_id (request {requestId}). The upstream came back empty-handed — retry 🌙",
         {},
         "upstream",
       );
@@ -185,7 +185,7 @@ export function withClaudeFallbackSignal(
   return { ...(stopDetails ?? {}), [CANONICAL_SERVED_BY_FALLBACK_KEY]: true };
 }
 
-export function eventContent(
+function eventContent(
   content: readonly ContentPart[],
   sequence: number,
 ): { events: CanonicalEvent[]; sequence: number } {
@@ -467,7 +467,7 @@ export async function* parseClaudeSseStream(
       throw new GatewayError(
         "platform_unavailable",
         502,
-        "Malformed Claude SSE event",
+        "Malformed Claude SSE event (request {requestId}). The upstream sent something we can't read — retry 🌙",
         {},
         "upstream",
       );
@@ -476,7 +476,7 @@ export async function* parseClaudeSseStream(
       throw new GatewayError(
         "platform_unavailable",
         502,
-        "Invalid Claude SSE event",
+        "Invalid Claude SSE event (request {requestId}). The upstream sent something we can't read — retry 🌙",
         {},
         "upstream",
       );
@@ -492,7 +492,7 @@ export async function* parseClaudeSseStream(
     throw new GatewayError(
       "platform_unavailable",
       502,
-      "Claude stream ended before message_stop",
+      "Claude stream ended before message_stop (request {requestId}). The upstream came back empty-handed — retry 🌙",
       {},
       "upstream",
     );

package/src/protocol/response/omp-tool-call-markup.ts

@@ -14,7 +14,7 @@ export interface OmpTextToolCall {
 }
 
 /** Text remaining after complete tool envelopes are removed. */
-export interface OmpTextToolCallResult {
+interface OmpTextToolCallResult {
   readonly text: string;
   readonly calls: readonly OmpTextToolCall[];
 }

package/src/protocol/response/responses.ts

@@ -10,7 +10,7 @@ import { gatewayErrorFromStreamError } from "../stream-error-frames";
 import { usageFromProvider, readResponsesReasoningDelta } from "../../providers/provider-usage";
 import { createToolEmitLedger } from "../tool-identity";
 
-export function mapResponsesStopReason(
+function mapResponsesStopReason(
   status: unknown,
   hasToolCall: boolean,
 ): "stop" | "length" | "tool_use" | "error" | undefined {
@@ -336,8 +336,8 @@ export async function* decodeResponsesSseStream(
         "platform_unavailable",
         502,
         error instanceof Error
-          ? `Malformed SSE event: ${error.message}`
-          : "Malformed SSE event",
+          ? `Malformed SSE event: ${error.message} (request {requestId}). The upstream sent something we can't read — retry 🌙`
+          : `Malformed SSE event (request {requestId}). The upstream sent something we can't read — retry 🌙`,
         {},
         "upstream",
       );

package/src/protocol/sse-decoder.ts

@@ -31,7 +31,7 @@ export interface SseEvent {
   readonly data: string;
 }
 
-export interface SseDecodeOptions {
+interface SseDecodeOptions {
   /**
    * Max UTF-16 length of a single line; default equals `maxEventBytes`.
    *
@@ -51,20 +51,57 @@ export interface SseDecodeOptions {
 
 const DEFAULT_MAX_EVENT_BYTES = 4 * 1024 * 1024;
 
+/**
+ * True when the accumulated data is a complete JSON value.
+ *
+ * Uses a bracket-depth scan that skips string contents (including escapes), so
+ * an inline `\n` or `\n\n` inside a string does not count as a structural
+ * terminator. A non-JSON payload (`[DONE]`, plain text) has depth 0 and reads
+ * as complete, so blank-line boundaries stay working for ordinary streams.
+ */
+function isCompleteJsonValue(data: string): boolean {
+  if (data.length === 0) return true;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < data.length; i += 1) {
+    const ch = data[i]!;
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+    } else if (ch === "{" || ch === "[") {
+      depth += 1;
+    } else if (ch === "}" || ch === "]") {
+      depth -= 1;
+      if (depth < 0) return true; // trailing close: not a partial JSON prefix
+    }
+  }
+  return depth <= 0;
+}
+
 // A corrupt SSE stream is an upstream protocol failure, not a client mistake:
 // labelling it `invalid_request` told the client its request was wrong and
 // invited a retry of the identical request against a broken upstream. The
 // `upstream` origin keeps the public envelope from prefixing it
 // a gateway-branded message, which blamed the gateway for the provider's bytes.
 function oversized(what: string): GatewayError {
-  return new GatewayError("platform_unavailable", 502, `SSE ${what} exceeds size bound`, {}, "upstream");
+  return new GatewayError("platform_unavailable", 502, `SSE ${what} exceeds size bound (request {requestId}). The upstream sent more than we can hold — retry 🌙`, {}, "upstream");
 }
 
 export async function* decodeSseEvents(
   body: ReadableStream<Uint8Array> | null,
   opts: SseDecodeOptions = {},
 ): AsyncIterable<SseEvent> {
-  if (body === null) throw new GatewayError("platform_unavailable", 502, "SSE response has no body", {}, "upstream");
+  if (body === null) throw new GatewayError("platform_unavailable", 502, "SSE response has no body (request {requestId}). The upstream came back empty-handed — retry 🌙", {}, "upstream");
   const maxEventBytes = opts.maxEventBytes ?? DEFAULT_MAX_EVENT_BYTES;
   const maxLineBytes = opts.maxLineBytes ?? maxEventBytes;
   const signal = opts.signal;
@@ -156,6 +193,18 @@ export async function* decodeSseEvents(
     }
     if (line.startsWith("id:") || line.startsWith("retry:")) return;
     if (line.trim() === "") {
+      // A blank line is an SSE event boundary — but only when the payload
+      // accumulated so far is already a complete value. Some upstreams
+      // (Qoder IDE /model/v1) emit JSON that contains literal blank lines
+      // inside a string (`raw_usage` carries keys like
+      // `"data_policy_preferre\n\nnd_count"`). Treating that blank line as a
+      // boundary splits the JSON, leaves a dangling continuation, and throws
+      // "Malformed SSE line". When the open data is not yet a complete JSON
+      // value, append the blank line as a continuation instead.
+      if (dataLines.length > 0 && !isCompleteJsonValue(dataLines.join("\n"))) {
+        dataLines.push("");
+        return;
+      }
       yield* dispatchEvent();
       return;
     }
@@ -163,7 +212,18 @@ export async function* decodeSseEvents(
     // not 502 the request: only `event:`/`data:` carry payload, the rest is
     // heartbeat/metadata. Unknown colon-prefixed fields are ignored.
     if (/^[a-zA-Z0-9_-]+:/.test(line)) return;
-    throw new GatewayError("platform_unavailable", 502, "Malformed SSE line", {}, "upstream");
+    // Some vendors (Qoder IDE /model/v1) emit a single `data:` event whose JSON
+    // payload contains literal newlines, so the event arrives as several lines:
+    // the first has the `data:` prefix, the rest are bare continuations. Treat
+    // a bare line as a continuation of the open `data:` event rather than a
+    // malformed stream. A bare line with no open data is still an error.
+    if (dataLines.length > 0) {
+      dataLines.push(line);
+      eventBytes += line.length;
+      if (eventBytes > maxEventBytes) throw oversized("event");
+      return;
+    }
+    throw new GatewayError("platform_unavailable", 502, "Malformed SSE line (request {requestId}). The upstream sent something we can't read — retry 🌙", {}, "upstream");
   }
 
   try {

package/src/protocol/stop-reason.ts

@@ -35,14 +35,14 @@ const WIRE_STOP_REASONS = {
   },
 } satisfies Record<string, Record<CanonicalStopReason, string>>;
 
-export type StopReasonWireFamily = keyof typeof WIRE_STOP_REASONS;
+type StopReasonWireFamily = keyof typeof WIRE_STOP_REASONS;
 
 /**
  * Maps a canonical stop reason onto `wire`'s vocabulary, falling back when the
  * terminal carried none: Chat has no null finish_reason and defaults to `stop`,
  * while Messages omits `stop_reason` entirely.
  */
-export function canonicalStopReasonToWire(
+function canonicalStopReasonToWire(
   wire: StopReasonWireFamily,
   reason: CanonicalStopReason | undefined,
   fallback: string,