cartethyia 2.7.3 → 2.7.5

package/src/protocol/dsml.ts

@@ -24,7 +24,7 @@ export interface DsmlToolCall {
   readonly arguments: string;
 }
 
-export interface DsmlRecovery {
+interface DsmlRecovery {
   readonly calls: readonly DsmlToolCall[];
   readonly clean: string;
 }
@@ -63,7 +63,7 @@ const DEFAULT_MAX_BLOCK_BYTES = 256 * 1024;
 const TOOL_NAME = /^[A-Za-z0-9_][A-Za-z0-9_.:-]{0,63}$/;
 
 /** Escapes regex metacharacters so a `|` separator is literal, not alternation. */
-export function escapeRegExp(value: string): string {
+function escapeRegExp(value: string): string {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
@@ -79,7 +79,7 @@ function uuidId(_call: { readonly name: string }, _index: number, _seq: number):
   return `call_${randomUUID().replace(/-/g, "").slice(0, 16)}`;
 }
 
-export interface DsmlParseResult {
+interface DsmlParseResult {
   readonly text: string;
   readonly calls: readonly DsmlToolCall[];
 }
@@ -306,15 +306,6 @@ function parseFuzzyDsml(text: string, options: DsmlParseOptions): DsmlRecovery {
   return { calls, clean };
 }
 
-/**
- * Recovers DSML tool calls from one plain-text string using the Qoder fuzzy
- * dialect. Always returns `{ calls, clean }` — no-DSML input returns the text
- * unchanged with no calls.
- */
-export function parseFuzzyDsmlToolCalls(text: string): DsmlRecovery {
-  return parseFuzzyDsml(text, {});
-}
-
 /**
  * Recovers DSML tool calls from one plain-text string. The dialect is chosen
  * by `options.fuzzy`; each dialect keeps its exact public shape:
@@ -338,40 +329,3 @@ export function parseDsmlToolCalls(
   const recovered = [...first.calls, ...last.calls];
   return recovered.length === 0 ? undefined : { text: `${first.text}${last.text}`.trim(), calls: recovered };
 }
-
-/**
- * The holdable tail of a content chunk: a short suffix that looks like the
- * start of a DSML tag and may finish in the next frame. Empty when there is
- * nothing worth holding. Mirrors `_dsml_tail_hold` in the reference bridge.
- */
-export function dsmlTailHold(text: string): string {
-  const at = text.lastIndexOf("<");
-  if (at < 0 || text.length - at > 24) return "";
-  const tail = text.slice(at);
-  // A complete tag already — nothing to wait for.
-  if (tail.includes(">")) return "";
-  const body = tail.replace(/\uFF5C/g, "|").toUpperCase().slice(1).replace(/^\//, "");
-  if (body.length === 0) return tail; // bare "<" or "</"
-  if (!body.startsWith("|")) return "";
-  const rest = body.slice(1);
-  if (rest.length === 0) return tail;
-  if ("DSML".startsWith(rest) || rest.startsWith("DSML")) return tail;
-  return "";
-}
-
-const DSML_CLOSE_TAG_RE = /<\/(?:[^>]*DSML[^>]*|parameter|invoke|calls|tool_calls|function_calls)\s*>\s*$/i;
-
-/**
- * Removes leftover DSML closing tags from the tail of a text. Anchored to the
- * end and looped, so several trailing tags come off one per pass; a closing
- * tag in the middle of a text is not residue and is preserved.
- */
-export function stripDsmlCloseTags(text: string): string {
-  let previous: string | null = null;
-  let out = text.trimEnd();
-  while (previous !== out) {
-    previous = out;
-    out = out.replace(DSML_CLOSE_TAG_RE, "").trimEnd();
-  }
-  return out;
-}

package/src/protocol/gateway-error.ts

@@ -6,12 +6,14 @@ export type GatewayErrorCode =
   | "capability_unsupported"
   | "ambiguous_model"
   | "model_not_found"
+  | "model_not_allowed"
   | "upstream_not_found"
   | "context_length_exceeded"
   | "request_too_large"
   | "accounts_unavailable"
   | "accounts_rate_limited"
   | "capacity_exhausted"
+  | "upstream_overloaded"
   | "provider_capacity_exhausted"
   | "upstream_queued"
   | "proxy_pool_capacity_exceeded"
@@ -22,8 +24,10 @@ export type GatewayErrorCode =
   | "proxy_pool_unhealthy"
   | "invalid_pool_limits"
   | "admission_unavailable"
+  | "route_unavailable"
   | "slug_reserved"
   | "quota_exceeded"
+  | "rate_limited"
   | "authentication_failed"
   | "policy_rejected"
   | "invalid_request"
@@ -52,8 +56,7 @@ export type GatewayErrorCode =
   | "proxy_unreachable"
   | "tool_call_loop_detected"
   | "client_router_denied"
-  | "shutting_down"
-  | "restart_for_update";
+  | "shutting_down";
 
 /** Identifies which boundary produced a safe public error. */
 export type GatewayErrorOrigin = "cartethyia" | "upstream" | "network";
@@ -226,7 +229,7 @@ export function capabilityUnsupported(
   return new GatewayError(
     "capability_unsupported",
     400,
-    `The selected route does not support capability: ${capability}`,
+    `The selected route does not support capability: ${capability} (request {requestId}). Drop the ${capability} part of the request, or route to a model that accepts it. Know your tools — this one just isn't in the box 🧰`,
     { capability, ...details },
   );
 }

package/src/protocol/image-clamp.ts

@@ -69,7 +69,7 @@ export interface ImageClampInput {
   readonly maxBytesOverride?: number;
 }
 
-export interface ImageClampDecision {
+interface ImageClampDecision {
   readonly action: ImageClampAction;
   readonly reason: ImageClampReason;
   /** Longest edge allowed for this image, given how many the request carries. */
@@ -96,7 +96,7 @@ export function base64DecodedByteLength(data: string): number {
 }
 
 /** The per-image longest-edge ceiling for a request carrying `imageCount` images. */
-export function imageClampMaxDimensionPx(imageCount: number): number {
+function imageClampMaxDimensionPx(imageCount: number): number {
   return imageCount > IMAGE_CLAMP_MANY_IMAGE_COUNT
     ? IMAGE_CLAMP_MANY_IMAGE_MAX_DIMENSION_PX
     : IMAGE_CLAMP_MAX_DIMENSION_PX;

package/src/protocol/image-generation.ts

@@ -22,7 +22,7 @@ const OPENAI_ASPECT_RATIOS: Readonly<Record<string, string>> = {
 export function imagePrompt(body: Record<string, unknown>): string {
   if (typeof body.prompt === "string" && body.prompt.trim().length > 0) return body.prompt;
   if (!Array.isArray(body.messages)) {
-    throw new GatewayError("invalid_request", 400, "prompt is required");
+    throw new GatewayError("invalid_request", 400, "prompt is required (request {requestId}). Check the shape of what you sent — then resend 🪞");
   }
   const texts: string[] = [];
   for (const message of body.messages) {
@@ -41,7 +41,7 @@ export function imagePrompt(body: Record<string, unknown>): string {
     }
   }
   const prompt = texts.join("\n").trim();
-  if (prompt.length === 0) throw new GatewayError("invalid_request", 400, "prompt is required");
+  if (prompt.length === 0) throw new GatewayError("invalid_request", 400, "prompt is required (request {requestId}). Check the shape of what you sent — then resend 🪞");
   return prompt;
 }
 

package/src/protocol/reasoning-text.ts

@@ -1,6 +1,6 @@
 /** The reasoning-shaped part this reads. Structural, so any reasoning part —
  *  including a `ContentPart` narrowed to `kind: "reasoning"` — is accepted. */
-export interface ReasoningTextSource {
+interface ReasoningTextSource {
   readonly payload?: unknown;
   readonly summary?: string;
   readonly opaque?: boolean;

package/src/protocol/reasoning.ts

@@ -1,6 +1,7 @@
 import type { CanonicalRequest, ReasoningEffort, ReasoningIntent } from "./canonical-model";
 import { budgetToLevel } from "./translation/thinking";
 import { isRecord } from "./codecs";
+import { DEEPSEEK_DEFAULT_EFFORT } from "./translation/dialect/thinking-ladder";
 
 /**
  * The effective reasoning effort for a canonical intent, deriving one from an
@@ -47,7 +48,7 @@ export function applyDeepSeekReasoning(payload: Record<string, unknown>): void {
   if (thinking === undefined) payload["thinking"] = { type: "enabled" };
   else if (type.length === 0) thinking["type"] = "enabled";
   if (typeof payload["reasoning_effort"] !== "string" || payload["reasoning_effort"].length === 0)
-    payload["reasoning_effort"] = "high";
+    payload["reasoning_effort"] = DEEPSEEK_DEFAULT_EFFORT;
 }
 
 /**
@@ -151,59 +152,13 @@ export function geminiThinkingOutputFloor(reasoning: CanonicalRequest["reasoning
 
 /**
  * Minimum output budget for a caller whose requested effort the ladder could
- * not serve as asked.
+ * not serve as asked. See the module doc for why both clamp directions need it.
+ * Only ever raises, and only to the model's own catalog limit.
  *
- * A wire ladder can only serve levels the upstream accepts, so a request for
- * `low` may be clamped up to whatever that model offers — `hy4-preview-f`
- * serves `high` and nothing else — and a request for `max` may be clamped down
- * to it. Either way the caller sized `max_tokens` for the effort it asked for,
- * and effort is not free: the applied level spends its budget on reasoning
- * before it writes the answer, so an answer that fit in 2048 tokens of visible
- * text no longer fits once the reasoning share is taken out of the same 2048.
- *
- * Both directions need the floor, because the mismatch is what costs tokens,
- * not its sign. A caller who asked for `max` with a 2048-token answer in mind
- * is owed the same headroom as one who asked for `low`: the applied level is
- * `high` either way, and `high` reasons out of that 2048 regardless.
- *
- * The symptom this removes is a truncated answer that an agent retries from
- * the top — reading as a loop ("let me do / let me go / let me do it") rather
- * than as a short limit.
- *
- * Only ever raises, and only to the model's own catalog limit: a caller whose
- * effort was served exactly as asked keeps its number, and no provider is
- * asked for more output than it declares.
+ * Re-exported from `translation/dialect/model-thinking` (the canonical helper);
+ * this shim keeps existing importers (e.g. buddy-chat-shared) stable.
  */
-export function clampedEffortOutputFloor(
-  requested: string | undefined,
-  applied: string | undefined,
-  modelOutputLimit: number | undefined,
-): number | undefined {
-  if (requested === undefined || applied === undefined) return undefined;
-  const from = BUDDY_LEVEL_RANK[requested.trim().toLowerCase()];
-  const to = BUDDY_LEVEL_RANK[applied.trim().toLowerCase()];
-  if (from === undefined || to === undefined || from === to) return undefined;
-  if (modelOutputLimit === undefined || !Number.isFinite(modelOutputLimit) || modelOutputLimit <= 0)
-    return undefined;
-  // Leave headroom instead of claiming the whole catalog limit: the caller's
-  // number was a real preference about answer size, and the goal is to stop
-  // truncating, not to spend the model's ceiling on every turn.
-  return Math.max(CLAMPED_EFFORT_MIN_OUTPUT_TOKENS, Math.floor(modelOutputLimit / 2));
-}
-
-const CLAMPED_EFFORT_MIN_OUTPUT_TOKENS = 16_384;
-
-const BUDDY_LEVEL_RANK: Readonly<Record<string, number>> = {
-  off: 0,
-  none: 0,
-  instant: 1,
-  minimal: 2,
-  low: 3,
-  medium: 4,
-  high: 5,
-  xhigh: 6,
-  max: 7,
-};
+export { outputFloorFor as clampedEffortOutputFloor } from "./translation/dialect/model-thinking";
 
 /** Builds the Anthropic thinking block from canonical reasoning intent. */
 export function buildAnthropicThinkingPayload(reasoning: ReasoningIntent): Record<string, unknown> {

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.