@bman654/clodex 2.3.0 → 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.3.0",
+  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;
@@ -5267,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,
@@ -5310,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") {
@@ -5805,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",
@@ -5947,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
@@ -6203,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);
   }
@@ -6350,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);
@@ -6369,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") {
@@ -6433,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;
@@ -7243,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(/\/$/, "");
@@ -7254,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);
@@ -7336,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: [],
@@ -7424,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(() => {
@@ -7485,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,
@@ -8087,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
     };
   }
@@ -8106,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
   };
@@ -8220,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);
@@ -9462,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) {
@@ -9535,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;
     }
@@ -9708,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) {
@@ -9789,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",
@@ -9825,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) {
@@ -9833,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()
@@ -11102,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",
@@ -11140,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
             }
           });
@@ -11158,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
           });
@@ -11367,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);
 }
@@ -11922,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,
@@ -11972,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
@@ -12252,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 };
@@ -13595,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 };
@@ -15091,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}`, {
@@ -16730,6 +17049,7 @@ Error: ${launchPlan.error}
           interleavedReasoningField: selectedModel.interleavedReasoningField,
           useResponsesLite: selectedModel.useResponsesLite,
           preferWebSockets: selectedModel.preferWebSockets,
+          compatibility: selectedModel.compatibility,
           headers: activeProvider.headers
         },
         launchApiKey ?? ""