@bitkyc08/opencodex 2.6.32 → 2.7.0

package/src/codex/warmup.ts

@@ -1,16 +1,19 @@
 export class CodexWarmupError extends Error {
   code: "http_status" | "missing_body" | "stream_failed" | "stream_incomplete" | "stream_error" | "invalid_sse" | "no_terminal" | "transport";
   status?: number;
+  /** Upstream error detail extracted from the response body (truncated to 512 chars). */
+  upstreamDetail?: string;
 
   constructor(
     code: CodexWarmupError["code"],
     message = "Codex warmup failed",
-    options: { status?: number; cause?: unknown } = {},
+    options: { status?: number; cause?: unknown; upstreamDetail?: string } = {},
   ) {
     super(message);
     this.name = "CodexWarmupError";
     this.code = code;
     this.status = options.status;
+    this.upstreamDetail = options.upstreamDetail;
     if (options.cause !== undefined) this.cause = options.cause;
   }
 }
@@ -24,11 +27,39 @@ export interface CodexWarmupOptions {
 
 const CODEX_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
 const DEFAULT_MODEL = "gpt-5.4-mini";
+const FALLBACK_MODELS = ["gpt-5.5"];
 const DEFAULT_TIMEOUT_MS = 30_000;
+const MAX_ERROR_BODY_BYTES = 2048;
+
+/** Read the first MAX_ERROR_BODY_BYTES of a response body and extract an error message. */
+async function readErrorDetail(res: Response): Promise<string | undefined> {
+  try {
+    const text = await res.text();
+    const trimmed = text.slice(0, MAX_ERROR_BODY_BYTES);
+    try {
+      const json = JSON.parse(trimmed) as Record<string, unknown>;
+      // ChatGPT backend error shape: { error: { message: "..." } } or { detail: "..." }
+      const nested = json.error;
+      if (nested && typeof nested === "object" && typeof (nested as Record<string, unknown>).message === "string") {
+        return ((nested as Record<string, unknown>).message as string).slice(0, 512);
+      }
+      if (typeof json.detail === "string") return json.detail.slice(0, 512);
+      if (typeof json.error === "string") return (json.error as string).slice(0, 512);
+      if (typeof json.message === "string") return json.message.slice(0, 512);
+    } catch {
+      // Non-JSON response body may contain sensitive data (tokens, credentials).
+      // Only surface structured error messages, never raw text.
+    }
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
 
 function safeWarmupReason(err: unknown): string {
   if (err instanceof CodexWarmupError) {
-    return err.status ? `${err.code}:${err.status}` : err.code;
+    const base = err.status ? `${err.code}:${err.status}` : err.code;
+    return err.upstreamDetail ? `${base} — ${err.upstreamDetail}` : base;
   }
   return "transport";
 }
@@ -99,7 +130,7 @@ async function drainWarmupSse(body: ReadableStream<Uint8Array>): Promise<void> {
   }
 }
 
-export async function warmCodexAccount(options: CodexWarmupOptions): Promise<void> {
+async function tryWarmup(options: CodexWarmupOptions, model: string): Promise<void> {
   let res: Response;
   try {
     res = await fetch(CODEX_RESPONSES_URL, {
@@ -110,7 +141,7 @@ export async function warmCodexAccount(options: CodexWarmupOptions): Promise<voi
         "Content-Type": "application/json",
       },
       body: JSON.stringify({
-        model: options.model?.trim() || DEFAULT_MODEL,
+        model,
         instructions: "Reply with OK.",
         input: "hi",
         stream: true,
@@ -123,8 +154,11 @@ export async function warmCodexAccount(options: CodexWarmupOptions): Promise<voi
   }
 
   if (!res.ok) {
-    await res.body?.cancel().catch(() => {});
-    throw new CodexWarmupError("http_status", "Codex warmup was rejected", { status: res.status });
+    const upstreamDetail = await readErrorDetail(res);
+    throw new CodexWarmupError("http_status", "Codex warmup was rejected", {
+      status: res.status,
+      upstreamDetail,
+    });
   }
   if (!res.body) throw new CodexWarmupError("missing_body");
 
@@ -135,3 +169,25 @@ export async function warmCodexAccount(options: CodexWarmupOptions): Promise<voi
   }
 }
 
+export async function warmCodexAccount(options: CodexWarmupOptions): Promise<void> {
+  const primaryModel = options.model?.trim() || DEFAULT_MODEL;
+  try {
+    await tryWarmup(options, primaryModel);
+    return;
+  } catch (err) {
+    // Retry with fallback models on 400 (model may not be available for this account).
+    if (!(err instanceof CodexWarmupError) || err.status !== 400) throw err;
+    let lastErr = err;
+    for (const fallback of FALLBACK_MODELS) {
+      if (fallback === primaryModel) continue;
+      try {
+        await tryWarmup(options, fallback);
+        return;
+      } catch (retryErr) {
+        if (retryErr instanceof CodexWarmupError) lastErr = retryErr;
+      }
+    }
+    throw lastErr;
+  }
+}
+

package/src/config.ts

@@ -149,12 +149,14 @@ const configSchema = z.object({
 
 /**
  * Default featured subagent models (native GPT) seeded on a fresh install and when `subagentModels`
- * is unset. Codex's spawn_agent advertises the first 5 featured catalog entries; these are the GPT
- * natives the installed Codex actually ships. The user can remove any in the GUI — once they set the
- * list (even to []), it is respected, so removals persist (start-up only seeds the UNSET case).
- * Kept to ids ChatGPT accepts; the start-up seed prefers the live catalog's native slugs.
+ * is unset. Codex's spawn_agent advertises the first 5 featured catalog entries, so this seed is a
+ * deliberate 5-list: frontier gpt-5.5 first, the gpt-5.6 preview trio, and gpt-5.4-mini as the cheap
+ * tier. gpt-5.4 / gpt-5.3-codex-spark stay selectable in the GUI's available list. The user can
+ * remove any in the GUI — once they set the list (even to []), it is respected, so removals persist
+ * (start-up only seeds the UNSET case). Kept to ids ChatGPT accepts; the start-up seed prefers the
+ * live catalog's native slugs.
  */
-export const DEFAULT_SUBAGENT_MODELS = ["gpt-5.5", "gpt-5.4", "gpt-5.4-mini", "gpt-5.3-codex-spark"];
+export const DEFAULT_SUBAGENT_MODELS = ["gpt-5.5", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "gpt-5.4-mini"];
 
 export function getConfigDir(): string {
   return resolveConfigDir();

package/src/lib/debug-log-buffer.ts

@@ -0,0 +1,42 @@
+/** In-memory ring buffer of debug log lines for `ocx debug logs` / GUI tailing. */
+
+export interface DebugLogEntry {
+  /** Monotonic cursor for pagination; survives same-millisecond bursts. */
+  seq: number;
+  at: number;
+  line: string;
+}
+
+const MAX_LINES = 2_000;
+const buffer: DebugLogEntry[] = [];
+const listeners = new Set<(entry: DebugLogEntry) => void>();
+let nextSeq = 1;
+
+export function appendDebugLogLine(line: string): void {
+  const entry: DebugLogEntry = { seq: nextSeq++, at: Date.now(), line };
+  buffer.push(entry);
+  if (buffer.length > MAX_LINES) buffer.splice(0, buffer.length - MAX_LINES);
+  for (const listener of listeners) {
+    try { listener(entry); } catch { /* listeners must not break logging */ }
+  }
+}
+
+export function getDebugLogEntries(options?: { after?: number; limit?: number }): DebugLogEntry[] {
+  const after = options?.after ?? 0;
+  const limit = options?.limit ?? 500;
+  const filtered = after > 0 ? buffer.filter(entry => entry.seq > after) : buffer;
+  if (filtered.length <= limit) return filtered;
+  return filtered.slice(-limit);
+}
+
+export function subscribeDebugLogEntries(listener: (entry: DebugLogEntry) => void): () => void {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+/** Test isolation. */
+export function resetDebugLogBufferForTests(): void {
+  buffer.length = 0;
+  listeners.clear();
+  nextSeq = 1;
+}

package/src/lib/debug-settings.ts

@@ -0,0 +1,84 @@
+/**
+ * Runtime-controllable debug flags.
+ * Provider debug: `ocx debug provider on|off|status|reset|logs [-f]` (or OCX_DEBUG=1 on start).
+ * Usage capture: `ocx debug usage on|off|status|reset|logs [-f]` (or OPENCODEX_USAGE_DEBUG=1).
+ * `/api/debug` and `ocx debug` override env defaults without restart.
+ */
+
+export const DEBUG_ENV = {
+  debug: "OCX_DEBUG",
+  usage: "OPENCODEX_USAGE_DEBUG",
+} as const;
+
+/** Legacy env var that still enables provider debug logging. */
+const LEGACY_DEBUG_ENV = ["OCX_DEBUG_FRAMES"] as const;
+
+export type DebugFlag = keyof typeof DEBUG_ENV;
+
+export interface DebugSettingsView {
+  enabled: boolean;
+  usage: boolean;
+  runtimeOverride: Partial<Record<DebugFlag, boolean>>;
+  env: Record<DebugFlag, boolean>;
+}
+
+const runtimeOverride: Partial<Record<DebugFlag, boolean>> = {};
+
+function envFlag(name: string): boolean {
+  return process.env[name] === "1";
+}
+
+function legacyDebugEnvEnabled(): boolean {
+  return LEGACY_DEBUG_ENV.some(name => envFlag(name));
+}
+
+export function isDebugEnabled(): boolean {
+  if (runtimeOverride.debug !== undefined) return runtimeOverride.debug;
+  return envFlag(DEBUG_ENV.debug) || legacyDebugEnvEnabled();
+}
+
+/** @deprecated Use isDebugEnabled(). */
+export function isFramesDebugEnabled(): boolean {
+  return isDebugEnabled();
+}
+
+export function isUsageDebugEnabled(): boolean {
+  if (runtimeOverride.usage !== undefined) return runtimeOverride.usage;
+  return envFlag(DEBUG_ENV.usage);
+}
+
+export function getDebugSettings(): DebugSettingsView {
+  return {
+    enabled: isDebugEnabled(),
+    usage: isUsageDebugEnabled(),
+    runtimeOverride: { ...runtimeOverride },
+    env: {
+      debug: envFlag(DEBUG_ENV.debug) || legacyDebugEnvEnabled(),
+      usage: envFlag(DEBUG_ENV.usage),
+    },
+  };
+}
+
+export function setDebugSettings(partial: Partial<Record<DebugFlag, boolean>>): DebugSettingsView {
+  for (const key of ["debug", "usage"] as const) {
+    if (partial[key] !== undefined) runtimeOverride[key] = partial[key];
+  }
+  return getDebugSettings();
+}
+
+export function clearDebugSetting(flag: DebugFlag): DebugSettingsView {
+  delete runtimeOverride[flag];
+  return getDebugSettings();
+}
+
+export function clearDebugSettings(): DebugSettingsView {
+  for (const key of ["debug", "usage"] as const) {
+    delete runtimeOverride[key];
+  }
+  return getDebugSettings();
+}
+
+/** Test isolation: drop runtime overrides only (env vars untouched). */
+export function resetDebugSettingsForTests(): void {
+  clearDebugSettings();
+}

package/src/lib/debug.ts

@@ -1,21 +1,30 @@
+import { appendDebugLogLine } from "./debug-log-buffer";
+import { isDebugEnabled } from "./debug-settings";
 import { redactSecrets } from "./redact";
 
-// Opt-in frame-drop visibility. The streaming path is intentionally quiet (no unconditional
-// console output), so this no-ops unless OCX_DEBUG_FRAMES=1. Lets a malformed/chunk-split
-// upstream frame be detected instead of silently truncating content.
-function debugFramesEnabled(): boolean {
-  return process.env.OCX_DEBUG_FRAMES === "1";
+function emitDebugLine(line: string): void {
+  if (!isDebugEnabled()) return;
+  try {
+    appendDebugLogLine(line);
+    console.error(line);
+  } catch {
+    /* diagnostics must never affect request handling */
+  }
 }
 
+// Opt-in provider diagnostics. Streaming adapters stay quiet unless provider debug is on
+// (`ocx debug provider on`, GUI Logs toggle, or OCX_DEBUG=1). Tail with `ocx debug provider logs -f`.
+
 export function debugDroppedFrame(adapter: string, payload: string): void {
-  if (!debugFramesEnabled()) return;
-  console.error(`[ocx:frame-drop] ${adapter}: dropped malformed upstream frame (payload redacted, bytes=${payload.length})`);
+  if (!isDebugEnabled()) return;
+  emitDebugLine(`[ocx:frame-drop] ${adapter}: dropped malformed upstream frame (payload redacted, bytes=${payload.length})`);
 }
 
+/** Provider-agnostic diagnostic logging: `[ocx:<adapter>:<event>] {...}`. */
 export function debugProviderDiagnostic(adapter: string, event: string, details: Record<string, unknown>): void {
-  if (!debugFramesEnabled()) return;
+  if (!isDebugEnabled()) return;
   try {
-    console.error(`[ocx:${adapter}:${event}] ${JSON.stringify(redactSecrets(details))}`);
+    emitDebugLine(`[ocx:${adapter}:${event}] ${JSON.stringify(redactSecrets(details))}`);
   } catch {
     /* diagnostics must never affect request handling */
   }

package/src/lib/errors.ts

@@ -30,7 +30,10 @@ export function classifyError(status: number, type: string, message: string): Oc
     text.includes("rate limit") ||
     text.includes("rate limited") ||
     text.includes("too many requests") ||
-    text.includes("throttlingexception")
+    text.includes("resource_exhausted") ||
+    text.includes("resource exhausted") ||
+    text.includes("throttlingexception") ||
+    text.includes("throttling")
   ) {
     return { message, type: "rate_limit_error", code: "rate_limit_exceeded" };
   }
@@ -81,3 +84,103 @@ export function classifyError(status: number, type: string, message: string): Oc
   }
   return { message, type, code: type || null };
 }
+
+/** Best-effort parse of a retry delay embedded in an upstream error message. */
+export function parseRetryAfterFromMessage(message: string): number | undefined {
+  const patterns = [
+    /try again in (\d+(?:\.\d+)?)\s*s(?:ec(?:ond)?s?)?/i,
+    /retry after (\d+(?:\.\d+)?)\s*s(?:ec(?:ond)?s?)?/i,
+    /retry[- ]after[:\s]+(\d+)/i,
+  ];
+  for (const pattern of patterns) {
+    const match = message.match(pattern);
+    if (!match?.[1]) continue;
+    const seconds = Number.parseFloat(match[1]);
+    if (Number.isFinite(seconds) && seconds > 0) return Math.ceil(seconds);
+  }
+  return undefined;
+}
+
+/** Infer HTTP status from adapter terminal error text (provider-agnostic keyword matching). */
+export function inferHttpStatusFromAdapterMessage(message: string): number {
+  const lower = message.toLowerCase();
+  if (
+    lower.includes("resource_exhausted") ||
+    lower.includes("resource exhausted") ||
+    lower.includes("rate limit") ||
+    lower.includes("too many requests") ||
+    lower.includes("throttling")
+  ) return 429;
+  if (
+    lower.includes("unauthenticated") ||
+    lower.includes("unauthorized") ||
+    lower.includes("permission_denied") ||
+    lower.includes("permission denied") ||
+    lower.includes("forbidden") ||
+    lower.includes("invalid token") ||
+    lower.includes("expired token") ||
+    lower.includes("authentication") ||
+    lower.includes("access denied")
+  ) return 401;
+  if (
+    lower.includes("unavailable") ||
+    lower.includes("overloaded") ||
+    lower.includes("temporarily") ||
+    lower.includes("server is busy")
+  ) return 503;
+  if (
+    lower.includes("invalid") ||
+    lower.includes("not found") ||
+    lower.includes("unsupported") ||
+    lower.includes("malformed") ||
+    lower.includes("unimplemented")
+  ) return 400;
+  if (
+    lower.includes("timed out") ||
+    lower.includes("timeout") ||
+    lower.includes("etimedout") ||
+    lower.includes("deadline")
+  ) return 504;
+  return 502;
+}
+
+/** Map an adapter terminal error message to HTTP status + classified Codex error payload. */
+export function adapterFailureFromMessage(message: string): { httpStatus: number; error: OcxErrorPayload } {
+  const httpStatus = inferHttpStatusFromAdapterMessage(message);
+  let finalMessage = message;
+  const retryAfterSeconds = parseRetryAfterFromMessage(message);
+  if (retryAfterSeconds && !/please try again in /i.test(message)) {
+    finalMessage = `${message} Please try again in ${retryAfterSeconds}s.`;
+  }
+  const errorType = httpStatus === 429
+    ? "rate_limit_error"
+    : httpStatus === 401
+      ? "authentication_error"
+      : httpStatus === 503 || httpStatus === 504
+        ? "server_error"
+        : httpStatus === 400
+          ? "invalid_request_error"
+          : "upstream_error";
+  return {
+    httpStatus,
+    error: classifyError(httpStatus, errorType, finalMessage),
+  };
+}
+
+/** Map a terminal Responses error object to the HTTP status we record in /api/logs. */
+export function httpStatusFromTerminalError(error: {
+  type?: string;
+  code?: string | null;
+  message?: string;
+} | undefined): number {
+  if (!error) return 502;
+  if (error.type === "rate_limit_error" || error.code === "rate_limit_exceeded") return 429;
+  if (error.type === "authentication_error" || error.code === "invalid_api_key") return 401;
+  if (error.type === "insufficient_quota" || error.code === "insufficient_quota") return 429;
+  if (error.type === "server_error" && error.code === "server_is_overloaded") return 503;
+  if (error.type === "invalid_request_error") return 400;
+  if (error.type === "proxy_error") return 500;
+  const message = error.message ?? "";
+  if (message) return inferHttpStatusFromAdapterMessage(message);
+  return 502;
+}

package/src/oauth/cursor.ts

@@ -32,6 +32,37 @@ export interface CursorAuthParams {
   loginUrl: string;
 }
 
+interface CursorJwtPayload {
+  sub?: unknown;
+  email?: unknown;
+  exp?: unknown;
+}
+
+function decodeCursorJwtPayload(token: string): CursorJwtPayload | undefined {
+  const parts = token.split(".");
+  const payload = parts[1];
+  if (parts.length !== 3 || !payload) return undefined;
+  try {
+    return JSON.parse(Buffer.from(payload, "base64url").toString("utf-8")) as CursorJwtPayload;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Build OAuthCredentials from Cursor tokens, extracting stable identity from JWT `sub` for multiauth. */
+export function credentialsFromCursorTokens(accessToken: string, refreshToken: string): OAuthCredentials {
+  const payload = decodeCursorJwtPayload(accessToken) ?? decodeCursorJwtPayload(refreshToken);
+  const accountId = typeof payload?.sub === "string" && payload.sub.length > 0 ? payload.sub : undefined;
+  const email = typeof payload?.email === "string" && payload.email.length > 0 ? payload.email.toLowerCase() : undefined;
+  return {
+    access: accessToken,
+    refresh: refreshToken,
+    expires: getTokenExpiry(accessToken),
+    ...(accountId ? { accountId } : {}),
+    ...(email ? { email } : {}),
+  };
+}
+
 /** Generate PKCE params + the cursor.com deep-link login URL (challenge only — never the verifier). */
 export async function generateCursorAuthParams(): Promise<CursorAuthParams> {
   const { verifier, challenge } = await generatePKCE();
@@ -113,7 +144,7 @@ export async function loginCursor(
   ctrl.onAuth?.({ url: loginUrl, instructions: "Approve the Cursor login in your browser, then return here." });
   ctrl.onProgress?.("Waiting for Cursor login approval…");
   const { accessToken, refreshToken } = await pollCursorAuth(uuid, verifier, ctrl.signal, pollBaseDelayMs);
-  return { access: accessToken, refresh: refreshToken, expires: getTokenExpiry(accessToken) };
+  return credentialsFromCursorTokens(accessToken, refreshToken);
 }
 
 function isRetryableRefreshStatus(status: number): boolean {
@@ -160,7 +191,7 @@ export async function refreshCursorToken(refresh: string, signal?: AbortSignal):
     if (response.ok) {
       const data = (await response.json()) as { accessToken?: string; refreshToken?: string };
       if (!data.accessToken) throw new Error("Cursor refresh response missing access token");
-      return { access: data.accessToken, refresh: data.refreshToken || refresh, expires: getTokenExpiry(data.accessToken) };
+      return credentialsFromCursorTokens(data.accessToken, data.refreshToken || refresh);
     }
     if (!isRetryableRefreshStatus(response.status) || attempt === REFRESH_ATTEMPTS - 1) {
       throw new Error(`Cursor token refresh failed: ${response.status}`);
@@ -174,15 +205,7 @@ export async function refreshCursorToken(refresh: string, signal?: AbortSignal):
 
 /** Resolve a token's expiry (epoch ms) from its JWT `exp`, minus a 5-minute skew; ~1h fallback. */
 export function getTokenExpiry(token: string): number {
-  try {
-    const parts = token.split(".");
-    const payload = parts.length === 3 ? parts[1] : undefined;
-    if (payload) {
-      const decoded = JSON.parse(Buffer.from(payload, "base64url").toString("utf-8")) as { exp?: number };
-      if (typeof decoded.exp === "number") return decoded.exp * 1000 - EXPIRY_SKEW_MS;
-    }
-  } catch {
-    // fall through to the fixed fallback below
-  }
+  const decoded = decodeCursorJwtPayload(token);
+  if (typeof decoded?.exp === "number") return decoded.exp * 1000 - EXPIRY_SKEW_MS;
   return Date.now() + FALLBACK_TTL_MS;
 }

package/src/oauth/store.ts

@@ -10,9 +10,10 @@
  * Exceptions:
  * - `chatgpt` stays single-slot (always replaced): codex-auth-api uses it as a scratch slot
  *   for Codex pool logins, which have their own ledger (codex-accounts.json).
- * - Credentials without identity (no accountId/email — kimi, kiro, cursor) replace the
- *   active slot instead of appending: their refresh tokens rotate, so a derived id would
- *   duplicate the same human on every re-login.
+ * - Credentials without identity (no accountId/email — kimi, kiro) replace the active slot
+ *   instead of appending: their refresh tokens rotate, so a derived id would duplicate the
+ *   same human on every re-login. Cursor login extracts JWT `sub` as accountId so multiauth
+ *   can append distinct accounts.
  */
 import { createHash } from "node:crypto";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, chmodSync } from "node:fs";

package/src/providers/derive.ts

@@ -23,6 +23,8 @@ export interface DerivedKeyLoginProvider {
   noPenaltyModels?: string[];
   autoToolChoiceOnlyModels?: string[];
   preserveReasoningContentModels?: string[];
+  thinkingToggleModels?: string[];
+  thinkingBudgetModels?: string[];
   escapeBuiltinToolNames?: boolean;
 }
 
@@ -80,9 +82,11 @@ export function providerConfigSeed(entry: ProviderRegistryEntry): OcxProviderCon
     ...(entry.noTemperatureModels ? { noTemperatureModels: [...entry.noTemperatureModels] } : {}),
     ...(entry.noTopPModels ? { noTopPModels: [...entry.noTopPModels] } : {}),
     ...(entry.noPenaltyModels ? { noPenaltyModels: [...entry.noPenaltyModels] } : {}),
+    ...(entry.parallelToolCalls !== undefined ? { parallelToolCalls: entry.parallelToolCalls } : {}),
     ...(entry.autoToolChoiceOnlyModels ? { autoToolChoiceOnlyModels: [...entry.autoToolChoiceOnlyModels] } : {}),
     ...(entry.preserveReasoningContentModels ? { preserveReasoningContentModels: [...entry.preserveReasoningContentModels] } : {}),
     ...(entry.thinkingToggleModels ? { thinkingToggleModels: [...entry.thinkingToggleModels] } : {}),
+    ...(entry.thinkingBudgetModels ? { thinkingBudgetModels: [...entry.thinkingBudgetModels] } : {}),
     ...(entry.escapeBuiltinToolNames !== undefined ? { escapeBuiltinToolNames: entry.escapeBuiltinToolNames } : {}),
     ...(entry.googleMode ? { googleMode: entry.googleMode } : {}),
     ...(entry.project ? { project: entry.project } : {}),
@@ -117,6 +121,8 @@ export function deriveKeyLoginMap(): Record<string, DerivedKeyLoginProvider> {
       ...(entry.noPenaltyModels ? { noPenaltyModels: [...entry.noPenaltyModels] } : {}),
       ...(entry.autoToolChoiceOnlyModels ? { autoToolChoiceOnlyModels: [...entry.autoToolChoiceOnlyModels] } : {}),
       ...(entry.preserveReasoningContentModels ? { preserveReasoningContentModels: [...entry.preserveReasoningContentModels] } : {}),
+      ...(entry.thinkingToggleModels ? { thinkingToggleModels: [...entry.thinkingToggleModels] } : {}),
+      ...(entry.thinkingBudgetModels ? { thinkingBudgetModels: [...entry.thinkingBudgetModels] } : {}),
       ...(entry.escapeBuiltinToolNames !== undefined ? { escapeBuiltinToolNames: entry.escapeBuiltinToolNames } : {}),
       ...(entry.googleMode ? { googleMode: entry.googleMode } : {}),
       ...(entry.project ? { project: entry.project } : {}),
@@ -177,9 +183,11 @@ export function enrichProviderFromRegistry(name: string, prov: OcxProviderConfig
   if (!prov.noTemperatureModels && seed.noTemperatureModels) prov.noTemperatureModels = [...seed.noTemperatureModels];
   if (!prov.noTopPModels && seed.noTopPModels) prov.noTopPModels = [...seed.noTopPModels];
   if (!prov.noPenaltyModels && seed.noPenaltyModels) prov.noPenaltyModels = [...seed.noPenaltyModels];
+  if (prov.parallelToolCalls === undefined && seed.parallelToolCalls !== undefined) prov.parallelToolCalls = seed.parallelToolCalls;
   if (!prov.autoToolChoiceOnlyModels && seed.autoToolChoiceOnlyModels) prov.autoToolChoiceOnlyModels = [...seed.autoToolChoiceOnlyModels];
   if (!prov.preserveReasoningContentModels && seed.preserveReasoningContentModels) prov.preserveReasoningContentModels = [...seed.preserveReasoningContentModels];
   if (!prov.thinkingToggleModels && seed.thinkingToggleModels) prov.thinkingToggleModels = [...seed.thinkingToggleModels];
+  if (!prov.thinkingBudgetModels && seed.thinkingBudgetModels) prov.thinkingBudgetModels = [...seed.thinkingBudgetModels];
   if (prov.escapeBuiltinToolNames === undefined && seed.escapeBuiltinToolNames !== undefined) prov.escapeBuiltinToolNames = seed.escapeBuiltinToolNames;
 }