@bman654/clodex 2.2.2 → 2.4.0

package/dist/cli.js

@@ -40,7 +40,7 @@ import {
   withProviderMutationLock,
   withRegistryWriteLock,
   withRegistryWriteLockSync
-} from "./chunk-W4SVDQCZ.js";
+} from "./chunk-LBEJOEUY.js";
 
 // src/cli.ts
 import pc13 from "picocolors";
@@ -218,7 +218,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@bman654/clodex",
-  version: "2.2.2",
+  version: "2.4.0",
   publishConfig: {
     access: "public"
   },
@@ -840,6 +840,51 @@ function applyClaudeCodeThirdPartyCompat(env) {
   env["ENABLE_TOOL_SEARCH"] = "true";
   env["CLAUDE_CODE_SIMPLE_SYSTEM_PROMPT"] = "0";
 }
+var LOOPBACK_NO_PROXY_ENTRIES = ["localhost", "127.0.0.1", "::1"];
+function gatewayHostname(gatewayUrl) {
+  try {
+    return new URL(gatewayUrl).hostname.replace(/^\[|\]$/g, "").toLowerCase();
+  } catch {
+    return "";
+  }
+}
+function isLoopbackHost(host) {
+  if (host === "localhost" || host.endsWith(".localhost")) return true;
+  if (host === "::1" || host === "0:0:0:0:0:0:0:1") return true;
+  const v4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(host);
+  if (!v4) return false;
+  const octets = v4.slice(1).map(Number);
+  if (octets.some((o) => o > 255)) return false;
+  return octets[0] === 127;
+}
+function effectiveNoProxyValue(env) {
+  return env["no_proxy"] || env["NO_PROXY"] || "";
+}
+function normalizedNoProxyEntries(env) {
+  return effectiveNoProxyValue(env).split(",").map((value) => value.trim()).filter(Boolean);
+}
+function addGatewayNoProxyBypass(env, gatewayUrl) {
+  const hasProxy = Boolean(
+    env["HTTPS_PROXY"]?.trim() || env["https_proxy"]?.trim() || env["HTTP_PROXY"]?.trim() || env["http_proxy"]?.trim()
+  );
+  if (!hasProxy) return;
+  const host = gatewayHostname(gatewayUrl);
+  if (!isLoopbackHost(host)) return;
+  if (effectiveNoProxyValue(env) === "*") return;
+  const existing = normalizedNoProxyEntries(env);
+  const additions = [...LOOPBACK_NO_PROXY_ENTRIES, host];
+  const seen = new Set(existing.map((entry) => entry.toLowerCase()));
+  const merged = [...existing];
+  for (const entry of additions) {
+    const key = entry.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(entry);
+  }
+  const value = merged.join(",");
+  env["NO_PROXY"] = value;
+  env["no_proxy"] = value;
+}
 function buildChildEnv(baseUrl, model, apiKey, proxyPort, contextWindow, enableGatewayDiscovery) {
   const env = { ...process.env };
   for (const name of CONFLICTING_ENV_VARS) {
@@ -847,6 +892,7 @@ function buildChildEnv(baseUrl, model, apiKey, proxyPort, contextWindow, enableG
   }
   env["ANTHROPIC_BASE_URL"] = proxyPort ? `http://127.0.0.1:${proxyPort}` : baseUrl;
   env["ANTHROPIC_API_KEY"] = apiKey;
+  addGatewayNoProxyBypass(env, env["ANTHROPIC_BASE_URL"]);
   const bareModel = stripOneMContextSuffix(model);
   env["ANTHROPIC_MODEL"] = claudeCodeClientModelId(model, contextWindow);
   env["CLAUDE_CODE_MAX_CONTEXT_TOKENS"] = String(resolveContextWindow(bareModel, contextWindow));
@@ -3414,6 +3460,7 @@ function applyPricingToRegistryProviders(registry, cache) {
   const index = buildPricingIndex(cache);
   let changed = false;
   for (const provider of registry.providers) {
+    if (provider.preserveModelPricing) continue;
     if (!provider.modelsCache?.models.length) continue;
     const platform = TEMPLATE_TO_PRICING_PLATFORM[provider.templateId] ?? TEMPLATE_TO_PRICING_PLATFORM[provider.id];
     const enriched = enrichModelsWithPricing(provider.modelsCache.models, index, platform);
@@ -3716,7 +3763,9 @@ function cachedModelToLocal(cached, provider) {
     reasoning: cached.reasoning ?? modelsDev?.reasoning,
     interleavedReasoningField: cached.interleavedReasoningField ?? modelsDev?.interleaved?.field,
     useResponsesLite: cached.useResponsesLite,
-    preferWebSockets: cached.preferWebSockets
+    preferWebSockets: cached.preferWebSockets,
+    modalities: cached.modalities,
+    compatibility: cached.compatibility
   };
 }
 function isAnonymousProvider(provider) {
@@ -3926,6 +3975,7 @@ function localProvidersToServerModels(localProviders) {
       interleavedReasoningField: model.interleavedReasoningField,
       useResponsesLite: model.useResponsesLite,
       preferWebSockets: model.preferWebSockets,
+      compatibility: model.compatibility,
       headers: provider.headers,
       providerData: provider.providerData
     }))
@@ -4044,7 +4094,7 @@ function frameStatusCode(code, discriminator) {
     const numeric = Number(code);
     if (numeric >= 400 && numeric <= 599) return numeric;
   }
-  if (/insufficient_quota|rate_limit/.test(discriminator)) return 429;
+  if (/insufficient_quota|rate_limit|usage_limit/.test(discriminator)) return 429;
   if (discriminator.includes("authentication")) return 401;
   if (discriminator.includes("permission")) return 403;
   if (discriminator.includes("not_found")) return 404;
@@ -4496,6 +4546,61 @@ function warnReasoningNormalizationGap(fields, log12) {
   } catch {
   }
 }
+function toolArgumentNormalizationGap(expected, actual, requiredProps) {
+  if (conversationItemKind(expected) !== "function_call") return void 0;
+  if (conversationItemKind(actual) !== "function_call") return void 0;
+  const left = expected;
+  const right = actual;
+  const callId = left.call_id;
+  if (typeof callId !== "string" || !callId || callId !== right.call_id) return void 0;
+  if (typeof left.name !== "string" || left.name !== right.name) return void 0;
+  if (canonicalJson(normalizeToolCallJson(left)) === canonicalJson(normalizeToolCallJson(right))) {
+    return void 0;
+  }
+  const required = requiredProps().get(left.name);
+  const stripped = (item) => {
+    if (typeof item.arguments !== "string") return void 0;
+    const raw = item.arguments.trim();
+    try {
+      const parsed = raw === "" ? {} : JSON.parse(raw);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+      return canonicalJson({
+        ...normalizeToolCallJson(item),
+        arguments: canonicalJson(sanitizeToolInput(parsed, required))
+      });
+    } catch {
+      return void 0;
+    }
+  };
+  const leftStripped = stripped(left);
+  const rightStripped = stripped(right);
+  return {
+    tool: left.name,
+    equalAfterStrip: leftStripped !== void 0 && leftStripped === rightStripped
+  };
+}
+var warnedToolArgumentGaps = /* @__PURE__ */ new Set();
+var MAX_TOOL_ARGUMENT_GAP_WARNINGS = 3;
+function warnToolArgumentNormalizationGap(gap, log12) {
+  const tool3 = typeof gap.tool === "string" ? gap.tool : "unknown";
+  const signature = `${tool3}:filler`;
+  const message = `clodex: warning: tool call "${tool3}" failed the continuation match, but both sides are identical once clodex's filler-strip rule is applied, so the head should have matched. Prompt caching is degraded for this turn \u2014 please report it, with the adapter debug log from --trace if you can, at https://github.com/bman654/clodex/issues`;
+  try {
+    log12?.(`tool argument normalization gap: ${signature}`);
+  } catch {
+  }
+  if (warnedToolArgumentGaps.has(signature)) return;
+  if (warnedToolArgumentGaps.size >= MAX_TOOL_ARGUMENT_GAP_WARNINGS) return;
+  warnedToolArgumentGaps.add(signature);
+  try {
+    process.stderr.write(`${message}
+`);
+    if (warnedToolArgumentGaps.size === MAX_TOOL_ARGUMENT_GAP_WARNINGS) {
+      process.stderr.write("clodex: warning: further tool-argument normalization warnings suppressed.\n");
+    }
+  } catch {
+  }
+}
 function continuationMismatchDetails(entry, payload, log12, warnOnGap = false) {
   const full = inputArray(payload);
   const prefix = [...entry.requestInput ?? [], ...entry.expectedAssistant ?? []];
@@ -4511,6 +4616,34 @@ function continuationMismatchDetails(entry, payload, log12, warnOnGap = false) {
   const actual = mismatch < full.length ? full[mismatch] : void 0;
   const reasoningGap = reasoningNormalizationGap(expected, actual);
   if (reasoningGap && warnOnGap) warnReasoningNormalizationGap(reasoningGap, log12);
+  let gapExpected = expected;
+  if (conversationItemKind(expected) === "reasoning" && conversationItemKind(actual) === "function_call") {
+    for (let index = mismatch; index < prefix.length; index += 1) {
+      if (conversationItemKind(prefix[index]) !== "reasoning") {
+        gapExpected = prefix[index];
+        break;
+      }
+    }
+  }
+  let toolArgumentGap;
+  try {
+    toolArgumentGap = toolArgumentNormalizationGap(
+      gapExpected,
+      actual,
+      // The head's own schema when it has one; the current turn's tools are only a
+      // fallback for a head that predates the snapshot (see headRequiredToolProps).
+      () => entry.headRequiredToolProps ?? requiredToolProps(payload)
+    );
+  } catch {
+  }
+  if (toolArgumentGap?.equalAfterStrip === true) {
+    if (warnOnGap) warnToolArgumentNormalizationGap(toolArgumentGap, log12);
+  } else if (toolArgumentGap && warnOnGap) {
+    try {
+      log12?.(`tool argument mismatch beyond the strip rule: ${String(toolArgumentGap.tool)}`);
+    } catch {
+    }
+  }
   return {
     fullItems: full.length,
     expectedPrefixItems: prefix.length,
@@ -4528,11 +4661,12 @@ function continuationMismatchDetails(entry, payload, log12, warnOnGap = false) {
         entry.expectedAssistant ?? [],
         mismatch
       )
-    } : {}
+    } : {},
+    ...toolArgumentGap ? { toolArgumentNormalizationGap: toolArgumentGap } : {}
   };
 }
