cartethyia 2.7.4 → 2.7.5

package/src/protocol/translation/quirks.ts

@@ -32,7 +32,7 @@ export interface ParamQuirk {
 }
 
 /** Per-wire output-token policy, in one table instead of per-builder branches. */
-export interface WireTokenBound {
+interface WireTokenBound {
   /** Default when the caller sent no limit (undefined = leave absent). */
   readonly defaultMaxTokens?: number;
   /** Floor applied to any positive caller value below it (wire minimum). */
@@ -66,6 +66,13 @@ const DEFAULT_OUTPUT_TOKENS = 32_000;
  * Output-token bounds per wire family. Chat has no global ceiling: a model's
  * catalog output limit is the ceiling, and an unknown model passes the
  * caller's value through. Messages keeps its Anthropic floors and OAuth cap.
+ *
+ * The ceiling only ever comes from `options.maxOutputTokens` (the model's
+ * catalog output limit, supplied by the compatible adapter from
+ * `candidate.output_limit`). When it is omitted there is nothing to clamp to,
+ * which is intentional pass-through: a direct codec caller without a catalog
+ * limit is unbounded, and an unknown model passes the caller's value through by
+ * design — the bound table supplies floors/defaults, never an invented ceiling.
  */
 export const WIRE_TOKEN_BOUNDS: Readonly<Record<string, WireTokenBound>> = {
   chat: { minTokens: 16, defaultMaxTokens: DEFAULT_OUTPUT_TOKENS },
@@ -73,7 +80,14 @@ export const WIRE_TOKEN_BOUNDS: Readonly<Record<string, WireTokenBound>> = {
   responses: { minTokens: 16, defaultMaxTokens: DEFAULT_OUTPUT_TOKENS },
 };
 
-/** Resolves the output-token value for one wire from caller controls. */
+/**
+ * Resolves the output-token value for one wire from caller controls.
+ *
+ * Clamping to a ceiling happens only when `options.maxOutputTokens` (the
+ * model's catalog limit) is present. An omitted `maxOutputTokens` means
+ * pass-through by design: a direct codec caller without a catalog limit is
+ * unbounded, and this function never fabricates a ceiling on its own.
+ */
 export function resolveWireMaxTokens(
   wire: string,
   controls: { max_tokens?: number | undefined },
@@ -120,7 +134,7 @@ function modelGeneration(modelId: string): { family: string; major: number; mino
 }
 
 /** True when the model rejects `temperature`/`top_p`/`top_k` at any thinking setting. */
-export function rejectsSamplingParams(modelId: string): boolean {
+function rejectsSamplingParams(modelId: string): boolean {
   const generation = modelGeneration(modelId);
   if (generation === undefined) return false;
   // Opus turns strict at 4.7; the other families at 5.0.
@@ -157,7 +171,7 @@ const PARAM_QUIRKS: readonly ParamQuirk[] = [
 ];
 
 /** Finds the first quirk matching the provider/model pair, or undefined. */
-export function findParamQuirk(
+function findParamQuirk(
   providerId: string,
   modelId: string,
 ): ParamQuirk | undefined {

package/src/protocol/translation/thinking.ts

@@ -5,7 +5,9 @@
 // so the native config (`thinking_type` + `budget_tokens`) is dropped while the
 // request-level effort intent (OpenAI `reasoning_effort`) survives — that field
 // is a property of the request, not of the turn.
-import type { CanonicalRequest, ReasoningIntent, WireFamily } from "../canonical-model";
+import type { CanonicalRequest, ReasoningIntent } from "../canonical-model";
+import type { ThinkingConfig } from "./dialect/thinking-ladder";
+import { clampThinkingLevelForModel } from "./dialect/model-thinking";
 
 /**
  * Canonical reasoning effort ladder, ordered least to most intensive.
@@ -41,7 +43,7 @@ export type ThinkingSuffixIntent =
  * A parsed model name: the bare id the router and upstream must see, plus the
  * thinking level the caller asked for (or null when they asked for none).
  */
-export interface ParsedThinkingSuffix {
+interface ParsedThinkingSuffix {
   readonly model: string;
   readonly intent: ThinkingSuffixIntent | null;
 }
@@ -200,248 +202,11 @@ export function withThinkingSuffixIntent(
 }
 
 /** Standard OpenAI Responses wire supported efforts (OpenAI, OpenCode, Azure). Responses API has no 'max' tier. */
-export const RESPONSES_WIRE_SUPPORTED_EFFORTS: readonly ReasoningEffortLevel[] = [
-  "minimal",
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-];
-
-/** Full 6-tier effort scale for models that support 'max' (Claude, MiMo, Kimi, DeepSeek). */
-export const EXTENDED_SUPPORTED_EFFORTS: readonly ReasoningEffortLevel[] = [
-  "minimal",
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-  "max",
-];
-
-/** Standard 4-tier effort scale (Gemini, Qwen). */
-export const BASE_SUPPORTED_EFFORTS: readonly ReasoningEffortLevel[] = [
-  "minimal",
-  "low",
-  "medium",
-  "high",
-];
-
-/**
- * The `mimo-v2.6` family rejects every effort outside this set.
- *
- * Verified live against OpenCode's `/zen/v1` on 2026-09-22: `minimal`, `xhigh`,
- * and `max` each answer `500 {"type":"error","error":{"message":"Internal server
- * error"}}` — an opaque failure that names nothing, so the caller sees a dead
- * request rather than a bad parameter — while `low`/`medium`/`high` and an
- * omitted field answer `200`. Its siblings on the very same endpoint
- * (`mimo-v2.5-free`, `nemotron-3-ultra-free`, `big-pickle`) accept the full
- * ladder, so this is a property of the model rather than of the route.
- *
- * Narrowing is the safe direction: every level here is accepted by all hosts of
- * the id, so the worst case for a host that would also take `xhigh` is that the
- * request runs one tier below what the caller asked for instead of failing.
- */
-const MIMO_V26_SUPPORTED_EFFORTS: readonly ReasoningEffortLevel[] = ["low", "medium", "high"];
-
-/**
- * Mercury (Inception Labs) — the chat ladder is `{instant, low, medium,
- * high}`: `minimal`, `xhigh`, and `max` each answer a 400
- * `reasoning_effort must be one of: 'instant', 'low', 'medium', 'high'`.
- * `instant` is not on the canonical ladder, so it can only appear here; the
- * clamp steps down to `high` for any higher request.
- */
-const INCEPTION_SUPPORTED_EFFORTS: readonly ReasoningEffortLevel[] = [
-  "instant",
-  "low",
-  "medium",
-  "high",
-];
 
-/**
- * `low..max`: the OpenAI 5.6/6/daybreak generation and the new-gen Claude
- * adaptive models (`fable`/`mythos`/`opus-5`/`sonnet-5`/`opus-4-7`/`opus-4-8`)
- * all serve `max`, and none of them advertises `minimal`.
- */
-const LOW_TO_MAX_SUPPORTED_EFFORTS: readonly ReasoningEffortLevel[] = [
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-  "max",
-];
-
-/** `gpt-5.5` rows: neither `minimal` nor `max`. */
-const GPT55_SUPPORTED_EFFORTS: readonly ReasoningEffortLevel[] = [
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-];
-
-/** Claude adaptive 4.6 pair: `low..high`, no `xhigh`/`max`. */
-const CLAUDE_ADAPTIVE_46_SUPPORTED_EFFORTS: readonly ReasoningEffortLevel[] = [
-  "low",
-  "medium",
-  "high",
-];
-
-/**
- * Resolves the valid reasoning effort levels for a given model and wire family.
- *
- * Priority order:
- * 1. Explicit model-declared `reasoningEfforts` from the catalog.
- * 2. Wire family constraint: the Responses wire API (`/v1/responses`) does not
- *    support 'max' (capped at 'xhigh') unless the model's published ladder
- *    includes it.
- * 3. Model family heuristics, matching each family's published ladder:
- *    - Muse Spark (Meta on OpenCode / Fireworks): `["minimal", "low", "medium", "high", "xhigh"]`
- *    - Gemini: `["minimal", "low", "medium", "high"]`
- *    - Claude: per-generation — 4.6 adaptive stops at `high`, budget-era 4.5/4.1
- *      tops out at `xhigh`, new-gen adaptive is `low..max`.
- *    - DeepSeek, Kimi, MiMo: full extended ladder including 'max'
- *    - Default: extended ladder.
- */
-export function resolveSupportedReasoningEfforts(
-  modelId?: string,
-  wireFamily?: WireFamily,
-  declaredEfforts?: readonly string[],
-): readonly ReasoningEffortLevel[] {
-  if (declaredEfforts !== undefined && declaredEfforts.length > 0) {
-    const filtered = declaredEfforts.filter((e): e is ReasoningEffortLevel =>
-      REASONING_EFFORT_LADDER.includes(e as ReasoningEffortLevel),
-    );
-    if (filtered.length > 0) return filtered;
-  }
-
-  const id = (modelId ?? "").toLowerCase();
-
-  if (wireFamily === "responses") {
-    // Catalog ladders for the ChatGPT/OpenAI generations: `gpt-5.5`
-    // is the one row that stops at `xhigh`.
-    if (id.includes("gpt-5.5")) return GPT55_SUPPORTED_EFFORTS;
-    if (id.includes("gpt-5.6") || id.includes("gpt-6") || id.includes("daybreak")) {
-      return LOW_TO_MAX_SUPPORTED_EFFORTS;
-    }
-    return RESPONSES_WIRE_SUPPORTED_EFFORTS;
-  }
-
-  if (id.includes("muse")) {
-    return RESPONSES_WIRE_SUPPORTED_EFFORTS;
-  }
-  if (id.includes("gemini")) {
-    return BASE_SUPPORTED_EFFORTS;
-  }
-  // Checked before the generic default, which would hand this family `xhigh`
-  // and `max` — both of which it answers with an opaque 500.
-  if (id.includes("mimo-v2.6")) {
-    return MIMO_V26_SUPPORTED_EFFORTS;
-  }
-  // Checked before the generic default: Mercury's chat endpoint answers every
-  // effort outside {instant, low, medium, high} with a 400 that names the
-  // field (recorded live from request 40b60777).
-  if (id.includes("mercury") && wireFamily === "chat") {
-    return INCEPTION_SUPPORTED_EFFORTS;
-  }
-  // Claude catalog ladders: `output_config.effort` rides the
-  // Messages wire, so an out-of-ladder tier is an upstream rejection risk.
-  // Dot-tolerant (`cb/claude-opus-4.6`) because gateway-prefixed ids keep the
-  // upstream separator.
-  if (id.includes("claude")) {
-    const claudeId = id.replaceAll(".", "-");
-    if (claudeId.includes("opus-4-6") || claudeId.includes("sonnet-4-6")) {
-      return CLAUDE_ADAPTIVE_46_SUPPORTED_EFFORTS;
-    }
-    if (
-      claudeId.includes("fable") ||
-      claudeId.includes("mythos") ||
-      claudeId.includes("opus-5") ||
-      claudeId.includes("sonnet-5") ||
-      claudeId.includes("opus-4-7") ||
-      claudeId.includes("opus-4-8")
-    ) {
-      return LOW_TO_MAX_SUPPORTED_EFFORTS;
-    }
-    if (
-      claudeId.includes("opus-4-5") ||
-      claudeId.includes("sonnet-4-5") ||
-      claudeId.includes("haiku-4-5") ||
-      claudeId.includes("opus-4-1") ||
-      claudeId.includes("opus-4-0") ||
-      claudeId.includes("sonnet-4-0")
-    ) {
-      // Budget-mode rows: `minimal..xhigh`, no `max` — same shape as the
-      // responses-wire default.
-      return RESPONSES_WIRE_SUPPORTED_EFFORTS;
-    }
-  }
-
-  return EXTENDED_SUPPORTED_EFFORTS;
-}
-
-/**
- * Whether a Claude model wants *adaptive* thinking (`thinking.type: "adaptive"`
- * + `output_config.effort`) or *budget* thinking (`thinking.type: "enabled"` +
- * `budget_tokens`).
- *
- * The two generations reject each other's shape: an adaptive-era model answers
- * a budget block with `thinking.budget_tokens: Extra inputs are not permitted`,
- * and a budget-era model answers an adaptive block with `adaptive thinking is
- * not supported on this model` (verified live against the Anthropic OAuth
- * route — opus-4-5/sonnet-4-5/haiku-4-5 400 on adaptive, while
- * opus-4-6+/sonnet-4-6+/5-series accept it).
- *
- * Adaptive era, per the reference catalog: Opus 4.6+, Sonnet 4.6+, and the
- * 5-series (fable/mythos/opus-5/sonnet-5). Everything older is budget era.
- * The rule is stated once here so the Messages codec and the effort ladder
- * cannot disagree about which generation a model belongs to.
- */
-export function claudeUsesAdaptiveThinking(modelId: string): boolean {
-  const id = modelId.toLowerCase().replaceAll(".", "-");
-  if (id.includes("fable") || id.includes("mythos")) return true;
-  if (id.includes("opus-5") || id.includes("sonnet-5")) return true;
-  if (id.includes("opus-4-6") || id.includes("sonnet-4-6")) return true;
-  if (id.includes("opus-4-7") || id.includes("opus-4-8")) return true;
-  return false;
-}
-
-/**
- * Clamps a requested reasoning effort against a target model/wire's supported ladder.
- *
- * If the requested effort is not in the supported list, it gracefully steps down to the
- * highest supported level that is less than or equal to the requested index in the canonical ladder.
- * Synonyms are normalized: 'ultra' -> 'max', 'off' -> 'none'.
- * Returns undefined for 'none' / unrequested.
- */
-export function clampReasoningEffort(
-  requested: string | undefined,
-  supported: readonly ReasoningEffortLevel[],
-): ReasoningEffortLevel | undefined {
-  if (!requested || typeof requested !== "string") return undefined;
-  const raw = requested.toLowerCase().trim();
-  const normalized = raw === "ultra" ? "max" : raw === "off" ? "none" : raw;
-  if (normalized === "none") return undefined;
-
-  const reqLevel = normalized as ReasoningEffortLevel;
-  // Don't clamp if provider declares it supports the level but we haven't updated constants yet.
-  // Fall through to direct return for any ladder member the caller asked for.
-  if (supported.includes(reqLevel)) return reqLevel;
-  // Unknown string → drop, don't invent a fallback.
-  const requestedIndex = REASONING_EFFORT_LADDER.indexOf(reqLevel);
-  if (requestedIndex === -1) return undefined;
-
-  let clamped: ReasoningEffortLevel | undefined;
-  for (const level of supported) {
-    if (REASONING_EFFORT_LADDER.indexOf(level) > requestedIndex) break;
-    clamped = level;
-  }
-  // No smaller supported level exists (caller asked below floor): use floor rather than max.
-  return clamped ?? supported[0];
-}
 
-export interface ThinkingNormalizationOptions {
-  readonly wireFamily?: WireFamily;
-  readonly modelId?: string;
-  readonly supportedEfforts?: readonly string[];
+interface ThinkingNormalizationOptions {
+  /** Resolved thinking config (from `resolveThinkingForModel`). Absent = no clamp. */
+  readonly thinking?: ThinkingConfig;
 }
 
 /**
@@ -459,7 +224,7 @@ function isLastMessageFromUser(request: CanonicalRequest): boolean {
  * `thinking` config is also present, so a config drop must never leave them
  * orphaned.
  */
-export function hasReplayedThinkingBlocks(request: CanonicalRequest): boolean {
+function hasReplayedThinkingBlocks(request: CanonicalRequest): boolean {
   for (const message of request.messages) {
     for (const part of message.content) {
       if (part.kind !== "reasoning") continue;
@@ -504,15 +269,10 @@ export function normalizeThinkingConfig(
     }
   }
 
-  // Only clamp when caller actually set an effort AND provider declares a ladder.
-  // If provider doesn't declare supportedEfforts, don't invent a 32k clamp — pass through.
-  if (reasoning?.effort !== undefined && options?.supportedEfforts !== undefined && options.supportedEfforts.length > 0) {
-    const supported = resolveSupportedReasoningEfforts(
-      options?.modelId ?? request.model,
-      options?.wireFamily,
-      options?.supportedEfforts,
-    );
-    const clamped = clampReasoningEffort(reasoning.effort, supported);
+  // Only clamp when caller actually set an effort AND a thinking config is
+  // resolved (ladder known). Without one, don't invent a clamp — pass through.
+  if (reasoning?.effort !== undefined && options?.thinking !== undefined) {
+    const clamped = clampThinkingLevelForModel(options.thinking, reasoning.effort);
     if (clamped !== reasoning.effort) {
       reasoning = { ...reasoning };
       if (clamped === undefined) delete reasoning.effort;

package/src/protocol/translation/tool-id.ts

@@ -9,7 +9,7 @@
 import type { CanonicalRequest } from "../canonical-model";
 
 /** Anthropic tool ID contract: alphanumerics, underscore, hyphen only. */
-export const TOOL_ID_PATTERN: RegExp = /^[a-zA-Z0-9_-]+$/;
+const TOOL_ID_PATTERN: RegExp = /^[a-zA-Z0-9_-]+$/;
 
 const INVALID_TOOL_ID_CHARS = /[^a-zA-Z0-9_-]/g;
 
@@ -21,7 +21,7 @@ const INVALID_TOOL_ID_CHARS = /[^a-zA-Z0-9_-]/g;
  * input is not a non-empty string or nothing valid remains, so callers can
  * fall back to a deterministic generated ID.
  */
-export function sanitizeToolId(id: unknown): string | null {
+function sanitizeToolId(id: unknown): string | null {
   if (typeof id !== "string" || id.length === 0) return null;
   const base = id.includes("|") ? (id.split("|")[0] ?? id) : id;
   const sanitized = base.replace(INVALID_TOOL_ID_CHARS, "");
@@ -33,7 +33,7 @@ export function sanitizeToolId(id: unknown): string | null {
  * identical histories produce byte-identical requests — cache-friendly and
  * directly testable.
  */
-export function generateToolCallId(msgIndex = 0, tcIndex = 0, toolName?: string): string {
+function generateToolCallId(msgIndex = 0, tcIndex = 0, toolName?: string): string {
   const name = toolName ? `_${toolName.replace(INVALID_TOOL_ID_CHARS, "")}` : "";
   return `call_msg${msgIndex}_tc${tcIndex}${name}`;
 }

package/src/protocol/translation/tool-repair.ts

@@ -211,7 +211,7 @@ function toolCallIdsIn(message: CanonicalMessage): string[] {
  * and is repaired by synthesizing a result (`repairMissingToolResponses`), not
  * by deleting the call — the model should see that the tool was interrupted.
  */
-export function dropOrphanToolResults(
+function dropOrphanToolResults(
   messages: readonly CanonicalMessage[],
 ): CanonicalMessage[] {
   const callIds = new Set<string>();

package/src/protocol/upstream/post-json.ts

@@ -1,6 +1,10 @@
 /**
  * Shared upstream JSON executor for [OpenAI]-compatible adapters: POSTs a payload
  * with deadline/abort wiring and returns the response plus a release hook.
+ *
+ * `bodyEncoder` lets a provider send the same body with non-JSON encoding
+ * (e.g. zstd, which the Grok Build CLI does). When omitted, the JSON string is
+ * sent as-is.
  */
 import type { ProviderDispatchContext, ValidatedOutboundFetch } from "../../providers/provider-contracts";
 import { abortGatewayError, createUpstreamDeadlineLifecycle } from "../../providers/operations/upstream-deadline";
@@ -11,13 +15,14 @@ export async function postUpstreamJson(
   payload: Record<string, unknown>,
   context: ProviderDispatchContext,
   outboundFetch: ValidatedOutboundFetch,
+  bodyEncoder?: (payload: Record<string, unknown>) => string | Uint8Array<ArrayBuffer>,
 ): Promise<{ res: Response; signal: AbortSignal; release: () => void }> {
   const lifecycle = createUpstreamDeadlineLifecycle(context);
   try {
     const res = await outboundFetch(fetchUrl, {
       method: "POST",
       headers,
-      body: JSON.stringify(payload),
+      body: bodyEncoder ? bodyEncoder(payload) : JSON.stringify(payload),
       signal: lifecycle.signal,
     });
     return {

package/src/providers/adapters/compatible-adapter.ts

@@ -13,6 +13,9 @@ import {
 import { applyRouteUserAgent, type ProviderDispatchTarget, type ProviderId, type ProviderDispatchContext } from "../provider-contracts";
 import { BaseProviderAdapter } from "./base-adapter";
 import { encodeWireRequest, decodeWireResponse, decodeWireStream } from "../../protocol/registry";
+import { resolveDialect } from "../../protocol/translation/dialect/resolver";
+import { resolveThinkingForModel } from "../../protocol/translation/dialect/thinking-ladder";
+import type { DialectPolicy } from "../../protocol/translation/dialect/types";
 import { postUpstreamJson } from "../../protocol/upstream/post-json";
 import { GATEWAY_USER_AGENT } from "../operations/gateway-user-agent";
 import { resolvePromptCacheKey } from "../operations/session-resolution";
@@ -89,6 +92,14 @@ export interface OpenAICompatibleAdapterConfig {
    * this is the enforcement boundary, not account-creation validation.
    */
   readonly credential_forwarding?: "account" | "never";
+  /**
+   * Body encoding for the upstream POST. `"json"` (default) sends the plain
+   * JSON string. `"zstd"` compresses the JSON with `Bun.zstdCompressSync` and
+   * stamps `Content-Encoding: zstd` — the Grok Build CLI does this via its
+   * sampler (`request_compression.rs`), and the proxy accepts it (verified
+   * live 2026-11-02). Falls back to plain JSON if the runtime lacks zstd.
+   */
+  readonly request_compression?: "json" | "zstd";
   /**
    * Stamps `user-agent: Cartethyia/<version>` on every dispatch. Explicit
    * opt-in per provider spec — never a default — so first-party cloaking
@@ -188,6 +199,10 @@ export class OpenAICompatibleAdapter extends BaseProviderAdapter {
       // serving the stale pinned fallback on the first dispatch.
       Object.assign(headers, await this.config.buildExtraHeaders(context, request, candidate));
     }
+    // The compression header must match the body actually sent. It is stamped
+    // here — alongside the other request headers — so auth/proxy layers see the
+    // final shape before the transport runs.
+    if (this.config.request_compression === "zstd") headers["content-encoding"] = "zstd";
     Object.assign(headers, filterProviderCustomHeaders(context.credential.custom_headers));
     applyRouteUserAgent(headers, context.credential, context.user_agent);
     return headers;
@@ -201,6 +216,17 @@ export class OpenAICompatibleAdapter extends BaseProviderAdapter {
     const wireFamily = candidate.wire_family;
     const effectiveRequest = this.config.prepareRequest?.(request) ?? request;
     const promptCacheKey = resolvePromptCacheKey(effectiveRequest, context);
+    const dialectPolicy: DialectPolicy = resolveDialect(
+      candidate.model_id,
+      candidate.provider_id,
+      wireFamily,
+      candidate.dialect,
+    );
+    const thinking = resolveThinkingForModel(
+      candidate.model_id,
+      candidate.provider_id,
+      wireFamily,
+    );
     const payload = await encodeWireRequest(wireFamily, effectiveRequest, {
       supportsPromptCaching: this.config.supports_prompt_caching !== false,
       ...(promptCacheKey === undefined ? {} : { promptCacheKey }),
@@ -211,6 +237,8 @@ export class OpenAICompatibleAdapter extends BaseProviderAdapter {
       ...(context.image_clamp_max_bytes === undefined
         ? {}
         : { maxBytesOverride: context.image_clamp_max_bytes }),
+      dialectPolicy,
+      thinking,
     });
     if (
       wireFamily !== "messages" &&
@@ -283,6 +311,11 @@ export class OpenAICompatibleAdapter extends BaseProviderAdapter {
       payload as Record<string, unknown>,
       context,
       outboundFetch,
+      // zstd body encoding: matches the Grok Build CLI's
+      // `request_compression` (zstd with a JSON fallback when unavailable).
+      this.config.request_compression === "zstd" && typeof Bun?.zstdCompressSync === "function"
+        ? (p) => Bun.zstdCompressSync(Buffer.from(JSON.stringify(p))) as Uint8Array<ArrayBuffer>
+        : undefined,
     );
     upstream.release();
     return upstream.res;
@@ -300,8 +333,11 @@ export class OpenAICompatibleAdapter extends BaseProviderAdapter {
    * the caller (the route handler validates only the trust boundary), so this
    * method only stamps headers and posts.
    *
-   * `systemone` is kept as a named alias because the `/v1/systemone` route
-   * reads it directly; both names are the same behavior.
+   * `systemone` is kept as a named alias because both names are live: the
+   * transport dispatch handler for `POST /v1/systemone`
+   * (transport/dispatch/systemone.ts) and the discovery probing service
+   * (discovery/probing-service.ts) read it directly; both names are the same
+   * behavior.
    */
   async dispatchNativeService(
     body: Record<string, unknown>,
@@ -356,7 +392,10 @@ export class OpenAICompatibleAdapter extends BaseProviderAdapter {
           "upstream",
         );
       }
-      yield* decodeWireStream(wireFamily, res.body, request, { signal: context.abort_signal });
+      yield* decodeWireStream(wireFamily, res.body, request, {
+        signal: context.abort_signal,
+        dialectPolicy: resolveDialect(candidate.model_id, candidate.provider_id, wireFamily, candidate.dialect),
+      });
     } else {
       // A streaming request answered with a non-SSE body is a provider
       // protocol violation, and the body is often an error envelope or a

package/src/providers/authentication/jwt-validator.ts

@@ -340,11 +340,6 @@ export function jwksVerifierFor(
   return verifier;
 }
 
-/** Test hook: forgets cached JWKS verifiers. */
-export function resetJwksVerifiersForTests(): void {
-  jwksVerifiers.clear();
-}
-
 interface IssuedTokenValidation {
   readonly jwksUrl?: string;
   readonly issuer?: string | readonly string[];