@bitkyc08/opencodex 2.6.26-preview.20260705 → 2.6.28-preview.20260707

package/src/responses/parser.ts

@@ -12,6 +12,8 @@ import type {
 } from "../types";
 import { namespacedToolName } from "../types";
 import { responsesRequestSchema } from "./schema";
+import { compactionItemToText } from "./compaction";
+import { decodeReasoningEnvelope } from "./reasoning-envelope";
 import { extractHostedWebSearch, WEB_SEARCH_TOOL_NAME } from "../web-search/synthetic-tool";
 
 function isObj(v: unknown): v is Record<string, unknown> {
@@ -37,7 +39,7 @@ function inputContentParts(blocks: unknown[] | string | undefined): string | Ocx
       if (b.image_url) {
         // Preserve the image as a structured part — adapters send it as a native image block.
         // NEVER inline the (often base64 data-URL) image_url as text: that explodes the token count.
-        parts.push({ type: "image", imageUrl: b.image_url, ...(b.detail ? { detail: b.detail } : {}) });
+        parts.push({ type: "image", imageUrl: b.image_url, ...(b.detail ? { detail: normalizeImageDetail(b.detail) } : {}) });
       } else {
         parts.push({ type: "text", text: `[image: ${b.file_id ?? "?"}]` }); // file_id ref → no inline data
       }
@@ -180,19 +182,30 @@ function outputToToolResultContent(output: string | unknown[] | undefined): stri
   let hasImage = false;
   for (const raw of output) {
     if (!isObj(raw)) continue;
-    if (raw.type === "output_text" || raw.type === "text") {
+    if (raw.type === "output_text" || raw.type === "text" || raw.type === "input_text") {
       if (typeof raw.text === "string") parts.push({ type: "text", text: raw.text });
     } else if (raw.type === "refusal" && typeof raw.refusal === "string") {
       parts.push({ type: "text", text: `[refusal: ${raw.refusal}]` });
     } else if (raw.type === "input_image" && typeof raw.image_url === "string") {
-      parts.push({ type: "image", imageUrl: raw.image_url, ...(typeof raw.detail === "string" ? { detail: raw.detail } : {}) });
+      parts.push({ type: "image", imageUrl: raw.image_url, ...(typeof raw.detail === "string" ? { detail: normalizeImageDetail(raw.detail) } : {}) });
       hasImage = true;
+    } else if (raw.type === "encrypted_content") {
+      // codex-rs FunctionCallOutputContentItem::EncryptedContent — opaque to routed models.
+      parts.push({ type: "text", text: "[encrypted content omitted]" });
     }
   }
   if (!hasImage) return parts.map(p => (p.type === "text" ? p.text : "")).join("");
   return parts;
 }
 
+/**
+ * codex-rs ImageDetail allows "original", but chat-completions providers only accept
+ * auto|low|high on image_url.detail — degrade "original" to "high" (the codex default).
+ */
+function normalizeImageDetail(detail: string): string {
+  return detail === "original" ? "high" : detail;
+}
+
 function findToolById(messages: OcxMessage[], callId: string): { name: string; namespace?: string } {
   for (let i = messages.length - 1; i >= 0; i--) {
     const m = messages[i];
@@ -218,6 +231,9 @@ export function parseRequest(body: unknown): OcxParsedRequest {
   // Tool specs surfaced by a prior tool_search (deferred tools, e.g. subagents). Codex does not
   // re-list these in `tools`, but chat models can only call listed tools — so we re-inject them.
   const loadedToolSpecs: unknown[] = [];
+  // Remote compaction v2: the input tail carries `{type:"compaction_trigger"}` and Codex expects a
+  // synthetic `{type:"compaction"}` output item (src/responses/compaction.ts). Flagged for the server.
+  let compactionRequest = false;
 
   if (typeof data.instructions === "string" && data.instructions.length > 0) {
     systemPrompt.push(data.instructions);
@@ -229,6 +245,27 @@ export function parseRequest(body: unknown): OcxParsedRequest {
     for (const item of data.input) {
       const effectiveType = (item as { type?: string }).type ?? ("role" in item ? "message" : undefined);
 
+      if (effectiveType === "compaction_trigger") {
+        compactionRequest = true;
+        continue;
+      }
+
+      if (effectiveType === "compaction" || effectiveType === "compaction_summary" || effectiveType === "context_compaction") {
+        // A stored summary from a previous compaction. Decode our ocx1 envelope into plain text so
+        // the routed model keeps the compacted context; real OpenAI-encrypted blobs degrade to a note.
+        // `context_compaction` (encrypted_content optional) is codex-rs's local-compaction marker;
+        // with no payload it is a pure marker (the summary follows as its own user message), so it
+        // is dropped silently. It must NOT flag _compactionRequest.
+        const encrypted = (item as { encrypted_content?: unknown }).encrypted_content;
+        if (effectiveType === "context_compaction" && typeof encrypted !== "string") continue;
+        messages.push({
+          role: "user",
+          content: compactionItemToText(typeof encrypted === "string" ? encrypted : undefined),
+          timestamp: now,
+        });
+        continue;
+      }
+
       if (effectiveType === "message") {
         const msg = item as { role?: string; content?: unknown };
         switch (msg.role) {
@@ -254,13 +291,20 @@ export function parseRequest(body: unknown): OcxParsedRequest {
       }
 
       if (effectiveType === "reasoning") {
-        const reasoning = item as { id?: string; summary?: { text: string }[]; content?: { text: string }[] };
+        const reasoning = item as { id?: string; summary?: { text: string }[]; content?: { text: string }[]; encrypted_content?: string };
         const fromSummary = (reasoning.summary ?? []).map(c => c.text).join("");
         const text = fromSummary || (reasoning.content ?? []).map(c => c.text).join("");
+        // ocxr1 envelope: the REAL Anthropic signature (+ redacted blocks, + hidden signed text)
+        // captured by the bridge. Native OpenAI-encrypted blobs decode to null and keep today's
+        // placeholder signature (which the anthropic adapter correctly rejects on replay).
+        const envelope = typeof reasoning.encrypted_content === "string"
+          ? decodeReasoningEnvelope(reasoning.encrypted_content)
+          : null;
         const thinking: OcxThinkingContent = {
           type: "thinking",
-          thinking: text,
-          signature: JSON.stringify(reasoning),
+          thinking: envelope?.txt || text,
+          signature: envelope?.sig ?? JSON.stringify(reasoning),
+          ...(envelope?.red ? { redacted: envelope.red } : {}),
           ...(reasoning.id ? { itemId: reasoning.id } : {}),
         };
         ensureAssistantPlaceholder(messages, data.model, now).content.push(thinking);
@@ -302,6 +346,32 @@ export function parseRequest(body: unknown): OcxParsedRequest {
         continue;
       }
 
+      if (effectiveType === "local_shell_call") {
+        // codex-rs LocalShellCall replay: pair it as an assistant toolCall so the subsequent
+        // function_call_output (same call_id) doesn't become an orphaned tool result.
+        const call = item as { id?: string; call_id?: string; action?: { type?: string; command?: string[] } };
+        const callId = call.call_id ?? call.id;
+        if (callId) {
+          const command = Array.isArray(call.action?.command) ? call.action.command : [];
+          ensureAssistantPlaceholder(messages, data.model, now).content.push({
+            type: "toolCall", id: callId, name: "shell",
+            arguments: command.length > 0 ? { command } : {},
+          });
+        }
+        continue;
+      }
+
+      if (effectiveType === "web_search_call") {
+        // Replayed hosted web-search evidence. Textify it into assistant history so the model
+        // knows the search already ran (prevents re-search loops); there is no output to pair.
+        const call = item as { action?: { type?: string; query?: string } };
+        const query = typeof call.action?.query === "string" ? call.action.query : "";
+        ensureAssistantPlaceholder(messages, data.model, now).content.push({
+          type: "text", text: query ? `[web search performed: ${query}]` : "[web search performed]",
+        });
+        continue;
+      }
+
       if (effectiveType === "tool_search_call") {
         // Preserve the model's prior tool_search call as an assistant tool call so multi-turn
         // history stays complete (otherwise the model re-issues tool_search forever).
@@ -316,7 +386,7 @@ export function parseRequest(body: unknown): OcxParsedRequest {
 
       if (effectiveType === "tool_search_output") {
         // Pair the tool_search call with its result so the model sees what was loaded.
-        const out = item as { call_id?: string; tools?: unknown[] };
+        const out = item as { call_id?: string; status?: string; tools?: unknown[] };
         const specs = Array.isArray(out.tools) ? (out.tools as Record<string, unknown>[]) : [];
         loadedToolSpecs.push(...specs);
         // List the EXACT wire names the model must call (flattened for namespaced specs), matching
@@ -331,12 +401,15 @@ export function parseRequest(body: unknown): OcxParsedRequest {
             wireNames.push(spec.name);
           }
         }
+        const failed = typeof out.status === "string" && out.status !== "completed" && out.status !== "success";
         messages.push({
           role: "toolResult", toolCallId: out.call_id ?? "", toolName: "tool_search",
-          content: wireNames.length
-            ? `Tool search loaded these tools — they are now in your available tools. Call one by its EXACT name: ${wireNames.join(", ")}.`
-            : "Tool search returned no tools.",
-          isError: false, timestamp: now,
+          content: failed && wireNames.length === 0
+            ? `Tool search failed (status: ${out.status}).`
+            : wireNames.length
+              ? `Tool search loaded these tools — they are now in your available tools. Call one by its EXACT name: ${wireNames.join(", ")}.`
+              : "Tool search returned no tools.",
+          isError: failed && wireNames.length === 0, timestamp: now,
         });
         continue;
       }
@@ -353,12 +426,14 @@ export function parseRequest(body: unknown): OcxParsedRequest {
       }
 
       if (effectiveType === "custom_tool_call_output") {
-        const output = item as { call_id: string; output: string };
+        const output = item as { call_id: string; output: string | unknown[] };
         const toolInfo = findToolById(messages, output.call_id);
         messages.push({
           role: "toolResult", toolCallId: output.call_id,
           toolName: toolInfo.name, toolNamespace: toolInfo.namespace,
-          content: output.output ?? "", isError: false, timestamp: now,
+          // Same payload shape as function_call_output (codex-rs FunctionCallOutputPayload):
+          // string or content items — normalize arrays instead of leaking raw wire blocks.
+          content: outputToToolResultContent(output.output), isError: false, timestamp: now,
         });
       }
     }
@@ -416,6 +491,7 @@ export function parseRequest(body: unknown): OcxParsedRequest {
     _rawBody: body,
     ...(webSearch ? { _webSearch: webSearch } : {}),
     ...(structuredOutput ? { _structuredOutput: true } : {}),
+    ...(compactionRequest ? { _compactionRequest: true } : {}),
   };
 }
 

package/src/responses/reasoning-envelope.ts

@@ -0,0 +1,52 @@
+/**
+ * Anthropic extended-thinking signature round-trip through Codex's `encrypted_content` slot.
+ *
+ * Anthropic requires the previous assistant turn's `thinking`/`redacted_thinking` blocks to be
+ * replayed VERBATIM (with their signatures) while extended thinking is enabled; a signature-less
+ * replay 400s ("Expected `thinking` or `redacted_thinking`, but found `tool_use`"). Codex round-trips
+ * whatever `encrypted_content` a reasoning output item carries (include: reasoning.encrypted_content
+ * is set whenever reasoning is on — codex-rs client.rs), so the proxy smuggles the real Anthropic
+ * signature (and any redacted blocks) inside a transparent `ocxr1:` + base64(JSON) envelope.
+ *
+ * Native OpenAI-encrypted blobs (no ocxr1 prefix) are left untouched by the decoder, and the
+ * passthrough scrub strips ocxr1 envelopes before native forwarding.
+ */
+
+export const OCX_REASONING_PREFIX = "ocxr1:";
+
+export interface ReasoningEnvelope {
+  /** Anthropic thinking-block signature (signature_delta), if captured. */
+  sig?: string;
+  /** Raw redacted_thinking block data payloads, order preserved. */
+  red?: string[];
+  /**
+   * Hidden thinking text (hideThinkingSummary providers): the signature signs this exact text,
+   * so replay needs it even though the visible summary was suppressed.
+   */
+  txt?: string;
+}
+
+export function encodeReasoningEnvelope(envelope: ReasoningEnvelope): string {
+  return OCX_REASONING_PREFIX + Buffer.from(JSON.stringify(envelope), "utf-8").toString("base64");
+}
+
+/** Decode an ocxr1 envelope; returns null for native (OpenAI-encrypted) blobs or garbage. */
+export function decodeReasoningEnvelope(encryptedContent: string): ReasoningEnvelope | null {
+  if (!encryptedContent.startsWith(OCX_REASONING_PREFIX)) return null;
+  try {
+    const parsed: unknown = JSON.parse(Buffer.from(encryptedContent.slice(OCX_REASONING_PREFIX.length), "base64").toString("utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    const obj = parsed as { sig?: unknown; red?: unknown };
+    const envelope: ReasoningEnvelope = {};
+    if (typeof obj.sig === "string") envelope.sig = obj.sig;
+    if (Array.isArray(obj.red)) {
+      const red = obj.red.filter((r): r is string => typeof r === "string");
+      if (red.length > 0) envelope.red = red;
+    }
+    const txt = (parsed as { txt?: unknown }).txt;
+    if (typeof txt === "string" && txt.length > 0) envelope.txt = txt;
+    return envelope.sig || envelope.red || envelope.txt ? envelope : null;
+  } catch {
+    return null;
+  }
+}

package/src/responses/schema.ts

@@ -4,7 +4,8 @@ const inputTextSchema = z.object({ type: z.literal("input_text"), text: z.string
 const plainTextSchema = z.object({ type: z.literal("text"), text: z.string() });
 const inputImageBlockSchema = z.object({
   type: z.literal("input_image"),
-  detail: z.enum(["auto", "low", "high"]).optional(),
+  // codex-rs ImageDetail: auto|low|high|original (view_image --detail original).
+  detail: z.enum(["auto", "low", "high", "original"]).optional(),
   image_url: z.string().optional(),
   file_id: z.string().optional(),
 }).refine(v => typeof v.image_url === "string" || typeof v.file_id === "string", {
@@ -20,9 +21,17 @@ const outputTextSchema = z.object({ type: z.literal("output_text"), text: z.stri
 const outputRefusalSchema = z.object({ type: z.literal("refusal"), refusal: z.string() });
 const summaryTextSchema = z.object({ type: z.literal("summary_text"), text: z.string() });
 const reasoningTextSchema = z.object({ type: z.literal("reasoning_text"), text: z.string() });
+// codex-rs FunctionCallOutputContentItem (protocol/src/models.rs): input_text | input_image | encrypted_content.
+const encryptedContentBlockSchema = z.object({ type: z.literal("encrypted_content"), encrypted_content: z.string() });
 
 const inputContentBlockSchema = z.union([inputTextSchema, plainTextSchema, inputImageBlockSchema, inputFileBlockSchema]);
 const outputContentBlockSchema = z.union([outputTextSchema, plainTextSchema, outputRefusalSchema]);
+// Tool outputs on the wire mix codex-rs FunctionCallOutputContentItem with legacy output blocks.
+const toolOutputContentBlockSchema = z.union([
+  outputTextSchema, plainTextSchema, outputRefusalSchema,
+  inputTextSchema, inputImageBlockSchema, encryptedContentBlockSchema,
+]);
+const toolOutputSchema = z.union([z.string(), z.array(toolOutputContentBlockSchema)]);
 
 const userMessageItemSchema = z.object({
   type: z.literal("message").optional(),
@@ -44,6 +53,8 @@ const reasoningItemSchema = z.object({
   id: z.string().optional(),
   summary: z.array(summaryTextSchema).optional(),
   content: z.array(reasoningTextSchema).optional(),
+  // Round-tripped opaque payload (native OpenAI encryption OR the proxy's ocxr1 envelope).
+  encrypted_content: z.string().optional(),
 });
 const functionCallItemSchema = z.object({
   type: z.literal("function_call"),
@@ -56,7 +67,7 @@ const functionCallItemSchema = z.object({
 const functionCallOutputItemSchema = z.object({
   type: z.literal("function_call_output"),
   call_id: z.string().min(1),
-  output: z.union([z.string(), z.array(z.union([outputContentBlockSchema, inputImageBlockSchema]))]).optional(),
+  output: toolOutputSchema.optional(),
 });
 const customToolCallItemSchema = z.object({
   type: z.literal("custom_tool_call"),
@@ -68,7 +79,8 @@ const customToolCallItemSchema = z.object({
 const customToolCallOutputItemSchema = z.object({
   type: z.literal("custom_tool_call_output"),
   call_id: z.string().min(1),
-  output: z.string(),
+  // codex-rs CustomToolCallOutput carries FunctionCallOutputPayload: string OR content items.
+  output: toolOutputSchema,
 });
 
 export const inputItemSchema = z.union([

package/src/responses/state.ts

@@ -1,5 +1,14 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { atomicWriteFile, getConfigDir } from "../config";
+
 const MAX_STORED_RESPONSES = 1_000;
 const RESPONSE_TTL_MS = 60 * 60 * 1_000;
+const SNAPSHOT_DEBOUNCE_MS = 2_000;
+/** Entries whose serialized size exceeds this are kept in memory but skipped on disk: inputs can
+ * carry base64 `input_image` data URLs, and one screenshot-heavy thread must not balloon the file. */
+const SNAPSHOT_ENTRY_MAX_BYTES = 2 * 1024 * 1024;
+const SNAPSHOT_TOTAL_MAX_BYTES = 24 * 1024 * 1024;
 
 interface StoredResponseState {
   createdAt: number;
@@ -9,11 +18,92 @@ interface StoredResponseState {
 }
 
 const states = new Map<string, StoredResponseState>();
+let loaded = false;
+let persistTimer: ReturnType<typeof setTimeout> | null = null;
+let pendingPersistPath: string | null = null;
 
 function now(): number {
   return Date.now();
 }
 
+function snapshotPath(): string {
+  return join(getConfigDir(), "responses-state.json");
+}
+
+/**
+ * Best-effort disk snapshot so previous_response_id chains survive a proxy restart (the
+ * dominant expansion-miss cause: an in-memory-only store dies with the process, and the next
+ * chained turn then reaches the upstream as a naked delta). Load is lazy on first store access;
+ * persistence is debounced + unref'd so the hot path never blocks and the process can exit.
+ * Every disk failure is swallowed — the snapshot is a cache, not a source of truth.
+ */
+function ensureLoaded(): void {
+  if (loaded) return;
+  loaded = true;
+  try {
+    const path = snapshotPath();
+    if (!existsSync(path)) return;
+    const raw = JSON.parse(readFileSync(path, "utf-8")) as { version?: unknown; states?: unknown };
+    if (raw.version !== 1 || !Array.isArray(raw.states)) return;
+    for (const entry of raw.states) {
+      if (!Array.isArray(entry) || entry.length !== 2) continue;
+      const [id, state] = entry as [unknown, unknown];
+      if (typeof id !== "string" || !state || typeof state !== "object") continue;
+      const rec = state as StoredResponseState;
+      if (typeof rec.createdAt !== "number" || !Array.isArray(rec.items)) continue;
+      states.set(id, rec);
+    }
+    pruneResponses();
+  } catch {
+    /* missing/corrupt snapshot: start empty */
+  }
+}
+
+function persistNow(path: string): void {
+  if (persistTimer) {
+    clearTimeout(persistTimer);
+    persistTimer = null;
+  }
+  pendingPersistPath = null;
+  try {
+    const entries: [string, StoredResponseState][] = [];
+    let total = 0;
+    // Newest-first so the most recent chains survive both caps.
+    for (const entry of [...states].reverse()) {
+      const size = JSON.stringify(entry).length;
+      if (size > SNAPSHOT_ENTRY_MAX_BYTES) continue;
+      if (total + size > SNAPSHOT_TOTAL_MAX_BYTES) break;
+      total += size;
+      entries.push(entry);
+    }
+    entries.reverse();
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    // mkdirSync's mode only applies on creation — re-harden an existing config dir so the
+    // conversation-content snapshot never lands in a group/world-readable directory.
+    try { chmodSync(dirname(path), 0o700); } catch { /* best-effort (e.g. Windows) */ }
+    atomicWriteFile(path, JSON.stringify({ version: 1, states: entries }));
+  } catch {
+    /* best-effort: disk trouble must never affect request handling */
+  }
+}
+
+function schedulePersist(): void {
+  if (persistTimer) return;
+  // Resolve the target path NOW: tests (and anything else) may swap OPENCODEX_HOME before the
+  // debounce fires, and a late write must land in the home that owned the recorded state.
+  pendingPersistPath = snapshotPath();
+  const path = pendingPersistPath;
+  persistTimer = setTimeout(() => persistNow(path), SNAPSHOT_DEBOUNCE_MS);
+  (persistTimer as { unref?: () => void }).unref?.();
+}
+
+/** Flush any pending debounced snapshot write (graceful shutdown / deterministic tests). */
+export function flushResponseState(): void {
+  if (!persistTimer) return;
+  // Use the path captured when the write was scheduled — OPENCODEX_HOME may have moved since.
+  persistNow(pendingPersistPath ?? snapshotPath());
+}
+
 function inputItems(input: unknown): unknown[] {
   if (input === undefined) return [];
   if (Array.isArray(input)) return input;
@@ -37,6 +127,7 @@ export function expandPreviousResponseInput(body: unknown): unknown {
   const request = body as Record<string, unknown>;
   const previousId = typeof request.previous_response_id === "string" ? request.previous_response_id : undefined;
   if (!previousId) return body;
+  ensureLoaded();
   pruneResponses();
   const previous = states.get(previousId);
   if (!previous) return body;
@@ -48,6 +139,7 @@ export function expandPreviousResponseInput(body: unknown): unknown {
 
 export function previousResponseConversationId(responseId: string | undefined): string | undefined {
   if (!responseId) return undefined;
+  ensureLoaded();
   pruneResponses();
   return states.get(responseId)?.conversationId;
 }
@@ -56,12 +148,19 @@ export function rememberResponseState(
   requestBody: unknown,
   response: { id?: unknown; output?: unknown; status?: unknown },
   conversationId?: string,
+  opts?: { force?: boolean },
 ): void {
   if (!requestBody || typeof requestBody !== "object" || Array.isArray(requestBody)) return;
   const request = requestBody as Record<string, unknown>;
-  if (request.store === false) return;
+  // `force` bypasses only the store:false skip: Codex sends `store:false` on every non-Azure
+  // HTTP request (and WS inherits it), yet its WS turns still chain with previous_response_id.
+  // The passthrough branch records with force so those chains can be expanded locally; the
+  // store stays in-memory with a 1h TTL, so this is a proxy-internal continuation cache, not
+  // real server-side response storage.
+  if (request.store === false && !opts?.force) return;
   if (typeof response.id !== "string" || !Array.isArray(response.output)) return;
   if (response.status !== undefined && response.status !== "completed") return;
+  ensureLoaded();
   states.set(response.id, {
     createdAt: now(),
     items: [...inputItems(request.input), ...response.output],
@@ -76,8 +175,24 @@ export function rememberResponseState(
     }),
   });
   pruneResponses();
+  schedulePersist();
 }
 
-export function clearResponseStateForTests(): void {
+/** Memory-only reset (simulates a process restart: the snapshot file survives). */
+export function clearResponseStateMemoryForTests(): void {
+  if (persistTimer) {
+    clearTimeout(persistTimer);
+    persistTimer = null;
+  }
   states.clear();
+  loaded = false;
+}
+
+export function clearResponseStateForTests(): void {
+  clearResponseStateMemoryForTests();
+  try {
+    unlinkSync(snapshotPath());
+  } catch {
+    /* no snapshot on disk */
+  }
 }

package/src/router.ts

@@ -96,6 +96,7 @@ function routedProviderConfig(providerName: string, provider: OcxProviderConfig)
   const noPenaltyModels = mergeStringArray(registryEntry.noPenaltyModels, provider.noPenaltyModels);
   const autoToolChoiceOnlyModels = mergeStringArray(registryEntry.autoToolChoiceOnlyModels, provider.autoToolChoiceOnlyModels);
   const preserveReasoningContentModels = mergeStringArray(registryEntry.preserveReasoningContentModels, provider.preserveReasoningContentModels);
+  const thinkingToggleModels = mergeStringArray(registryEntry.thinkingToggleModels, provider.thinkingToggleModels);
 
   return {
     ...provider,
@@ -124,6 +125,7 @@ function routedProviderConfig(providerName: string, provider: OcxProviderConfig)
     ...(noPenaltyModels ? { noPenaltyModels } : {}),
     ...(autoToolChoiceOnlyModels ? { autoToolChoiceOnlyModels } : {}),
     ...(preserveReasoningContentModels ? { preserveReasoningContentModels } : {}),
+    ...(thinkingToggleModels ? { thinkingToggleModels } : {}),
   };
 }