@bitkyc08/opencodex 2.19.0 → 2.20.0

package/src/routing/capability.ts

@@ -12,6 +12,7 @@
 
 import type { OcxConfig } from "../types";
 import { isCanonicalOpenAiForwardProvider, OPENAI_CODEX_PROVIDER_ID } from "../providers/openai-tiers";
+import { serviceTierSupportForModel } from "../providers/service-tier";
 import { applyProviderContextCap, providerContextCap } from "../providers/context-cap";
 import { PROVIDER_REGISTRY } from "../providers/registry";
 import {
@@ -185,8 +186,9 @@ export function candidateCapabilityEvidence(
     ?? catalogRow?.reasoningEfforts
     ?? (isNative ? nativeReasoningEfforts(modelId) : undefined);
 
-  const tierSupport = provider?.supportsServiceTier
-    ?? registryEntry?.supportsServiceTier;
+  const tierSupport = provider
+    ? serviceTierSupportForModel(provider, modelId, providerName)
+    : registryEntry ? serviceTierSupportForModel(registryEntry, modelId, providerName) : undefined;
   const serviceTier = tierSupport === true
     ? "supported"
     : tierSupport === false ? "unsupported" : "unknown";

package/src/routing/compatibility/behavior.ts

@@ -1,5 +1,6 @@
 import type { OcxConfig, OcxProviderConfig } from "../../types";
 import { PROVIDER_REGISTRY, type ProviderAuthKind } from "../../providers/registry";
+import { serviceTierSupportForModel } from "../../providers/service-tier";
 import { localFingerprint } from "../../lab/digest";
 import type { LabBehaviorSource, LabBehaviorValues } from "../../lab/live/types";
 
@@ -116,7 +117,10 @@ export function resolveProductionBehaviorValues(
     "auth.mode": behaviorRow("provider_config", authMode),
     "auth.transport": behaviorRow("provider_config", authTransportFor(effective, adapter, authMode)),
     "responses.stateful": behaviorRow("provider_config", effective.statelessResponses !== true),
-    "responses.serviceTier": behaviorRow("provider_config", effective.supportsServiceTier ?? null),
+    "responses.serviceTier": behaviorRow(
+      "provider_config",
+      serviceTierSupportForModel(effective, modelId, providerName) ?? null,
+    ),
     "responses.snapshotRepair": behaviorRow("provider_config", effective.responsesSnapshotRepair === true),
     "responses.itemIdRepair": behaviorRow("provider_config", effective.responsesItemIdRepair ?? null),
     "limits.contextWindow": behaviorRow(

package/src/server/adapter-resolve.ts

@@ -1,12 +1,4 @@
-import { createAnthropicAdapter } from "../adapters/anthropic";
-import { createAzureAdapter } from "../adapters/azure";
-import { createCursorAdapter } from "../adapters/cursor";
-import { createGoogleAdapter } from "../adapters/google";
-import { createKiroAdapter } from "../adapters/kiro";
-import { createMimoFreeAdapter } from "../adapters/mimo-free";
-import { createOpenAIChatAdapter } from "../adapters/openai-chat";
-import { createCommandCodeAdapter } from "../adapters/command-code";
-import { createResponsesPassthroughAdapter } from "../adapters/openai-responses";
+import { createRegisteredAdapter } from "../adapters/registry";
 import type { OcxProviderConfig } from "../types";
 import { isWirePinnedModel, MODEL_ADAPTER_OVERRIDE_ALLOWED, pinnedWireAdapter } from "../types";
 import { isCanonicalOpenAiForwardProvider } from "../providers/openai-tiers";
@@ -57,27 +49,5 @@ export function resolveWireProtocolOverride(
 
 /** Build the provider adapter for a resolved provider config. */
 export function resolveAdapter(providerConfig: OcxProviderConfig, cacheRetention?: "none" | "short" | "long") {
-  switch (providerConfig.adapter) {
-    case "command-code":
-      return createCommandCodeAdapter(providerConfig);
-    case "openai-chat":
-      return createOpenAIChatAdapter(providerConfig);
-    case "anthropic":
-      return createAnthropicAdapter(providerConfig, cacheRetention);
-    case "openai-responses":
-      return createResponsesPassthroughAdapter(providerConfig);
-    case "google":
-      return createGoogleAdapter(providerConfig);
-    case "kiro":
-      return createKiroAdapter(providerConfig);
-    case "azure":
-    case "azure-openai":
-      return createAzureAdapter(providerConfig);
-    case "cursor":
-      return createCursorAdapter(providerConfig);
-    case "mimo-free":
-      return createMimoFreeAdapter(providerConfig);
-    default:
-      throw new Error(`Unknown adapter: ${providerConfig.adapter}`);
-  }
+  return createRegisteredAdapter(providerConfig, { cacheRetention });
 }

package/src/server/auth-cors.ts

@@ -14,6 +14,7 @@ import {
   providerModelCostsConfigError,
   reasoningSummaryDeliveryRecordConfigError,
   retryOn429PolicyConfigError,
+  requestPacingConfigError,
   sanitizeModelCostsForDisplay,
 } from "../config";
 import { providerDestinationConfigError } from "../lib/destination-policy";
@@ -453,6 +454,8 @@ export function providerManagementConfigError(name: unknown, provider: unknown):
     // modelCosts is a user-owned display overlay, not part of the canonical
     // forward seed; it is validated separately below (providerModelCostsConfigError).
     delete canonicalCandidate.modelCosts;
+    // requestPacing is a user-owned transport overlay, not part of the canonical seed.
+    delete canonicalCandidate.requestPacing;
     const canonical = seed && sameCanonicalProviderSeed(canonicalCandidate, seed);
     if (!canonical) {
       return `provider ${name} must equal the canonical built-in provider seed`;
@@ -477,6 +480,10 @@ export function providerManagementConfigError(name: unknown, provider: unknown):
     // it before it reaches the management API response.
     return `provider ${JSON.stringify(redactSecretString(name))} ${retryOn429Error}`;
   }
+  const requestPacingError = requestPacingConfigError(raw.requestPacing);
+  if (requestPacingError) {
+    return `provider ${JSON.stringify(redactSecretString(name))} ${requestPacingError}`;
+  }
   const modelCostsError = providerModelCostsConfigError(raw.modelCosts);
   if (modelCostsError) {
     // The provider name is caller-controlled and can be token-shaped; redact and JSON-escape
@@ -580,6 +587,7 @@ export function safeConfigDTO(config: OcxConfig): unknown {
       "keyOptional",
       "freeTier",
       "liveModels",
+      "requestPacing",
       "models",
       "contextWindow",
       "modelContextWindows",

package/src/server/chat-completions.ts

@@ -2,11 +2,15 @@
  * OpenAI Chat Completions inbound (/v1/chat/completions) for GitHub Copilot App
  * and other OpenAI-compatible clients.
  *
- * Translate-and-replay: Chat Completions body -> /v1/responses via handleResponses,
- * then bridge the Responses output back to Chat Completions SSE/JSON.
+ * Ordinary openai-chat routes send directly on the Chat Completions wire. Routes
+ * that need Responses-only behavior keep the Chat -> Responses -> Chat bridge.
  */
 import { FORWARD_HEADERS } from "../adapters/openai-responses";
-import { ChatCompletionsRequestError, chatCompletionsToResponsesBody } from "../chat/inbound";
+import {
+  assertChatCompletionsRoutingBody,
+  ChatCompletionsRequestError,
+  chatCompletionsToResponsesBody,
+} from "../chat/inbound";
 import {
   chatCompletionsErrorResponse,
   collectChatCompletion,
@@ -40,6 +44,7 @@ import {
   isTranslatorBudgetExceededError,
   type TranslatorBudget,
 } from "../lib/translator-budget";
+import { handleNativeChatCompletions, isNativeChatRouteEligible } from "./chat-native";
 
 type Rec = Record<string, unknown>;
 
@@ -80,11 +85,11 @@ async function handleChatCompletionsWithBudget(
   translatorBudget: TranslatorBudget,
   logIds?: { requestId: string; start: number; turnAdmissionLease?: AdmissionLease },
 ): Promise<Response> {
-  let chatBody: unknown;
-  let internalBody: Rec;
+  let chatBody: Rec;
   try {
-    chatBody = await readChatBody(req, translatorBudget);
-    internalBody = chatCompletionsToResponsesBody(chatBody);
+    const rawBody = await readChatBody(req, translatorBudget);
+    assertChatCompletionsRoutingBody(rawBody);
+    chatBody = rawBody;
   } catch (err) {
     const overflow = isTranslatorBudgetExceededError(err);
     const status = overflow ? 413 : err instanceof ChatCompletionsRequestError ? 400 : 500;
@@ -97,20 +102,17 @@ async function handleChatCompletionsWithBudget(
     );
   }
 
-  const requestedModel = (chatBody as Rec).model as string;
-  const stream = internalBody.stream === true;
+  const requestedModel = chatBody.model as string;
+  const stream = chatBody.stream === true;
   // Best-effort Grok attribution: the managed fence stamps this header on every model
   // it registers (extra_headers, sent verbatim by upstream Grok). Dashboard usage
   // bucketing only — never an auth or billing signal.
   if (req.headers.get("x-opencodex-grok") === "1") logCtx.surface = "grok";
-  // Routed adapters only support streamed turns; always stream internally and fold
-  // for non-streaming clients.
-  internalBody.stream = true;
-
-  let nativeRoute = false;
   let directRoute = false;
+  let settledRoute: ReturnType<typeof routeModel> | null = null;
+  let chatNativeRoute: ReturnType<typeof routeModel> | null = null;
   try {
-    const route = routeModel(config, internalBody.model as string, evidenceFromBody(internalBody));
+    const route = routeModel(config, requestedModel, evidenceFromBody(chatBody));
     // Settle the wire once so every branch below reads the adapter this model will
     // actually use, not the provider-wide default (#404).
     route.provider = resolveWireProtocolOverride(route.providerName, route.modelId, route.provider, "chat");
@@ -119,33 +121,17 @@ async function handleChatCompletionsWithBudget(
     logCtx.requestedModel = requestedModel;
     logCtx.provider = route.providerName;
     logCtx.routeDecision = route.routeDecision;
+    settledRoute = route;
     if (route.provider.adapter === "openai-responses") {
-      nativeRoute = true;
       directRoute = route.codexAccountMode === "direct";
-      // ChatGPT backend rejects store:true and unsupported sampling knobs.
-      internalBody.store = false;
-      delete internalBody.max_output_tokens;
-      delete internalBody.temperature;
-      delete internalBody.top_p;
-      delete internalBody.stop;
-      delete internalBody.user;
-    } else if (internalBody.store === undefined) {
-      internalBody.store = false;
     }
     if (route.provider.adapter === "cursor" || route.provider.adapter === "kiro") {
-      const raw = chatBody as Rec;
       const parts: string[] = [];
-      if (raw.messages !== undefined) parts.push(JSON.stringify(raw.messages));
-      if (raw.tools !== undefined) parts.push(JSON.stringify(raw.tools));
+      if (chatBody.messages !== undefined) parts.push(JSON.stringify(chatBody.messages));
+      if (chatBody.tools !== undefined) parts.push(JSON.stringify(chatBody.tools));
       logCtx.usageLogInputTokens = Math.max(1, estimateTokens(parts.join("\n"), requestedModel));
     }
-    if (internalBody.reasoning !== undefined) {
-      const { stripEmptyLadderEffort, supportedLadderFor } = await import("./effort-policy");
-      const ladder = supportedLadderFor({ provider: route.provider, modelId: route.modelId });
-      const next = stripEmptyLadderEffort(internalBody.reasoning, ladder);
-      if (next === undefined) delete internalBody.reasoning;
-      else internalBody.reasoning = next;
-    }
+    if (isNativeChatRouteEligible(route, chatBody)) chatNativeRoute = route;
   } catch (err) {
     if (err instanceof NoEligiblePolicyCandidateError) {
       logCtx.routeDecision = err.trace;
@@ -154,7 +140,59 @@ async function handleChatCompletionsWithBudget(
     }
     /* unknown model: let handleResponses shape the 404 */
   }
-  void nativeRoute;
+
+  if (chatNativeRoute) {
+    return handleNativeChatCompletions({
+      req,
+      config,
+      logCtx,
+      ...(logIds ? { logIds } : {}),
+      route: chatNativeRoute,
+      chatBody,
+      requestedModel,
+      requestedStream: stream,
+      translatorBudget,
+    });
+  }
+
+  let internalBody: Rec;
+  try {
+    // Validate the full Chat boundary after routing. Native Chat keeps `chatBody` as
+    // its wire source; this Responses projection is used only by the fallback path.
+    internalBody = chatCompletionsToResponsesBody(chatBody);
+  } catch (err) {
+    const overflow = isTranslatorBudgetExceededError(err);
+    const status = overflow ? 413 : err instanceof ChatCompletionsRequestError ? 400 : 500;
+    if (logIds) addFinalRequestLog(logIds.requestId, logIds.start, logCtx, status, { closeReason: "non_stream" });
+    return chatCompletionsErrorResponse(
+      status,
+      overflow ? "request translation buffer exceeded the safe limit" : err instanceof Error ? err.message : String(err),
+      overflow ? "request_too_large" : undefined,
+      overflow ? "translation_buffer_limit" : undefined,
+    );
+  }
+
+  // Routed adapters only support streamed turns; always stream internally and fold
+  // for non-streaming clients. Native Chat uses the caller's original stream bit.
+  internalBody.stream = true;
+  if (settledRoute?.provider.adapter === "openai-responses") {
+    // ChatGPT backend rejects store:true and unsupported sampling knobs.
+    internalBody.store = false;
+    delete internalBody.max_output_tokens;
+    delete internalBody.temperature;
+    delete internalBody.top_p;
+    delete internalBody.stop;
+    delete internalBody.user;
+  } else if (internalBody.store === undefined) {
+    internalBody.store = false;
+  }
+  if (settledRoute && internalBody.reasoning !== undefined) {
+    const { stripEmptyLadderEffort, supportedLadderFor } = await import("./effort-policy");
+    const ladder = supportedLadderFor({ provider: settledRoute.provider, modelId: settledRoute.modelId });
+    const next = stripEmptyLadderEffort(internalBody.reasoning, ladder);
+    if (next === undefined) delete internalBody.reasoning;
+    else internalBody.reasoning = next;
+  }
 
   const headers = new Headers({ "content-type": "application/json" });
   for (const name of FORWARD_HEADERS) {

package/src/server/chat-native-sse.ts

@@ -0,0 +1,331 @@
+import { chatCompletionsErrorBody } from "../chat/outbound";
+import { classifyError, CYBER_POLICY_ERROR_CODE, isCyberPolicyCode } from "../lib/errors";
+import { redactSecretString } from "../lib/redact";
+import {
+  isTranslatorBudgetExceededError,
+  TRANSLATOR_MAX_SSE_EVENT_BYTES,
+  type TranslatorBudget,
+} from "../lib/translator-budget";
+import type { OcxUsage } from "../types";
+import { nextSseBlock, replaceSseDataPayload, sseDataPayload } from "./sse-payload-rewrite";
+
+type Rec = Record<string, unknown>;
+
+function isRec(value: unknown): value is Rec {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export function usageFromChat(value: unknown): OcxUsage | undefined {
+  if (!isRec(value)) return undefined;
+  const prompt = typeof value.prompt_tokens === "number" ? value.prompt_tokens : undefined;
+  const completion = typeof value.completion_tokens === "number" ? value.completion_tokens : undefined;
+  if (prompt === undefined && completion === undefined) return undefined;
+  const promptDetails = isRec(value.prompt_tokens_details) ? value.prompt_tokens_details : undefined;
+  const completionDetails = isRec(value.completion_tokens_details) ? value.completion_tokens_details : undefined;
+  return {
+    inputTokens: prompt ?? 0,
+    outputTokens: completion ?? 0,
+    ...(typeof promptDetails?.cached_tokens === "number" ? { cachedInputTokens: promptDetails.cached_tokens } : {}),
+    ...(typeof completionDetails?.reasoning_tokens === "number"
+      ? { reasoningOutputTokens: completionDetails.reasoning_tokens }
+      : {}),
+  };
+}
+
+export function structuredError(value: unknown): {
+  message: string;
+  type?: string;
+  code?: string | null;
+  status?: number;
+} | null {
+  if (!isRec(value) || value.error === undefined || value.error === null) return null;
+  const error = value.error;
+  if (typeof error === "string") return { message: redactSecretString(error) };
+  if (!isRec(error)) return { message: "upstream error" };
+  const rawMessage = typeof error.message === "string" ? error.message : "upstream error";
+  return {
+    message: redactSecretString(rawMessage),
+    ...(typeof error.type === "string" ? { type: error.type } : {}),
+    ...(error.code === null || typeof error.code === "string" ? { code: error.code } : {}),
+    ...(typeof error.status === "number" && Number.isInteger(error.status) ? { status: error.status } : {}),
+  };
+}
+
+function normalizedChunk(value: Rec, requestedModel: string): Rec {
+  return {
+    ...value,
+    id: typeof value.id === "string" ? value.id : `chatcmpl-${crypto.randomUUID().replace(/-/g, "").slice(0, 24)}`,
+    object: "chat.completion.chunk",
+    created: typeof value.created === "number" ? value.created : Math.floor(Date.now() / 1000),
+    model: requestedModel,
+  };
+}
+
+export function jsonCompletionSse(value: Rec, requestedModel: string): string {
+  const id = typeof value.id === "string" ? value.id : `chatcmpl-${crypto.randomUUID().replace(/-/g, "").slice(0, 24)}`;
+  const created = typeof value.created === "number" ? value.created : Math.floor(Date.now() / 1000);
+  const model = requestedModel;
+  const choices = Array.isArray(value.choices) ? value.choices : [];
+  const choice = isRec(choices[0]) ? choices[0] : {};
+  const message = isRec(choice.message) ? choice.message : {};
+  const frames: Rec[] = [{
+    id,
+    object: "chat.completion.chunk",
+    created,
+    model,
+    choices: [{ index: 0, delta: { role: "assistant", content: "" }, finish_reason: null }],
+  }];
+  const delta: Rec = {};
+  if (typeof message.content === "string" && message.content.length > 0) delta.content = message.content;
+  if (typeof message.reasoning_content === "string" && message.reasoning_content.length > 0) {
+    delta.reasoning_content = message.reasoning_content;
+  }
+  if (Array.isArray(message.tool_calls) && message.tool_calls.length > 0) {
+    delta.tool_calls = message.tool_calls.map((tool, index) => isRec(tool) ? { index, ...tool } : tool);
+  }
+  if (Object.keys(delta).length > 0) {
+    frames.push({ id, object: "chat.completion.chunk", created, model, choices: [{ index: 0, delta, finish_reason: null }] });
+  }
+  frames.push({
+    id,
+    object: "chat.completion.chunk",
+    created,
+    model,
+    choices: [{ index: 0, delta: {}, finish_reason: typeof choice.finish_reason === "string" ? choice.finish_reason : "stop" }],
+    ...(value.usage !== undefined ? { usage: value.usage } : {}),
+  });
+  return `${frames.map(frame => `data: ${JSON.stringify(frame)}\n\n`).join("")}data: [DONE]\n\n`;
+}
+
+interface NativeChatSseOptions {
+  requestedModel: string;
+  translatorBudget: TranslatorBudget;
+  signal: AbortSignal;
+  onFirstOutput?: () => void;
+  onUsage: (usage: OcxUsage) => void;
+  onTerminal?: (status: number, message?: string) => void;
+  onCancel?: () => void;
+}
+
+export function nativeChatSse(
+  body: ReadableStream<Uint8Array>,
+  options: NativeChatSseOptions,
+): ReadableStream<Uint8Array> {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  const scope = { kind: "live_transient" as const };
+  let buffer = "";
+  let bufferBytes = 0;
+  let queuedBytes = 0;
+  let sawFinish = false;
+  let sawDone = false;
+  let firstOutput = false;
+  let settled = false;
+  let cancelled = false;
+  let cancelledBySignal = false;
+
+  const releaseQueued = () => {
+    if (queuedBytes === 0) return;
+    options.translatorBudget.releaseRetained(queuedBytes, scope);
+    queuedBytes = 0;
+  };
+  const replaceBuffer = (next: string) => {
+    const nextBytes = encoder.encode(next).byteLength;
+    const reservation = options.translatorBudget.reserveTransient(nextBytes, scope);
+    reservation.commitRetained();
+    options.translatorBudget.releaseRetained(bufferBytes, scope);
+    buffer = next;
+    bufferBytes = nextBytes;
+  };
+  const appendBuffer = (fragment: string) => {
+    if (!fragment) return;
+    const fragmentBytes = encoder.encode(fragment).byteLength;
+    const nextBytes = bufferBytes + fragmentBytes;
+    if (nextBytes > TRANSLATOR_MAX_SSE_EVENT_BYTES) {
+      throw new Error("upstream SSE event exceeded the safe limit", { cause: { code: "translation_buffer_limit" } });
+    }
+    const reservation = options.translatorBudget.reserveTransient(nextBytes, scope);
+    try {
+      buffer += fragment;
+      reservation.commitRetained();
+      options.translatorBudget.releaseRetained(bufferBytes, scope);
+      bufferBytes = nextBytes;
+    } catch (error) {
+      reservation.release();
+      throw error;
+    }
+  };
+  const enqueue = (controller: ReadableStreamDefaultController<Uint8Array>, text: string) => {
+    const bytes = encoder.encode(text);
+    const reservation = options.translatorBudget.reserveTransient(bytes.byteLength, scope);
+    controller.enqueue(bytes);
+    reservation.commitRetained();
+    queuedBytes += bytes.byteLength;
+  };
+  const releaseBuffer = () => {
+    options.translatorBudget.releaseRetained(bufferBytes, scope);
+    buffer = "";
+    bufferBytes = 0;
+  };
+  const settle = (status: number, message?: string) => {
+    if (settled) return;
+    settled = true;
+    options.signal.removeEventListener("abort", onAbort);
+    options.onTerminal?.(status, message);
+  };
+  const fail = (
+    controller: ReadableStreamDefaultController<Uint8Array>,
+    message: string,
+    code: string,
+    status = 502,
+    type = "upstream_error",
+  ) => {
+    const safeMessage = redactSecretString(message);
+    try {
+      const frame = `data: ${JSON.stringify(chatCompletionsErrorBody(status, safeMessage, type, code))}\n\n`;
+      if (code === "translation_buffer_limit") controller.enqueue(encoder.encode(frame));
+      else enqueue(controller, frame);
+    } catch { /* controller may already be closed */ }
+    releaseBuffer();
+    settle(status, safeMessage);
+    try { void reader.cancel(new Error(safeMessage)).catch(() => {}); } catch { /* already closed */ }
+    try { controller.close(); } catch { /* already closed */ }
+  };
+  const processBlock = (
+    controller: ReadableStreamDefaultController<Uint8Array>,
+    block: string,
+    delimiter: string,
+  ): void => {
+    const payload = sseDataPayload(block);
+    if (payload === null) {
+      enqueue(controller, block + delimiter);
+      return;
+    }
+    const trimmed = payload.trim();
+    if (trimmed === "[DONE]") {
+      sawDone = true;
+      enqueue(controller, replaceSseDataPayload(block, "[DONE]") + delimiter);
+      settle(200);
+      try { void reader.cancel().catch(() => {}); } catch { /* already closed */ }
+      controller.close();
+      return;
+    }
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(payload);
+    } catch {
+      fail(controller, "upstream returned malformed SSE JSON", "upstream_sse_invalid");
+      return;
+    }
+    if (!isRec(parsed)) {
+      fail(controller, "upstream returned an invalid SSE event", "upstream_sse_invalid");
+      return;
+    }
+    const error = structuredError(parsed);
+    if (error) {
+      const status = error.status ?? 502;
+      const classified = classifyError(status, error.type ?? "upstream_error", error.message);
+      if (isCyberPolicyCode(error.code)) {
+        classified.code = CYBER_POLICY_ERROR_CODE;
+        classified.type = "invalid_request_error";
+      } else if (error.code !== undefined && error.code !== null) {
+        classified.code = error.code;
+      }
+      const safe = chatCompletionsErrorBody(status, classified.message, classified.type, classified.code);
+      enqueue(controller, replaceSseDataPayload(block, JSON.stringify(safe)) + delimiter);
+      settle(isCyberPolicyCode(classified.code) ? 400 : status, classified.message);
+      try { void reader.cancel(new Error(classified.message)).catch(() => {}); } catch { /* already closed */ }
+      controller.close();
+      return;
+    }
+    const usage = usageFromChat(parsed.usage);
+    if (usage) options.onUsage(usage);
+    const choices = Array.isArray(parsed.choices) ? parsed.choices : [];
+    if (choices.some(choice => isRec(choice) && typeof choice.finish_reason === "string" && choice.finish_reason.length > 0)) {
+      sawFinish = true;
+    }
+    if (!firstOutput && choices.some(choice => {
+      if (!isRec(choice) || !isRec(choice.delta)) return false;
+      const delta = choice.delta;
+      return (typeof delta.content === "string" && delta.content.length > 0)
+        || (typeof delta.reasoning_content === "string" && delta.reasoning_content.length > 0)
+        || (Array.isArray(delta.tool_calls) && delta.tool_calls.length > 0);
+    })) {
+      firstOutput = true;
+      options.onFirstOutput?.();
+    }
+    enqueue(controller, replaceSseDataPayload(block, JSON.stringify(normalizedChunk(parsed, options.requestedModel))) + delimiter);
+  };
+
+  function onAbort() {
+    cancelledBySignal = true;
+    if (!settled) {
+      settled = true;
+      options.onCancel?.();
+    }
+    try { void reader.cancel(options.signal.reason).catch(() => {}); } catch { /* already closed */ }
+  }
+  if (options.signal.aborted) onAbort();
+  else options.signal.addEventListener("abort", onAbort, { once: true });
+
+  return new ReadableStream<Uint8Array>({
+    async pull(controller) {
+      releaseQueued();
+      try {
+        for (;;) {
+          const next = nextSseBlock(buffer);
+          if (next) {
+            replaceBuffer(next.rest);
+            processBlock(controller, next.block, next.delimiter);
+            return;
+          }
+          const { done, value } = await reader.read();
+          if (cancelled) return;
+          if (cancelledBySignal) {
+            releaseBuffer();
+            controller.close();
+            return;
+          }
+          if (!done) {
+            appendBuffer(decoder.decode(value, { stream: true }));
+            continue;
+          }
+          appendBuffer(decoder.decode());
+          if (buffer.trim().length > 0) {
+            fail(controller, "upstream SSE ended with an unterminated event", "upstream_sse_unterminated");
+            return;
+          }
+          releaseBuffer();
+          if (sawDone || sawFinish) {
+            if (!sawDone) enqueue(controller, "data: [DONE]\n\n");
+            settle(200);
+            controller.close();
+          } else {
+            fail(controller, "upstream SSE ended before a terminal event", "upstream_sse_truncated");
+          }
+          return;
+        }
+      } catch (error) {
+        const overflow = isTranslatorBudgetExceededError(error)
+          || (error instanceof Error && (error.cause as { code?: unknown } | undefined)?.code === "translation_buffer_limit");
+        fail(
+          controller,
+          overflow ? "upstream SSE event exceeded the safe limit" : error instanceof Error ? error.message : String(error),
+          overflow ? "translation_buffer_limit" : "upstream_sse_error",
+        );
+      }
+    },
+    cancel(reason) {
+      cancelled = true;
+      releaseQueued();
+      releaseBuffer();
+      options.signal.removeEventListener("abort", onAbort);
+      if (!settled) {
+        settled = true;
+        options.onCancel?.();
+      }
+      try { return reader.cancel(reason).then(() => undefined, () => undefined); } catch { return Promise.resolve(); }
+    },
+  });
+}