cartethyia 2.7.4 → 2.7.6

package/src/protocol/registry.ts

@@ -1,6 +1,8 @@
 import type { CanonicalEvent, CanonicalRequest, WireFamily } from "./canonical-model";
+import type { DialectPolicy } from "./translation/dialect/types";
+import type { ThinkingConfig } from "./translation/dialect/thinking-ladder";
 
-export interface CodecContext {
+interface CodecContext {
   readonly isOAuth?: boolean;
   readonly sessionId?: string;
   readonly supportsPromptCaching?: boolean;
@@ -13,6 +15,16 @@ export interface CodecContext {
    * deployment default; only wire encoders that clamp images read it.
    */
   readonly maxBytesOverride?: number;
+  /**
+   * Resolved wire dialect (see `translation/dialect`). Absent = the codec's
+   * own default behavior (today's exact bytes).
+   */
+  readonly dialectPolicy?: DialectPolicy;
+  /**
+   * Resolved thinking config (see `translation/dialect/thinking-ladder`).
+   * Absent = the codec's own default behavior (today's exact clamp/ladder).
+   */
+  readonly thinking?: ThinkingConfig;
 }
 
 /**
@@ -27,7 +39,13 @@ type CodecModule =
       readonly family: "messages";
       readonly encodeWireRequest: (
         request: CanonicalRequest,
-        options?: { isOAuth?: boolean },
+        options?: {
+          readonly isOAuth?: boolean;
+          readonly maxBytesOverride?: number;
+          readonly dialectPolicy?: DialectPolicy;
+          readonly thinking?: ThinkingConfig;
+          readonly maxOutputTokens?: number;
+        },
       ) => Record<string, unknown>;
       readonly decodeWireResponse: (
         json: Record<string, unknown>,
@@ -48,6 +66,8 @@ type CodecModule =
           readonly supportsPromptCaching?: boolean;
           readonly tokenLimitField?: "max_tokens" | "max_completion_tokens";
           readonly promptCacheKey?: string;
+          readonly dialectPolicy?: DialectPolicy;
+          readonly thinking?: ThinkingConfig;
         },
       ) => Record<string, unknown>;
       readonly decodeWireResponse: (
@@ -58,6 +78,7 @@ type CodecModule =
         body: ReadableStream<Uint8Array>,
         request: CanonicalRequest,
         signal?: AbortSignal,
+        options?: { readonly dialectPolicy?: DialectPolicy },
       ) => AsyncIterable<CanonicalEvent>;
     }
   | {
@@ -67,6 +88,9 @@ type CodecModule =
         options?: {
           readonly supportsPromptCaching?: boolean;
           readonly promptCacheKey?: string;
+          readonly dialectPolicy?: DialectPolicy;
+          readonly thinking?: ThinkingConfig;
+          readonly maxOutputTokens?: number;
         },
       ) => Record<string, unknown>;
       readonly decodeWireResponse: (
@@ -89,8 +113,10 @@ type CodecModule =
  *
  * The dynamic import is awaited by the caller. Wire encoding happens before the
  * upstream request is issued, so the cost is paid once, on the first request,
- * and is subsequently free. `preloadCodecs()` warms it during boot to remove
- * even that first-request delay.
+ * The cost is paid once, on the first request for that family, because wire
+ * encoding happens before the upstream request is issued. There is no preload
+ * at boot: no family is knowable then, and eagerly loading all three codecs
+ * would defeat the ~50 MiB of resident memory this indirection removes.
  */
 const codecCache = new Map<WireFamily, Promise<CodecModule>>();
 
@@ -103,8 +129,8 @@ const codecCache = new Map<WireFamily, Promise<CodecModule>>();
  * a gateway instance only ever serves one family.
  *
  * The cost is paid once, on the first request for that family, because wire
- * encoding happens before the upstream request is issued. `preloadCodec()`
- * warms it during boot so even that first-request delay disappears.
+ * encoding happens before the upstream request is issued. No boot-time preload
+ * exists — see the note on `codecCache` above.
  */
 async function loadCodec(wireFamily: WireFamily): Promise<CodecModule> {
   const cached = codecCache.get(wireFamily);
@@ -127,15 +153,6 @@ async function loadCodec(wireFamily: WireFamily): Promise<CodecModule> {
   return promise;
 }
 
-/**
- * Warms the codec module for a wire family during boot so the first request
- * does not pay the dynamic-import cost. Safe to call concurrently; the cache
- * deduplicates.
- */
-export function preloadCodec(wireFamily: WireFamily): Promise<void> {
-  return loadCodec(wireFamily).then(() => undefined);
-}
-
 export async function encodeWireRequest(
   wireFamily: WireFamily,
   request: CanonicalRequest,
@@ -148,6 +165,11 @@ export async function encodeWireRequest(
       ...(context?.maxBytesOverride === undefined
         ? {}
         : { maxBytesOverride: context.maxBytesOverride }),
+      ...(context?.maxOutputTokens === undefined
+        ? {}
+        : { maxOutputTokens: context.maxOutputTokens }),
+      ...(context?.dialectPolicy === undefined ? {} : { dialectPolicy: context.dialectPolicy }),
+      ...(context?.thinking === undefined ? {} : { thinking: context.thinking }),
     });
   }
   if (codec.family === "chat") {
@@ -164,6 +186,8 @@ export async function encodeWireRequest(
       ...(context?.promptCacheKey === undefined
         ? {}
         : { promptCacheKey: context.promptCacheKey }),
+      ...(context?.dialectPolicy === undefined ? {} : { dialectPolicy: context.dialectPolicy }),
+      ...(context?.thinking === undefined ? {} : { thinking: context.thinking }),
     });
   }
   return codec.encodeWireRequest(request, {
@@ -173,6 +197,11 @@ export async function encodeWireRequest(
     ...(context?.promptCacheKey === undefined
       ? {}
       : { promptCacheKey: context.promptCacheKey }),
+    ...(context?.maxOutputTokens === undefined
+      ? {}
+      : { maxOutputTokens: context.maxOutputTokens }),
+    ...(context?.dialectPolicy === undefined ? {} : { dialectPolicy: context.dialectPolicy }),
+    ...(context?.thinking === undefined ? {} : { thinking: context.thinking }),
   });
 }
 
@@ -206,6 +235,12 @@ export function decodeWireStream(
       yield* codec.decodeWireStream(body, context?.signal, context?.isOAuth ?? false);
       return;
     }
+    if (codec.family === "chat") {
+      yield* codec.decodeWireStream(body, request, context?.signal, {
+        ...(context?.dialectPolicy === undefined ? {} : { dialectPolicy: context.dialectPolicy }),
+      });
+      return;
+    }
     yield* codec.decodeWireStream(body, request, context?.signal);
   }
   return decode();