-function continuationMismatchSummary(entry, payload, log12, mismatchDump = false) {
-  const details = continuationMismatchDetails(entry, payload, log12, true);
+function continuationMismatchSummary(entry, payload, log12, mismatchDump = false, precomputedDetails) {
+  const details = precomputedDetails ?? continuationMismatchDetails(entry, payload, log12, true);
   let summary = `full_items=${details.fullItems} expected_prefix_items=${details.expectedPrefixItems} first_mismatch=${details.firstMismatch} expected=${details.expectedKind} actual=${details.actualKind}`;
   if (details.expectedHash || details.actualHash) {
     summary += ` expected_hash=${details.expectedHash ?? "none"} actual_hash=${details.actualHash ?? "none"}`;
@@ -4668,6 +4802,7 @@ function emitContextDiagnostic(entry, ctx, details) {
     retried: ctx.retried,
     frameCount: ctx.frameCount,
     emittedModelData: ctx.emittedModelData,
+    emittedDownstreamData: ctx.emittedDownstreamData,
     responseIdReceived: Boolean(ctx.responseId),
     inFlightMs: entry.inFlightStartedAt === void 0 ? void 0 : Math.max(0, entry.options.now() - entry.inFlightStartedAt),
     ...details
@@ -4922,6 +5057,7 @@ function expectedAssistantItems(ctx) {
 }
 function encodeSse(ctx, event) {
   if (ctx.closed) return;
+  ctx.emittedDownstreamData = true;
   ctx.controller.enqueue(ctx.encoder.encode(`data: ${JSON.stringify(event)}
 
 `));
@@ -4973,12 +5109,12 @@ function failContext(entry, ctx, message, diagnosticDetails, statusCode, retryAf
   closeContext(ctx);
 }
 function retryTransportFailure(entry, ctx, diagnosticDetails) {
-  if (ctx.closed || entry.current !== ctx || ctx.retried || ctx.frameCount !== 0 || ctx.emittedModelData) {
+  if (ctx.closed || entry.current !== ctx || ctx.retried || !transportReplaySafe(ctx)) {
     return false;
   }
   ctx.retried = true;
   ctx.transportRetryPending = true;
-  entry.debug("transport failed before any response frame; retrying once with full context");
+  entry.debug("transport failed before downstream output; retrying once with full context");
   emitContextDiagnostic(entry, ctx, {
     event: "ws_transport_retry",
     outcome: "started",
@@ -5012,9 +5148,9 @@ function retryTransportFailure(entry, ctx, diagnosticDetails) {
 function handleTransportFailure(entry, ctx, message, diagnosticDetails) {
   if (retryTransportFailure(entry, ctx, diagnosticDetails)) return;
   if (ctx.closed || entry.current !== ctx) return;
-  if (ctx.retried && ctx.frameCount === 0 && !ctx.emittedModelData) {
+  if (ctx.retried && ctx.transportRetryPending && transportReplaySafe(ctx)) {
     ctx.transportRetryPending = false;
-    entry.debug("transport retry exhausted before any response frame");
+    entry.debug("transport retry exhausted before downstream output");
     emitContextDiagnostic(entry, ctx, {
       event: "ws_transport_retry",
       outcome: "exhausted",
@@ -5118,6 +5254,9 @@ function resetContextForRetry(ctx) {
   ctx.recentUpstreamEventTypes = [];
   ctx.emittedProtocolAnomalies.clear();
 }
+function transportReplaySafe(ctx) {
+  return !ctx.emittedDownstreamData && !ctx.emittedModelData && ctx.outputByIndex.size === 0;
+}
 function handleSocketMessage(entry, data) {
   const ctx = entry.current;
   if (!ctx || ctx.closed) return;
@@ -5178,7 +5317,8 @@ function handleSocketMessage(entry, data) {
     return;
   }
   const errorStatus = type === "error" && !ctx.emittedModelData ? responseErrorStatus(event) : void 0;
-  if (FAILURE_EVENT_TYPES.has(type ?? "") && (errorStatus === void 0 || willRetry)) {
+  const emptyFailureTerminal = FAILURE_EVENT_TYPES.has(type ?? "") && errorStatus === void 0 && !willRetry && !ctx.emittedModelData;
+  if (FAILURE_EVENT_TYPES.has(type ?? "") && (errorStatus === void 0 || willRetry) && !emptyFailureTerminal) {
     emitResponseErrorDiagnostic(entry, ctx, {
       source: "response_event",
       upstreamEventType: type,
@@ -5221,6 +5361,39 @@ function handleSocketMessage(entry, data) {
     );
     return;
   }
+  if (emptyFailureTerminal) {
+    const details = responseFailureDetails(event);
+    const named = [details.errorType, details.errorCode, details.incompleteReason].filter((value) => typeof value === "string");
+    const summary = "OpenAI ended the response with no output" + (named.length ? ` (${named.join(" / ")})` : ` (${type})`);
+    const discriminator = [details.errorType, details.errorCode].filter((value) => typeof value === "string").join(" ").toLowerCase();
+    const settledReason = details.incompleteReason === "content_filter" || details.incompleteReason === "max_output_tokens";
+    const numericOrNamed = typeof details.errorCode === "string" ? details.errorCode : void 0;
+    const classified = numericOrNamed !== void 0 || discriminator ? frameStatusCode(numericOrNamed, discriminator) : 500;
+    const statusCode = classified !== 500 ? classified : settledReason ? 400 : 502;
+    const usageLimited = statusCode === 429;
+    const retryAfterSeconds = usageLimited && responseRetryAfterSeconds(event) !== void 0 ? clampRetryAfterSeconds(responseRetryAfterSeconds(event)) : void 0;
+    failContext(
+      entry,
+      ctx,
+      retryAfterSeconds === void 0 ? summary : `${summary}; retry after ${retryAfterSeconds}s`,
+      {
+        source: "empty_failure_terminal",
+        upstreamEventType: type,
+        ...details,
+        // Under DISTINCT keys. `failContext` fingerprints the message it was
+        // given after spreading these, so an `errorMessage*` pair here is
+        // overwritten by the summary's — which would silently discard the only
+        // content-free evidence of what upstream actually said, and leave two
+        // failures with the same type and code indistinguishable. `errorMessage*`
+        // now means "what the client was told", `upstreamMessage*` means "what
+        // upstream said", and both survive.
+        ...diagnosticTextFingerprint("upstreamMessage", responseErrorMessage(event))
+      },
+      statusCode,
+      retryAfterSeconds
+    );
+    return;
+  }
   ctx.pendingEvents.push(event);
   if (isModelDataEvent(type)) flushPending(ctx);
   if (TERMINAL_EVENT_TYPES.has(type ?? "") || type === "error") {
@@ -5232,6 +5405,7 @@ function handleSocketMessage(entry, data) {
       entry.responseId = ctx.responseId;
       entry.requestInput = inputArray(ctx.originalPayload);
       entry.expectedAssistant = expectedAssistantItems(ctx);
+      entry.headRequiredToolProps = requiredToolProps(ctx.originalPayload);
       entry.canonicalPrefix = void 0;
       entry.canonicalEchoablePrefix = void 0;
       entry.promptFieldHashes = ctx.promptFieldHashes;
@@ -5417,6 +5591,7 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
     let persistent = Boolean(partitionKey);
     let promotedConnectionId;
     let decision;
+    let candidateMismatchDetails;
     if (selected && selectedDelta) {
       sendPayload = { ...payload, input: selectedDelta, previous_response_id: selected.responseId };
       continued = true;
@@ -5439,8 +5614,23 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
       decision = "parallel_isolated";
       debug("parallel request using an isolated socket");
     } else if (diagnosticEntry) {
+      const diagnosticMismatch = continuationMismatchDetails(diagnosticEntry, payload, debug, true);
+      candidateMismatchDetails = /* @__PURE__ */ new Map([[diagnosticEntry, diagnosticMismatch]]);
+      for (const candidate of candidates) {
+        if (candidate === diagnosticEntry) continue;
+        candidateMismatchDetails.set(
+          candidate,
+          continuationMismatchDetails(candidate, payload, debug, true)
+        );
+      }
       debug(
-        `history mismatch starting an additional chain; retained ${candidates.length} existing head(s) (${continuationMismatchSummary(diagnosticEntry, payload, debug, mismatchDump)})`
+        `history mismatch starting an additional chain; retained ${candidates.length} existing head(s) (${continuationMismatchSummary(
+          diagnosticEntry,
+          payload,
+          debug,
+          mismatchDump,
+          diagnosticMismatch
+        )})`
       );
       decision = "history_mismatch_new_head";
     } else if (partitionKey) {
@@ -5500,7 +5690,7 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
         ttlPausedMs: entry.ttlPausedMs,
         idleMs: Math.max(0, now - entry.lastUsedAt),
         promptChanges: changedPromptFields(entry.promptFieldHashes, promptFieldHashes),
-        mismatch: continuationMismatchDetails(entry, payload, debug)
+        mismatch: candidateMismatchDetails?.get(entry) ?? continuationMismatchDetails(entry, payload, debug)
       })),
       evictions
     }, diagnosticCorrelation);
@@ -5520,6 +5710,7 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
           frameCount: 0,
           pendingEvents: [],
           emittedModelData: false,
+          emittedDownstreamData: false,
           transportRetryPending: false,
           outputByIndex: /* @__PURE__ */ new Map(),
           outputIndexByItemId: /* @__PURE__ */ new Map(),
@@ -5698,6 +5889,63 @@ function isCredentialBearingHeader(name) {
   return CREDENTIAL_BEARING_HEADER.test(name);
 }
 
+// src/model-runtime-compatibility.ts
+function remapMaxTokensField(body, field) {
+  if (field === "max_tokens") {
+    if (body.max_tokens === void 0 && body.max_completion_tokens !== void 0) {
+      body.max_tokens = body.max_completion_tokens;
+    }
+    delete body.max_completion_tokens;
+    return;
+  }
+  if (field === "max_completion_tokens") {
+    if (body.max_completion_tokens === void 0 && body.max_tokens !== void 0) {
+      body.max_completion_tokens = body.max_tokens;
+    }
+    delete body.max_tokens;
+  }
+}
+function transformMessages(messages, compatibility) {
+  if (!Array.isArray(messages)) return messages;
+  const rewriteDeveloper = compatibility.supportsDeveloperRole === false;
+  const replayReasoning = compatibility.requiresReasoningContentOnAssistantMessages === true;
+  if (!rewriteDeveloper && !replayReasoning) return messages;
+  let changed = false;
+  const transformed = messages.map((message) => {
+    if (!message || typeof message !== "object" || Array.isArray(message)) return message;
+    const source = message;
+    const role = source.role;
+    const needsRoleRewrite = rewriteDeveloper && role === "developer";
+    const needsReasoningReplay = replayReasoning && role === "assistant" && !Object.prototype.hasOwnProperty.call(source, "reasoning_content");
+    if (!needsRoleRewrite && !needsReasoningReplay) return message;
+    changed = true;
+    return {
+      ...source,
+      ...needsRoleRewrite ? { role: "system" } : {},
+      ...needsReasoningReplay ? { reasoning_content: "" } : {}
+    };
+  });
+  return changed ? transformed : messages;
+}
+function transformOpenAiCompatibleRequestBody(body, compatibility) {
+  const transformed = { ...body };
+  if (compatibility.supportsStore === false) delete transformed.store;
+  if (compatibility.supportsLongCacheRetention === false) {
+    delete transformed.prompt_cache_retention;
+    delete transformed.promptCacheRetention;
+  }
+  remapMaxTokensField(transformed, compatibility.maxTokensField);
+  const messages = transformMessages(transformed.messages, compatibility);
+  if (messages !== transformed.messages) transformed.messages = messages;
+  const hasReasoningEffort = typeof transformed.reasoning_effort === "string" && transformed.reasoning_effort.trim().length > 0;
+  if (hasReasoningEffort && compatibility.thinkingFormat === "deepseek") {
+    if (transformed.thinking === void 0) transformed.thinking = { type: "enabled" };
+  } else if (hasReasoningEffort && compatibility.thinkingFormat === "qwen") {
+    if (transformed.enable_thinking === void 0) transformed.enable_thinking = true;
+  }
+  return transformed;
+}
+
 // src/provider-factory.ts
 var RESPONSES_ONLY_PREFIXES = [
   "gpt-5-codex",
@@ -5840,7 +6088,10 @@ async function createLanguageModel(spec) {
       baseURL: baseURL ?? "",
       ...spec.authType !== "none" && apiKey.trim() ? { apiKey } : {},
       ...spec.authType === "none" ? { fetch: fetchWithoutCredentialHeaders } : {},
-      ...spec.headers ? { headers: spec.headers } : {}
+      ...spec.headers ? { headers: spec.headers } : {},
+      ...spec.compatibility ? {
+        transformRequestBody: (body) => transformOpenAiCompatibleRequestBody(body, spec.compatibility)
+      } : {}
     };
     model = createOpenAICompatible({
       ...options
@@ -6096,8 +6347,68 @@ function mapCodexEffortToGeminiBudget(effort) {
   if (!level) return void 0;
   return GEMINI_25_BUDGETS[level];
 }
+function compatibilityReasoningCapabilities(metadata) {
+  const compatibility = metadata?.compatibility;
+  if (!compatibility) return void 0;
+  if (compatibility.supportsReasoningEffort === false) {
+    return metadata?.reasoning === false ? EMPTY_REASONING : {
+      ...EMPTY_REASONING,
+      mode: "internal-only",
+      source: "provider-metadata",
+      confidence: "documented"
+    };
+  }
+  if (compatibility.reasoningEffortMap) {
+    const levels = Object.entries(compatibility.reasoningEffortMap).filter(([, mapped]) => mapped !== null).map(([level]) => level);
+    if (levels.length === 0) {
+      return metadata?.reasoning === false ? EMPTY_REASONING : {
+        ...EMPTY_REASONING,
+        mode: "internal-only",
+        source: "provider-metadata",
+        confidence: "documented"
+      };
+    }
+    const preferredDefault = ["medium", "high", "max", "low"].find((level) => levels.includes(level));
+    return {
+      levels,
+      defaultLevel: preferredDefault ?? levels[0],
+      supportsSummaries: false,
+      mode: "controllable",
+      source: "provider-metadata",
+      confidence: "documented",
+      wireFormat: compatibility.thinkingFormat === "deepseek" ? { kind: "deepseek-thinking" } : { kind: "openai-reasoning-effort" }
+    };
+  }
+  if (compatibility.supportsReasoningEffort === true || compatibility.thinkingFormat !== void 0) {
+    if (metadata?.reasoning === false) return EMPTY_REASONING;
+    return {
+      levels: ["low", "medium", "high"],
+      defaultLevel: "medium",
+      supportsSummaries: false,
+      mode: "controllable",
+      source: "provider-metadata",
+      confidence: "documented",
+      wireFormat: compatibility.thinkingFormat === "deepseek" ? { kind: "deepseek-thinking" } : { kind: "openai-reasoning-effort" }
+    };
+  }
+  return void 0;
+}
+function compatibilityReasoningEffort(effort, modelId, compatibility) {
+  if (compatibility.supportsReasoningEffort === false) return void 0;
+  const map = compatibility.reasoningEffortMap;
+  if (map) {
+    if (!Object.prototype.hasOwnProperty.call(map, effort)) return void 0;
+    return map[effort] ?? void 0;
+  }
+  if (compatibility.supportsReasoningEffort === true || compatibility.thinkingFormat !== void 0) {
+    return mapCodexEffortToOpenAI(effort, modelId);
+  }
+  return void 0;
+}
 function getReasoningCapabilities(npm, modelId, metadata) {
   const id = modelId.toLowerCase();
+  const compatibilityCapabilities = compatibilityReasoningCapabilities(metadata);
+  if (compatibilityCapabilities) return compatibilityCapabilities;
   if (isOpenRouterRoute(npm, metadata)) {
     return openRouterReasoningCapabilities(metadata);
   }
@@ -6243,7 +6554,10 @@ function getReasoningCapabilities(npm, modelId, metadata) {
   return EMPTY_REASONING;
 }
 function getPatchReasoningCapabilities(npm, modelId, metadata) {
-  if (metadata?.reasoning === false && !hasSupportedParameter(metadata, "reasoning_effort") && !hasSupportedParameter(metadata, "reasoning")) {
+  if (metadata?.compatibility?.supportsReasoningEffort === false) {
+    return compatibilityReasoningCapabilities(metadata) ?? EMPTY_REASONING;
+  }
+  if (metadata?.reasoning === false && !metadata?.compatibility?.reasoningEffortMap && !hasSupportedParameter(metadata, "reasoning_effort") && !hasSupportedParameter(metadata, "reasoning")) {
     return EMPTY_REASONING;
   }
   const capabilities = getReasoningCapabilities(npm, modelId, metadata);
@@ -6262,11 +6576,22 @@ function getPatchReasoningCapabilities(npm, modelId, metadata) {
 }
 function effortProviderOptions(npm, effort, modelId, metadata) {
   if (!effort) return void 0;
+  if (npm === "@ai-sdk/openai-compatible" && modelId && metadata?.compatibility) {
+    const reasoningEffort = compatibilityReasoningEffort(
+      effort,
+      modelId,
+      metadata.compatibility
+    );
+    if (!reasoningEffort) return void 0;
+    const key = metadata.providerId ? toCamelCase(metadata.providerId) : "openaiCompatible";
+    return { [key]: { reasoningEffort } };
+  }
   if (isOpenRouterRoute(npm, metadata)) {
     const caps = openRouterReasoningCapabilities(metadata);
     if (caps.mode !== "controllable") return void 0;
     const allowed = new Set(OPENROUTER_EFFORT_LEVELS);
-    const mapped = allowed.has(effort) ? effort : effort === "max" ? "xhigh" : void 0;
+    const candidate = effort;
+    const mapped = allowed.has(candidate) ? candidate : candidate === "max" ? "xhigh" : void 0;
     return mapped ? { openrouter: { reasoning: { effort: mapped, exclude: false } } } : void 0;
   }
   if (npm === "@ai-sdk/openai" || npm === "@ai-sdk/azure") {
@@ -6326,7 +6651,8 @@ function effortProviderOptions(npm, effort, modelId, metadata) {
     }
     if (hasSupportedParameter(metadata, "reasoning")) {
       const allowed = new Set(OPENROUTER_EFFORT_LEVELS);
-      const mapped = allowed.has(effort) ? effort : effort === "max" ? "xhigh" : void 0;
+      const candidate = effort;
+      const mapped = allowed.has(candidate) ? candidate : candidate === "max" ? "xhigh" : void 0;
       return mapped ? { openrouter: { reasoning: { effort: mapped, exclude: false } } } : void 0;
     }
     return void 0;
@@ -7136,6 +7462,62 @@ function parseModelList(body, npm) {
   }
   return models;
 }
+function materializeTemplateModel(template, model, baseUrl) {
+  const npm = model.npm ?? template.npm;
+  const { id, upstreamModelId: normalizedUpstream } = normalizeGoogleModelId(model.id, npm);
+  const family = model.family ?? (id.split(/[-/:]/)[0] ?? id);
+  const freeStatus = model.freeStatus ?? classifyFreeStatus({ model });
+  return {
+    ...model,
+    id,
+    name: normalizeGoogleDisplayName(model.name, id),
+    upstreamModelId: model.upstreamModelId ?? normalizedUpstream,
+    family,
+    brand: model.brand ?? deriveBrand(family),
+    contextWindow: model.contextWindow ?? resolveContextWindow(id),
+    isFree: model.isFree ?? isFreeStatus(freeStatus),
+    freeStatus,
+    modelFormat: model.modelFormat ?? modelFormatForNpm(npm),
+    npm,
+    apiUrl: model.apiUrl ?? baseUrl
+  };
+}
+function normalizeTemplateOverlay(template, model) {
+  const npm = model.npm ?? template.npm;
+  const { id } = normalizeGoogleModelId(model.id, npm);
+  const family = model.family;
+  const hasFreeMetadata = model.cost !== void 0 || model.isFree !== void 0 || model.freeStatus !== void 0;
+  const freeStatus = hasFreeMetadata ? model.freeStatus ?? classifyFreeStatus({ model }) : void 0;
+  return {
+    ...model,
+    id,
+    name: normalizeGoogleDisplayName(model.name, id),
+    ...model.upstreamModelId !== void 0 ? { upstreamModelId: normalizeGoogleModelId(model.upstreamModelId, npm).upstreamModelId } : {},
+    ...model.npm !== void 0 ? { npm } : {},
+    ...model.modelFormat !== void 0 ? { modelFormat: model.modelFormat } : model.npm !== void 0 ? { modelFormat: modelFormatForNpm(npm) } : {},
+    ...family !== void 0 ? { family, brand: model.brand ?? deriveBrand(family) } : {},
+    ...freeStatus !== void 0 ? {
+      freeStatus,
+      isFree: model.isFree ?? isFreeStatus(freeStatus)
+    } : {}
+  };
+}
+function applyTemplateModelMetadata(template, discovered, _baseUrl) {
+  const curated = new Map(
+    (template.staticModels ?? []).map((model) => normalizeTemplateOverlay(template, model)).map((model) => [model.id, model])
+  );
+  const visible = template.staticModelPolicy === "allowlist" ? discovered.filter((model) => curated.has(model.id)) : discovered;
+  return visible.map((model) => {
+    const overlay = curated.get(model.id);
+    if (!overlay) return model;
+    return {
+      ...model,
+      ...overlay,
+      id: model.id,
+      upstreamModelId: overlay.upstreamModelId ?? model.upstreamModelId
+    };
+  });
+}
 async function fetchTemplateModels(template, apiKey, baseUrlOverride, extraHeaders) {
   const trimmedOverride = baseUrlOverride?.trim();
   const baseUrl = (trimmedOverride || template.defaultBaseUrl)?.replace(/\/$/, "");
@@ -7147,19 +7529,7 @@ async function fetchTemplateModels(template, apiKey, baseUrlOverride, extraHeade
     };
   }
   if (template.modelSource === "static-seed") {
-    const models = (template.staticModels || []).map((sm) => {
-      const family = sm.id.split(/[-/:]/)[0] ?? sm.id;
-      return {
-        id: sm.id,
-        name: sm.name,
-        upstreamModelId: sm.id,
-        family,
-        brand: deriveBrand(family),
-        contextWindow: resolveContextWindow(sm.id),
-        modelFormat: modelFormatForNpm(template.npm),
-        npm: template.npm
-      };
-    });
+    const models = (template.staticModels ?? []).map((model) => materializeTemplateModel(template, model, baseUrl));
     return { models, baseUrl };
   }
   const url = modelsUrl(baseUrl, template);
@@ -7229,7 +7599,7 @@ async function fetchTemplateModels(template, apiKey, baseUrlOverride, extraHeade
       }
     } catch {
     }
-    const models = parseModelList(json, template.npm);
+    const models = applyTemplateModelMetadata(template, parseModelList(json, template.npm), baseUrl);
     if (models.length === 0) {
       return {
         models: [],
@@ -7317,11 +7687,11 @@ async function addProviderFromTemplate(template, apiKey, opts) {
   }
   const pricingCache = loadPricingCache();
   const platform = pricingPlatformForProvider(template.id, template.id);
-  const pricedModels = enrichModelsWithPricing(
-    usableModels.map((m) => ({ ...m, apiUrl: fetched.baseUrl })),
-    buildPricingIndex(pricingCache),
-    platform
-  );
+  const discoveredModels = usableModels.map((m) => ({
+    ...m,
+    apiUrl: m.apiUrl ?? fetched.baseUrl
+  }));
+  const pricedModels = template.preserveModelPricing ? discoveredModels : enrichModelsWithPricing(discoveredModels, buildPricingIndex(pricingCache), platform);
   const account = `provider:${template.id}`;
   const result = await withProviderMutationLock(template.id, async () => {
     const currentState = await withRegistryWriteLock(() => {
@@ -7378,6 +7748,7 @@ async function addProviderFromTemplate(template, apiKey, opts) {
           enabled: true,
           authRef,
           authType: trimmedKey ? template.authType : "none",
+          ...template.preserveModelPricing ? { preserveModelPricing: true } : {},
           ...!trimmedKey && template.anonymousFreeModels ? { subscriptionFilter: "free" } : {},
           api: {
             npm: template.npm,
@@ -7980,7 +8351,7 @@ async function refreshApiListProvider(provider, apiKey) {
       return { models: [], error: fetched2.error ?? "No models returned.", baseUrl: fetched2.baseUrl };
     }
     return {
-      models: fetched2.models.map((m) => ({ ...m, apiUrl: fetched2.baseUrl })),
+      models: fetched2.models.map((m) => ({ ...m, apiUrl: m.apiUrl ?? fetched2.baseUrl })),
       baseUrl: fetched2.baseUrl
     };
   }
@@ -7999,7 +8370,7 @@ async function refreshApiListProvider(provider, apiKey) {
   return {
     models: usableModels.map((m) => ({
       ...m,
-      apiUrl: fetched.baseUrl
+      apiUrl: m.apiUrl ?? fetched.baseUrl
     })),
     baseUrl: fetched.baseUrl
   };
@@ -8113,7 +8484,7 @@ async function refreshProviderModels(providerId, apiKey, registry) {
     }
     const pricingCache = loadPricingCache();
     const platform = pricingPlatformForProvider(provider.templateId, provider.id);
-    const enriched = enrichModelsWithPricing(models, buildPricingIndex(pricingCache), platform);
+    const enriched = provider.preserveModelPricing ? models : enrichModelsWithPricing(models, buildPricingIndex(pricingCache), platform);
     await withRegistryWriteLock(() => {
       const currentRegistry = loadRegistryStrict();
       const currentProvider = currentRegistry.providers.find((candidate) => candidate.id === providerId);
@@ -9355,7 +9726,8 @@ function localModelToRoute(lp, model) {
     reasoning: model.reasoning,
     interleavedReasoningField: model.interleavedReasoningField,
     useResponsesLite: model.useResponsesLite,
-    preferWebSockets: model.preferWebSockets
+    preferWebSockets: model.preferWebSockets,
+    compatibility: model.compatibility
   };
 }
 function makeRouteResolver(localProviders) {
@@ -9428,7 +9800,8 @@ function buildHttpProxyRoutes(providers, favorites, modelAliases = void 0, max =
       unavailable.push(favorite);
       continue;
     }
-    if (model.modelFormat !== "openai" || !isSdkMigratedNpm(model.npm)) {
+    const supported = model.modelFormat === "anthropic" ? Boolean(model.baseUrl) : isSdkMigratedNpm(model.npm);
+    if (!supported) {
       unsupported.push(favorite);
       continue;
     }
@@ -9601,7 +9974,8 @@ function routeUnavailableMessage(modelId, reason) {
 }
 
 // src/upstream-forward.ts
-import { Readable } from "stream";
+import { Readable, Transform } from "stream";
+import { StringDecoder } from "string_decoder";
 
 // src/server/auth.ts
 function sanitizeCredential(value) {
@@ -9682,6 +10056,34 @@ async function fetchWithOAuthRetry(apiKey, request3, refreshToken) {
   response = await request3(refreshed);
   return { response, apiKey: refreshed, refreshed: true };
 }
+function anthropicSseModelRewrite(override) {
+  const decoder = new StringDecoder("utf8");
+  let tail = "";
+  const rewriteLine = (line) => {
+    if (!line.startsWith("data:") || !line.includes('"message_start"')) return line;
+    try {
+      const parsed = JSON.parse(line.slice(5));
+      if (parsed.type === "message_start" && parsed.message && typeof parsed.message.model === "string") {
+        parsed.message.model = override;
+        return "data: " + JSON.stringify(parsed);
+      }
+    } catch {
+    }
+    return line;
+  };
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      const lines = (tail + decoder.write(chunk)).split("\n");
+      tail = lines.pop() ?? "";
+      const rewritten = lines.map(rewriteLine);
+      callback(null, rewritten.length ? rewritten.join("\n") + "\n" : "");
+    },
+    flush(callback) {
+      const rest = tail + decoder.end();
+      callback(null, rest ? rewriteLine(rest) : "");
+    }
+  });
+}
 async function relayAnthropicMessages(res, messagesUrl, body, apiKey, clientWantsStream, options = {}) {
   const doFetch = (key) => fetch(messagesUrl, {
     method: "POST",
@@ -9718,7 +10120,12 @@ async function relayAnthropicMessages(res, messagesUrl, body, apiKey, clientWant
       "Cache-Control": "no-cache",
       "Connection": "keep-alive"
     });
-    Readable.fromWeb(upstreamRes.body).on("error", () => res.destroy()).pipe(res);
+    const upstream = Readable.fromWeb(upstreamRes.body).on("error", () => res.destroy());
+    if (options.responseModelOverride) {
+      upstream.pipe(anthropicSseModelRewrite(options.responseModelOverride)).on("error", () => res.destroy()).pipe(res);
+    } else {
+      upstream.pipe(res);
+    }
     return;
   }
   if (!upstreamRes.body) {
@@ -9726,14 +10133,19 @@ async function relayAnthropicMessages(res, messagesUrl, body, apiKey, clientWant
     res.end(JSON.stringify({ type: "error", error: { type: "api_error", message: "Upstream returned empty response body" } }));
     return;
   }
-  const text4 = await upstreamRes.text();
+  let text4 = await upstreamRes.text();
+  let parsed;
   try {
-    JSON.parse(text4);
+    parsed = JSON.parse(text4);
   } catch {
     res.writeHead(502, { "Content-Type": "application/json" });
     res.end(JSON.stringify({ type: "error", error: { type: "api_error", message: "Upstream response was not valid JSON" } }));
     return;
   }
+  if (options.responseModelOverride && parsed && typeof parsed === "object" && !Array.isArray(parsed) && typeof parsed.model === "string") {
+    parsed.model = options.responseModelOverride;
+    text4 = JSON.stringify(parsed);
+  }
   res.writeHead(200, {
     "Content-Type": "application/json",
     "Content-Length": Buffer.byteLength(text4).toString()
@@ -9882,6 +10294,41 @@ function resolveUpstreamTools(tools, messages) {
   return upstream;
 }
 
+// src/upstream-retry.ts
+var UPSTREAM_MAX_RETRIES_ENV = "CLODEX_UPSTREAM_MAX_RETRIES";
+var MAX_UPSTREAM_MAX_RETRIES = 5;
+var reportedValues = /* @__PURE__ */ new Set();
+function reportOnce(raw, message, warn) {
+  if (reportedValues.has(raw)) return;
+  reportedValues.add(raw);
+  try {
+    warn(message);
+  } catch {
+  }
+}
+function upstreamMaxRetries(env = process.env, warn = (message) => console.error(`clodex: ${message}`)) {
+  const raw = env[UPSTREAM_MAX_RETRIES_ENV]?.trim();
+  if (raw === void 0 || raw === "") return void 0;
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < 0) {
+    reportOnce(
+      raw,
+      `ignoring ${UPSTREAM_MAX_RETRIES_ENV}=${raw} (expected a non-negative integer)`,
+      warn
+    );
+    return void 0;
+  }
+  if (value > MAX_UPSTREAM_MAX_RETRIES) {
+    reportOnce(
+      raw,
+      `clamping ${UPSTREAM_MAX_RETRIES_ENV}=${raw} to ${MAX_UPSTREAM_MAX_RETRIES} (higher values exceed the 120s streaming idle budget)`,
+      warn
+    );
+    return MAX_UPSTREAM_MAX_RETRIES;
+  }
+  return value;
+}
+
 // src/sdk-adapter.ts
 function sdkTranslationErrorSignature(error) {
   const message = error instanceof Error ? error.message : typeof error === "string" ? error : void 0;
@@ -9952,10 +10399,12 @@ function openAiCacheBreakpoint(block, enabled) {
 function translateTopLevelSystemForOpenAi(system) {
   if (!system) return [];
   if (typeof system === "string") {
-    return system.trim() ? [{ role: "system", content: system }] : [];
+    const stripped = stripClaudeCodeBillingHeader(system);
+    return stripped?.trim() ? [{ role: "system", content: stripped }] : [];
   }
   return system.flatMap((block) => {
-    const text4 = typeof block === "string" ? block : block.text ?? "";
+    const raw = typeof block === "string" ? block : block.text ?? "";
+    const text4 = stripClaudeCodeBillingHeader(raw) ?? "";
     if (!text4.trim()) return [];
     const cacheControl = typeof block === "string" ? void 0 : block.cache_control;
     return [{
@@ -10141,7 +10590,7 @@ function isClaudeCodeStructuredOutputCompactRequest(body) {
 function translateRequest(body, npm, options) {
   const messages = body.messages ?? [];
   annotateToolNames(messages);
-  const baseSystem = systemToString(body.system, options?.openAiOAuth === true);
+  const baseSystem = systemToString(body.system, true);
   const systemText = baseSystem?.trim() || (options?.openAiOAuth ? "You are a coding assistant." : void 0);
   const compactRequest = isClaudeCodeStructuredOutputCompactRequest(body);
   let upstreamTools = resolveUpstreamTools(
@@ -10432,6 +10881,7 @@ async function streamAnthropicResponse(model, params, modelId, write, log12, obs
   const result = streamText({
     model,
     ...params,
+    maxRetries: upstreamMaxRetries(),
     abortSignal,
     onError: () => {
     }
@@ -10480,6 +10930,7 @@ async function generateAnthropicResponse(model, params, modelId, options) {
     const r = streamText({
       model,
       ...params,
+      maxRetries: upstreamMaxRetries(),
       abortSignal,
       onError: () => {
       }
@@ -10536,6 +10987,7 @@ async function generateAnthropicResponse(model, params, modelId, options) {
       const r = await generateText({
         model,
         ...params,
+        maxRetries: upstreamMaxRetries(),
         abortSignal: generateAbort.signal
       });
       ({ text: text4, toolCalls, finishReason, usage } = r);
@@ -10955,6 +11407,10 @@ async function startProxyCatalog(routes, defaultAliasId, debug = false, inferenc
               route.apiKey = refreshed;
             },
             signal: clientAbort.signal,
+            // A route selected through a clodex: id or short alias must echo the
+            // exact requested id back, or patched Claude Code misses the alias
+            // context-window key and can skip auto-compaction.
+            responseModelOverride: typeof originalModel === "string" && originalModel !== route.realModelId ? originalModel : void 0,
             onUpstreamError: inferenceLogPath ? (statusCode, errorContent) => writeInferenceResponseErrorLog(inferenceLogPath, {
               modelId: originalModel,
               provider: route.providerId ?? route.aliasId.split(":")[1] ?? "unknown",
@@ -10993,6 +11449,7 @@ async function startProxyCatalog(routes, defaultAliasId, debug = false, inferenc
               supportedParameters: route.supportedParameters,
               reasoning: route.reasoning,
               interleavedReasoningField: route.interleavedReasoningField,
+              compatibility: route.compatibility,
               upstreamModelId: route.realModelId
             }
           });
@@ -11011,6 +11468,7 @@ async function startProxyCatalog(routes, defaultAliasId, debug = false, inferenc
             headers: route.headers,
             useResponsesLite: route.useResponsesLite,
             preferWebSockets: route.preferWebSockets,
+            compatibility: route.compatibility,
             onDebug: (msg) => plog(() => msg),
             onWebSocketDiagnostic: webSocketDiagnosticsLogPath ? (event) => writeWebSocketDiagnosticLog(webSocketDiagnosticsLogPath, event) : void 0
           });
@@ -11220,6 +11678,7 @@ function startProxy(completionsUrl, modelId, debug = false, contextWindow, sdk,
     interleavedReasoningField: sdk?.interleavedReasoningField,
     useResponsesLite: sdk?.useResponsesLite,
     preferWebSockets: sdk?.preferWebSockets,
+    compatibility: sdk?.compatibility,
     headers: sdk?.headers
   }], clientModelId, debug);
 }
@@ -11490,11 +11949,20 @@ async function collectOpenAiStream(stream) {
 async function generateOpenAiResponse(model, params, responseModelId, options) {
   let result;
   if (options?.forceStream) {
-    const { stream } = streamText2({ model, ...params, onError: () => {
-    } });
+    const { stream } = streamText2({
+      model,
+      ...params,
+      maxRetries: upstreamMaxRetries(),
+      onError: () => {
+      }
+    });
     result = await collectOpenAiStream(stream);
   } else {
-    result = await generateText2({ model, ...params });
+    result = await generateText2({
+      model,
+      ...params,
+      maxRetries: upstreamMaxRetries()
+    });
   }
   const message = { role: "assistant", content: result.text || null };
   if (result.toolCalls?.length) {
@@ -11518,7 +11986,11 @@ async function generateOpenAiResponse(model, params, responseModelId, options) {
   };
 }
 async function streamOpenAiResponse(model, params, responseModelId, onChunk) {
-  const { stream } = streamText2({ model, ...params });
+  const { stream } = streamText2({
+    model,
+    ...params,
+    maxRetries: upstreamMaxRetries()
+  });
   const baseData = {
     id: `chatcmpl-${Date.now()}`,
     object: "chat.completion.chunk",
@@ -11762,6 +12234,9 @@ async function handleAnthropicMessages(req, res, options, modelCache, plog) {
       onTokenRefreshed: (refreshed) => {
         model.apiKey = refreshed;
       },
+      // Echo the exact requested id when it differs from the upstream id, so
+      // clients that key context windows on the response model still resolve.
+      responseModelOverride: typeof body.model === "string" && body.model !== upstreamModelId(model) ? body.model : void 0,
       onUpstreamError: options.inferenceLogPath ? (statusCode, errorContent) => writeInferenceResponseErrorLog(options.inferenceLogPath, {
         requestId,
         modelId: body.model,
@@ -11812,6 +12287,7 @@ async function handleAnthropicMessages(req, res, options, modelCache, plog) {
         supportedParameters: model.supportedParameters,
         reasoning: model.reasoning,
         interleavedReasoningField: model.interleavedReasoningField,
+        compatibility: model.compatibility,
         upstreamModelId: upstreamModelId(model)
       },
       maxTools: npmMaxTools
@@ -12092,6 +12568,7 @@ async function getOrInitLanguageModel(modelCache, model, npm, baseURL, apiKey, w
       headers: model.headers,
       useResponsesLite: model.useResponsesLite,
       preferWebSockets: model.preferWebSockets,
+      compatibility: model.compatibility,
       onWebSocketDiagnostic: webSocketDiagnosticsLogPath ? (event) => writeWebSocketDiagnosticLog(webSocketDiagnosticsLogPath, event) : void 0
     });
     cached = { apiKey, languageModel };
@@ -13435,7 +13912,8 @@ function enrichServerModelReasoning(model) {
     apiBaseUrl: model.apiBaseUrl,
     supportedParameters: model.supportedParameters,
     reasoning: model.reasoning,
-    interleavedReasoningField: model.interleavedReasoningField
+    interleavedReasoningField: model.interleavedReasoningField,
+    compatibility: model.compatibility
   });
   if (!caps.defaultLevel) return model;
   return { ...model, defaultEffort: caps.defaultLevel };
@@ -14931,6 +15409,7 @@ function buildDesiredPatchConfig() {
         supportedParameters: model.supportedParameters,
         reasoning: model.reasoning ?? modelsDev?.reasoning,
         interleavedReasoningField: model.interleavedReasoningField ?? modelsDev?.interleaved?.field,
+        compatibility: model.compatibility,
         upstreamModelId: upstreamModelId2
       });
       meta.set(`${provider.id}:${model.id}`, {
@@ -16570,6 +17049,7 @@ Error: ${launchPlan.error}
           interleavedReasoningField: selectedModel.interleavedReasoningField,
           useResponsesLite: selectedModel.useResponsesLite,
           preferWebSockets: selectedModel.preferWebSockets,
+          compatibility: selectedModel.compatibility,
           headers: activeProvider.headers
         },
         launchApiKey ?? ""