package/src/protocol/request/chat.ts

@@ -8,15 +8,19 @@ import { isWebSearchTool } from "../../protocol/translation/search";
 import { pickWireSupportedControls } from "../../protocol/translation/capabilities";
 import { normalizeWireMaxTokens } from "../../protocol/translation/normalize";
 import { resolveWireMaxTokens } from "../../protocol/translation/quirks";
-import {
-  clampReasoningEffort,
-  resolveSupportedReasoningEfforts,
-} from "../../protocol/translation/thinking";
+import { DEFAULT_DIALECT_POLICIES } from "../../protocol/translation/dialect/rules";
+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 } from "../codecs";
 import { resolvePromptCacheKey } from "../../providers/operations/session-resolution";
 import { reasoningEffortFromIntent } from "../../protocol/reasoning";
 import { parseChatResponseToEvents, decodeChatSseStream } from "../response/chat";
 
+/** Fallback when no resolved policy is supplied — today's exact behavior. */
+const DEFAULT_CHAT_DIALECT_POLICY: DialectPolicy = DEFAULT_DIALECT_POLICIES.openai;
+
 /**
  * OpenAI `input_audio.format` accepts only the discrete ids `wav`/`mp3`, never a
  * MIME type. The canonical `audio` part carries a `media_type`; map it here and
@@ -182,15 +186,31 @@ export function canonicalToChatPayload(
     readonly tokenLimitField?: "max_tokens" | "max_completion_tokens";
     readonly maxOutputTokens?: number;
     readonly promptCacheKey?: string;
+    readonly dialectPolicy?: DialectPolicy;
+    readonly thinking?: ThinkingConfig;
   } = {},
 ): Record<string, unknown> {
+  const policy = options.dialectPolicy ?? DEFAULT_CHAT_DIALECT_POLICY;
+  const resolvedThinking = options.thinking ?? resolveThinkingForModel(request.model, "", "chat");
   const supportsPromptCaching = options.supportsPromptCaching ?? true;
-  const tokenLimitField = options.tokenLimitField ?? "max_tokens";
+  const tokenLimitField = options.tokenLimitField ?? policy.maxTokensField;
+  const reasoningField = policy.reasoningContentField;
+  const carryReasoning = (has: boolean, text: string): Record<string, unknown> =>
+    has && reasoningField !== undefined ? { [reasoningField]: text } : {};
   const messages: Array<Record<string, unknown>> = [];
+  const systemTexts: string[] = [];
   if (request.system?.length) {
     for (const p of request.system) {
-      if (p.kind === "text" && !isClaudeBillingHeaderText(p.text))
-        messages.push({ role: "system", content: p.text });
+      if (p.kind === "text" && !isClaudeBillingHeaderText(p.text)) systemTexts.push(p.text);
+    }
+  }
+  if (systemTexts.length > 0) {
+    if (policy.supportsMultipleSystemMessages) {
+      for (const text of systemTexts) messages.push({ role: "system", content: text });
+    } else {
+      // Strict chat templates (Qwen Portal / Alibaba / MiniMax) accept a single
+      // system message; join the canonical system parts into one.
+      messages.push({ role: "system", content: systemTexts.join("\n") });
     }
   }
   if (request.instructions?.length) {
@@ -217,6 +237,12 @@ export function canonicalToChatPayload(
         (c): c is Extract<typeof c, { kind: "text" }> => c.kind === "text",
       );
       const content = textParts.length ? textParts.map((c) => c.text).join("\n") : null;
+      // DeepSeek V4 requires the assistant content field to be present on a
+      // tool-call turn; a null content would be rejected verbatim.
+      const effectiveContent =
+        policy.requiresAssistantContentForToolCalls && (content === null || content.length === 0)
+          ? ""
+          : content;
       // Reasoning must survive on a tool-call turn, not just on plain assistant
       // turns. Providers in thinking mode require the previous turn's reasoning
       // to be replayed, and the tool-call turn is exactly where a thinking
@@ -237,9 +263,9 @@ export function canonicalToChatPayload(
       const hasReasoning = m.content.some((c) => c.kind === "reasoning");
       messages.push({
         role: "assistant",
-        content,
+        content: effectiveContent,
         tool_calls: toolCalls,
-        ...(hasReasoning ? { reasoning_content: reasoningContent } : {}),
+        ...carryReasoning(hasReasoning, reasoningContent),
       });
     } else if (m.role === "tool") {
       for (const p of m.content) {
@@ -332,9 +358,7 @@ export function canonicalToChatPayload(
         messages.push({
           role: m.role,
           content: parts,
-          ...(m.role === "assistant" && hasReasoning
-            ? { reasoning_content: reasoningContent }
-            : {}),
+          ...carryReasoning(m.role === "assistant" && hasReasoning, reasoningContent),
         });
       } else {
         // A user turn whose toolResult parts were all folded out above has
@@ -374,7 +398,7 @@ export function canonicalToChatPayload(
             messages.push({
               role: "assistant",
               content: "",
-              reasoning_content: reasoningContent,
+              ...carryReasoning(true, reasoningContent),
             });
             continue;
           }
@@ -401,9 +425,7 @@ export function canonicalToChatPayload(
         messages.push({
           role: m.role,
           content,
-          ...(m.role === "assistant" && hasReasoning
-            ? { reasoning_content: reasoningContent }
-            : {}),
+          ...carryReasoning(m.role === "assistant" && hasReasoning, reasoningContent),
         });
       }
     }
@@ -458,7 +480,7 @@ export function canonicalToChatPayload(
       };
     });
   }
-  if (request.tool_choice) {
+  if (request.tool_choice && policy.supportsToolChoice) {
     if (typeof request.tool_choice === "object" && request.tool_choice.type === "allowed_tools") {
       payload["tool_choice"] = {
         type: "allowed_tools",
@@ -484,11 +506,16 @@ export function canonicalToChatPayload(
   // is what the Codex encoder already uses); deriving it here instead of in
   // each codec is what keeps a translated request from silently losing it.
   if (request.reasoning !== undefined) {
-    const effort = clampReasoningEffort(
+    const effort = clampThinkingLevelForModel(
+      resolvedThinking,
       reasoningEffortFromIntent(request.reasoning),
-      resolveSupportedReasoningEfforts(request.model, "chat"),
     );
     if (effort !== undefined) payload["reasoning_effort"] = effort;
+    // Qwen chat templates select thinking with `enable_thinking` (plus optional
+    // `thinking_budget`) instead of `reasoning_effort`.
+    if (policy.thinkingFormat === "qwen" && effort !== undefined) {
+      payload["enable_thinking"] = true;
+    }
   }
   // Stream controls the caller asked for are forwarded upstream so a
   // pass-through provider can honor them (the local encoder honors them too).

package/src/protocol/request/codex.ts

@@ -27,7 +27,7 @@ import {
  * `provider_options` key that opts one request into the Daybreak
  * `access_programs.cyber` member. See the UNCONFIRMED note at its use site.
  */
-export const CODEX_ACCESS_PROGRAMS_CYBER_OPTION = "codex_access_programs_cyber";
+const CODEX_ACCESS_PROGRAMS_CYBER_OPTION = "codex_access_programs_cyber";
 
 /**
  * Removes `access_programs` from an already-built Codex Responses payload.

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) {
@@ -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,

package/src/protocol/response/messages.ts

@@ -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 } {

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 {