@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-YVCMDVBB.js

@@ -0,0 +1,698 @@
+import {
+  splitClaudeModelContextSuffix
+} from "./chunk-H3HGMISG.js";
+import {
+  ProviderRegistry
+} from "./chunk-QJ6OEH4K.js";
+import {
+  normalizeCodexHomePath,
+  readTomlValues
+} from "./chunk-BD3PGW6A.js";
+import {
+  expandHomeDir
+} from "./chunk-MNOVBYFU.js";
+
+// src/core/providers/codex/native-defaults.ts
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function codexNativeHome(env) {
+  return env.CODEX_HOME?.trim() ? normalizeCodexHomePath(env.CODEX_HOME) : join(env.HOME?.trim() || homedir(), ".codex");
+}
+function readCodexContextWindowOverride(env = process.env) {
+  try {
+    const value = readTomlValues(
+      readFileSync(join(codexNativeHome(env), "config.toml"), "utf8")
+    ).get("model_context_window");
+    return typeof value === "number" && value > 0 ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readCodexNativeDefaults(env = process.env) {
+  const result = { evidence: "configured-defaults" };
+  const home = codexNativeHome(env);
+  result.limitations = ["Run-selected Codex profiles and sidecar settings are not included."];
+  const files = [join(home, "config.toml")];
+  for (const file of files) {
+    let text;
+    try {
+      text = readFileSync(file, "utf8");
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        result.unavailablePaths ??= [];
+        result.unavailablePaths.push(file);
+      }
+      continue;
+    }
+    const values = readTomlValues(text);
+    for (const [field, key] of [
+      ["model", "model"],
+      ["reasoningEffort", "model_reasoning_effort"],
+      ["serviceTier", "service_tier"]
+    ]) {
+      const value = values.get(key);
+      if (typeof value === "string" && value.trim()) {
+        result[field] = { value, source: "native-config", sourcePath: `${file}#${key}` };
+      }
+    }
+  }
+  return result;
+}
+
+// src/core/providers/grok/native-defaults.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+function grokConfigPath(env) {
+  const explicit = env.GROK_HOME?.trim();
+  const home = explicit ? expandHomeDir(explicit) : join2(env.HOME?.trim() || homedir2(), ".grok");
+  return join2(home, "config.toml");
+}
+function readGrokConfigValues(env) {
+  const file = grokConfigPath(env);
+  try {
+    return { file, values: readTomlValues(readFileSync2(file, "utf8")) };
+  } catch (error) {
+    return { file, unreadable: error.code !== "ENOENT" };
+  }
+}
+function readGrokNativeDefaults(env = process.env) {
+  const result = {
+    evidence: "configured-defaults",
+    limitations: ["Run-selected Grok models and per-run overrides are not included."]
+  };
+  const { file, values, unreadable } = readGrokConfigValues(env);
+  if (unreadable) result.unavailablePaths = [file];
+  for (const [field, key] of [
+    ["model", "models.default"],
+    ["reasoningEffort", "models.default_reasoning_effort"]
+  ]) {
+    const value = values?.get(key);
+    if (typeof value === "string" && value.trim()) {
+      result[field] = { value, source: "native-config", sourcePath: `${file}#${key}` };
+    }
+  }
+  return result;
+}
+function readGrokContextWindowOverride(modelId, env = process.env) {
+  const value = readGrokConfigValues(env).values?.get(`model.${modelId}.context_window`);
+  return typeof value === "number" && value > 0 ? value : void 0;
+}
+function resolveGrokAutoModelFromConfig(env = process.env) {
+  const value = readGrokConfigValues(env).values?.get("models.default");
+  const model = typeof value === "string" ? value.trim() : "";
+  return model && model !== "auto" ? model : void 0;
+}
+
+// src/core/providers/opencode/model-metadata.ts
+var OPENCODE_CONTEXT_WINDOW_FALLBACKS = {
+  auto: 128e3,
+  "amazon-bedrock/amazon.nova-micro-v1:0": 128e3,
+  "amazon-bedrock/anthropic.claude-sonnet-4-6": 2e5,
+  "amazon-bedrock/anthropic.claude-opus-4-6-v1": 2e5,
+  "amazon-bedrock/moonshotai.kimi-k2.5": 262144,
+  "amazon-bedrock/qwen.qwen3-coder-480b-a35b-v1:0": 262144,
+  "zai-coding-plan/glm-5": 2e5,
+  "zai-coding-plan/glm-5.3": 1e6,
+  "z-ai/glm-4.7": 202752,
+  "z-ai/glm-4.6": 202752,
+  "z-ai/glm-4.5": 128e3,
+  "deepseek-v3": 163840
+};
+function deriveOpencodePrefixes(modelIds) {
+  const prefixes = /* @__PURE__ */ new Set();
+  for (const id of modelIds) {
+    const slash = id.indexOf("/");
+    if (slash > 0) {
+      prefixes.add(id.slice(0, slash).toLowerCase());
+    }
+  }
+  return prefixes;
+}
+function getOpencodeCatalogEntry(modelId, cacheDir) {
+  void cacheDir;
+  try {
+    const config = ProviderRegistry.getProviderConfig("opencode");
+    const available = config.models.available;
+    const normalizedModelId = modelId.trim().toLowerCase();
+    const entry = available.find(
+      (m) => m.id === modelId || m.id.toLowerCase() === normalizedModelId
+    );
+    if (entry != null) {
+      return {
+        modelId: entry.id,
+        contextWindow: entry.context_window,
+        maxOutputTokens: entry.max_output_tokens,
+        source: "registry"
+      };
+    }
+  } catch {
+  }
+  return { modelId, source: "none" };
+}
+function getOpencodeContextWindow(modelId, cacheDir) {
+  return getOpencodeCatalogEntry(modelId, cacheDir).contextWindow;
+}
+function findOpencodeFallbackContextWindow(modelId) {
+  const normalizedModelId = modelId.trim().toLowerCase();
+  if (normalizedModelId === "") {
+    return void 0;
+  }
+  const exactMatch = OPENCODE_CONTEXT_WINDOW_FALLBACKS[normalizedModelId];
+  if (exactMatch !== void 0) {
+    return { contextWindow: exactMatch, exact: true };
+  }
+  let bestMatch;
+  for (const [fallbackModelId, contextWindow] of Object.entries(
+    OPENCODE_CONTEXT_WINDOW_FALLBACKS
+  )) {
+    if (!isBoundarySubstringMatch(normalizedModelId, fallbackModelId)) {
+      continue;
+    }
+    if (bestMatch === void 0 || fallbackModelId.length > bestMatch.keyLength) {
+      bestMatch = { contextWindow, keyLength: fallbackModelId.length };
+    }
+  }
+  return bestMatch === void 0 ? void 0 : { contextWindow: bestMatch.contextWindow, exact: false };
+}
+function isIdBoundaryChar(char) {
+  return char === "/" || char === ":";
+}
+function isBoundaryAlignedSubstring(haystack, needle) {
+  if (needle === "") {
+    return false;
+  }
+  let from = 0;
+  while (from <= haystack.length - needle.length) {
+    const idx = haystack.indexOf(needle, from);
+    if (idx === -1) {
+      return false;
+    }
+    const beforeOk = idx === 0 || isIdBoundaryChar(haystack[idx - 1]);
+    const afterIdx = idx + needle.length;
+    const afterOk = afterIdx === haystack.length || isIdBoundaryChar(haystack[afterIdx]);
+    if (beforeOk && afterOk) {
+      return true;
+    }
+    from = idx + 1;
+  }
+  return false;
+}
+function isBoundarySubstringMatch(modelId, fallbackModelId) {
+  return isBoundaryAlignedSubstring(modelId, fallbackModelId) || isBoundaryAlignedSubstring(fallbackModelId, modelId);
+}
+function getOpencodeFallbackContextWindow(modelId) {
+  return findOpencodeFallbackContextWindow(modelId)?.contextWindow;
+}
+function resolveOpencodeContextWindow(modelId, defaultContextWindow = 128e3, cacheDir) {
+  return getOpencodeContextWindow(modelId, cacheDir) ?? getOpencodeFallbackContextWindow(modelId) ?? defaultContextWindow;
+}
+
+// src/core/config/model-metadata-resolver.ts
+var OPENAI_COMPATIBILITY_CONTEXT_WINDOWS = {
+  "gpt-4": 128e3,
+  "gpt-4-turbo": 128e3,
+  "gpt-4o": 128e3,
+  "gpt-4o-mini": 128e3,
+  "gpt-3.5-turbo": 16e3,
+  "gpt-3.5": 16e3
+};
+var LEGACY_CONTEXT_WINDOWS = {
+  // Compatibility-only estimator bucket. Delete when direct `openai`
+  // callers have migrated to codex or provider-specific routing.
+  openai: OPENAI_COMPATIBILITY_CONTEXT_WINDOWS,
+  // Cursor's `auto` remains a stable user-facing selector, not a registry model.
+  cursor: {
+    auto: 128e3
+  },
+  // Legacy Copilot aliases remain for pre-catalog callers. Delete when no
+  // caller passes removed GPT-4/GPT-3.5 Copilot names.
+  copilot: {
+    "gpt-4": 128e3,
+    "gpt-3.5-turbo": 16e3
+  },
+  // Historical Codex shorthand. Delete when `codex` is no longer accepted as a model id.
+  codex: {
+    codex: 8e3
+  }
+};
+function normalizeProvider(provider) {
+  const normalized = provider.trim().toLowerCase();
+  if (normalized === "anthropic") return "claude";
+  if (normalized === "google") return "gemini";
+  if (normalized === "github") return "copilot";
+  if (normalized === "cursor-cli") return "cursor";
+  if (normalized === "copilot-cli") return "copilot";
+  return normalized;
+}
+function findModelInfo(config, modelId) {
+  const normalizedModelId = modelId.toLowerCase();
+  return config.models.available.find(
+    (entry) => entry.id === modelId || entry.id.toLowerCase() === normalizedModelId
+  );
+}
+function findHarnessMaxContextWindow(model) {
+  try {
+    const config = ProviderRegistry.getProviderConfig(model.provider);
+    return findModelInfo(config, model.modelId)?.harness?.max_context_window;
+  } catch {
+    return void 0;
+  }
+}
+function findPricingKey(providerPricing, modelId) {
+  const modelPricing = providerPricing?.models;
+  if (!modelPricing) return void 0;
+  if (modelPricing[modelId]) {
+    return modelId;
+  }
+  const normalizedModelId = modelId.toLowerCase();
+  return Object.keys(modelPricing).find((key) => key.toLowerCase() === normalizedModelId);
+}
+function isPreviewModelId(modelId) {
+  return /(?:^|[-_/])preview(?:$|[-_/])/.test(modelId.toLowerCase());
+}
+function findMappedModel(config, model) {
+  return config.models.mappings[model] ?? config.models.mappings[model.toLowerCase()];
+}
+function resolveClaudeProviderModelForPricing(model, providerPricing) {
+  const vertexBaseModel = model.includes("@") ? model.slice(0, model.indexOf("@")) : model;
+  if (!vertexBaseModel.includes("anthropic.claude-")) {
+    return vertexBaseModel === model ? void 0 : vertexBaseModel;
+  }
+  const modelIds = providerPricing?.models ? Object.keys(providerPricing.models) : [];
+  let bestMatch;
+  for (const modelId of modelIds) {
+    if (vertexBaseModel.includes(modelId) && (!bestMatch || modelId.length > bestMatch.length)) {
+      bestMatch = modelId;
+    }
+  }
+  return bestMatch;
+}
+function resolveCodexProviderModelForPricing(model, providerPricing) {
+  const canonical = model.startsWith("openai.") ? model.slice("openai.".length) : void 0;
+  return canonical && findPricingKey(providerPricing, canonical) ? canonical : void 0;
+}
+function fuzzyRankingContextWindow(config, providerPricing, candidate) {
+  return findModelInfo(config, candidate)?.context_window ?? providerPricing?.models?.[findPricingKey(providerPricing, candidate) ?? ""]?.context_window ?? Number.POSITIVE_INFINITY;
+}
+function fuzzyFindModelId(config, providerPricing, model) {
+  const normalizedModel = model.toLowerCase();
+  const candidates = [
+    ...config.models.available.map((entry) => entry.id),
+    ...Object.keys(providerPricing?.models ?? {})
+  ].filter((candidate, index, all) => all.indexOf(candidate) === index);
+  const matches = candidates.filter((candidate) => {
+    const normalizedCandidate = candidate.toLowerCase();
+    return normalizedModel.includes(normalizedCandidate) || normalizedCandidate.includes(normalizedModel);
+  });
+  if (matches.length === 0) return void 0;
+  return matches.sort((left, right) => {
+    const leftContext = fuzzyRankingContextWindow(config, providerPricing, left);
+    const rightContext = fuzzyRankingContextWindow(config, providerPricing, right);
+    if (leftContext !== rightContext) return leftContext - rightContext;
+    const leftIsPreview = isPreviewModelId(left);
+    const rightIsPreview = isPreviewModelId(right);
+    if (leftIsPreview !== rightIsPreview) return leftIsPreview ? 1 : -1;
+    return right.localeCompare(left);
+  })[0];
+}
+function isExactCompatibilityMatch(provider, model) {
+  const providerFallbacks = LEGACY_CONTEXT_WINDOWS[normalizeProvider(provider)];
+  if (!providerFallbacks) {
+    return void 0;
+  }
+  const normalizedModel = model.trim().toLowerCase();
+  if (normalizedModel === "") {
+    return void 0;
+  }
+  if (providerFallbacks[normalizedModel] !== void 0) {
+    return true;
+  }
+  for (const fallbackModelId of Object.keys(providerFallbacks)) {
+    if (normalizedModel.includes(fallbackModelId) || fallbackModelId.includes(normalizedModel)) {
+      return false;
+    }
+  }
+  return void 0;
+}
+function resolveLegacyContextWindow(provider, model) {
+  const providerFallbacks = LEGACY_CONTEXT_WINDOWS[provider];
+  if (!providerFallbacks) {
+    return void 0;
+  }
+  const normalizedModel = model.trim().toLowerCase();
+  if (normalizedModel === "") {
+    return void 0;
+  }
+  const exactMatch = providerFallbacks[normalizedModel];
+  if (exactMatch !== void 0) {
+    return exactMatch;
+  }
+  for (const [fallbackModelId, contextWindow] of Object.entries(providerFallbacks)) {
+    if (normalizedModel.includes(fallbackModelId) || fallbackModelId.includes(normalizedModel)) {
+      return contextWindow;
+    }
+  }
+  return void 0;
+}
+function resolveOpencodeFallbackModel(requestedModel, options) {
+  if (!requestedModel) {
+    return void 0;
+  }
+  const catalogEntry = getOpencodeCatalogEntry(requestedModel);
+  if (catalogEntry.source === "registry") {
+    return {
+      provider: "opencode",
+      requestedModel,
+      modelId: catalogEntry.modelId,
+      matchType: "exact",
+      source: "opencode-catalog"
+    };
+  }
+  if (!options.allowFallback && !options.allowFuzzy) {
+    return void 0;
+  }
+  const fallback = findOpencodeFallbackContextWindow(requestedModel);
+  if (!fallback) {
+    return void 0;
+  }
+  if (!fallback.exact && !options.allowFuzzy) {
+    return void 0;
+  }
+  return {
+    provider: "opencode",
+    requestedModel,
+    modelId: requestedModel,
+    matchType: fallback.exact ? "fallback" : "fuzzy",
+    source: "opencode-catalog"
+  };
+}
+var PROVIDER_METADATA_HOOKS = {
+  claude: {
+    // A Claude Code context-window suffix (`[1m]`) selects the 1M session
+    // window; it is never part of the catalog/pricing model id. See the
+    // comment in resolveModel and claude/config.ts.
+    splitModelContextSuffix: splitClaudeModelContextSuffix,
+    // Vertex-style ids (`...anthropic.claude-...@rev`) map onto pricing ids.
+    resolvePricingModelId: resolveClaudeProviderModelForPricing
+  },
+  codex: {
+    // Codex-on-Bedrock reports `openai.gpt-*` transport ids. They are not
+    // accepted as public execution selectors, but they still map to the
+    // canonical Codex model for cost enrichment.
+    resolvePricingModelId: resolveCodexProviderModelForPricing,
+    // `model_context_window` in config.toml applies to whichever model runs.
+    resolveConfiguredContextWindow: (_modelId, env) => readCodexContextWindowOverride(env)
+  },
+  grok: {
+    // `[model."<id>"] context_window` in Grok's config.toml pins the run's window.
+    resolveConfiguredContextWindow: (modelId, env) => readGrokContextWindowOverride(modelId, env),
+    resolveConcreteModel: (modelId, env) => modelId.toLowerCase() === "auto" ? resolveGrokAutoModelFromConfig(env) : void 0
+  },
+  opencode: {
+    // OpenCode routes multi-provider model paths through its own catalog.
+    resolveFallbackModel: resolveOpencodeFallbackModel,
+    resolveContextWindow: (modelId) => resolveOpencodeContextWindow(modelId),
+    resolveMaxOutputTokens: (modelId) => getOpencodeCatalogEntry(modelId).maxOutputTokens
+  }
+};
+function providerMetadataHooks(provider) {
+  return Object.hasOwn(PROVIDER_METADATA_HOOKS, provider) ? PROVIDER_METADATA_HOOKS[provider] ?? {} : {};
+}
+var ModelMetadataResolver = class _ModelMetadataResolver {
+  static resolveModel(provider, model, options = {}) {
+    const normalizedProvider = normalizeProvider(provider);
+    const hooks = providerMetadataHooks(normalizedProvider);
+    const rawRequested = (model ?? "").trim();
+    const contextSuffix = hooks.splitModelContextSuffix?.(rawRequested);
+    if (rawRequested !== "" && contextSuffix?.suffix && contextSuffix.base.trim() === "") {
+      return void 0;
+    }
+    const requestedModel = contextSuffix?.base ?? rawRequested;
+    let config;
+    try {
+      config = ProviderRegistry.getProviderConfig(normalizedProvider);
+    } catch {
+      let providerPricing2;
+      try {
+        providerPricing2 = ProviderRegistry.getProviderPricing(normalizedProvider);
+      } catch {
+        providerPricing2 = void 0;
+      }
+      const pricingKey = requestedModel ? findPricingKey(providerPricing2, requestedModel) : void 0;
+      if (pricingKey) {
+        return {
+          provider: normalizedProvider,
+          requestedModel,
+          modelId: pricingKey,
+          matchType: "exact",
+          source: "provider-registry"
+        };
+      }
+      const pricingModelId2 = requestedModel ? hooks.resolvePricingModelId?.(requestedModel, providerPricing2) : void 0;
+      if (pricingModelId2) {
+        return {
+          provider: normalizedProvider,
+          requestedModel,
+          modelId: pricingModelId2,
+          matchType: "alias",
+          source: "provider-registry"
+        };
+      }
+      if (options.allowFallback && requestedModel && resolveLegacyContextWindow(normalizedProvider, requestedModel) !== void 0) {
+        return {
+          provider: normalizedProvider,
+          requestedModel,
+          modelId: requestedModel,
+          matchType: "fallback",
+          source: "compatibility"
+        };
+      }
+      return hooks.resolveFallbackModel?.(requestedModel, options);
+    }
+    const providerPricing = ProviderRegistry.getProviderPricing(normalizedProvider);
+    const modelToResolve = requestedModel || config.models.default;
+    const exactModel = findModelInfo(config, modelToResolve);
+    if (exactModel) {
+      return {
+        provider: normalizedProvider,
+        requestedModel,
+        modelId: exactModel.id,
+        matchType: "exact",
+        source: "provider-registry"
+      };
+    }
+    const exactPricingKey = findPricingKey(providerPricing, modelToResolve);
+    if (exactPricingKey) {
+      return {
+        provider: normalizedProvider,
+        requestedModel,
+        modelId: exactPricingKey,
+        matchType: "exact",
+        source: "provider-registry"
+      };
+    }
+    const pricingModelId = hooks.resolvePricingModelId?.(modelToResolve, providerPricing);
+    if (pricingModelId) {
+      return {
+        provider: normalizedProvider,
+        requestedModel,
+        modelId: pricingModelId,
+        matchType: "alias",
+        source: "provider-registry"
+      };
+    }
+    const mappedModel = findMappedModel(config, modelToResolve);
+    if (mappedModel) {
+      return {
+        provider: normalizedProvider,
+        requestedModel,
+        modelId: mappedModel,
+        matchType: "alias",
+        source: "provider-registry"
+      };
+    }
+    try {
+      const resolvedModel = ProviderRegistry.resolveModel(normalizedProvider, modelToResolve);
+      const resolvedIsKnown = findModelInfo(config, resolvedModel) !== void 0 || findPricingKey(providerPricing, resolvedModel) !== void 0;
+      if (resolvedModel !== modelToResolve || resolvedIsKnown) {
+        return {
+          provider: normalizedProvider,
+          requestedModel,
+          modelId: resolvedModel,
+          matchType: resolvedModel === modelToResolve ? "exact" : "alias",
+          source: "provider-registry"
+        };
+      }
+    } catch {
+    }
+    if (options.allowFuzzy) {
+      const fuzzyModelId = fuzzyFindModelId(config, providerPricing, modelToResolve);
+      if (fuzzyModelId) {
+        return {
+          provider: normalizedProvider,
+          requestedModel,
+          modelId: fuzzyModelId,
+          matchType: "fuzzy",
+          source: "provider-registry"
+        };
+      }
+    }
+    if (options.allowFallback && resolveLegacyContextWindow(normalizedProvider, modelToResolve) !== void 0) {
+      return {
+        provider: normalizedProvider,
+        requestedModel,
+        modelId: modelToResolve,
+        matchType: "fallback",
+        source: "compatibility"
+      };
+    }
+    return hooks.resolveFallbackModel?.(modelToResolve, options);
+  }
+  static getContextWindow(provider, model, options = {}) {
+    let resolvedModel = _ModelMetadataResolver.resolveModel(provider, model, options);
+    if (!resolvedModel) {
+      return void 0;
+    }
+    const hooks = providerMetadataHooks(resolvedModel.provider);
+    const concreteModel = hooks.resolveConcreteModel?.(resolvedModel.modelId, options.env);
+    if (concreteModel) {
+      resolvedModel = _ModelMetadataResolver.resolveModel(resolvedModel.provider, concreteModel, options) ?? resolvedModel;
+    }
+    if (hooks.resolveContextWindow) {
+      return hooks.resolveContextWindow(resolvedModel.modelId);
+    }
+    const configured = hooks.resolveConfiguredContextWindow?.(resolvedModel.modelId, options.env);
+    if (configured !== void 0) {
+      const nativeMax = findHarnessMaxContextWindow(resolvedModel);
+      return nativeMax !== void 0 ? Math.min(configured, nativeMax) : configured;
+    }
+    try {
+      const config = ProviderRegistry.getProviderConfig(resolvedModel.provider);
+      const modelInfo = findModelInfo(config, resolvedModel.modelId);
+      if (modelInfo?.harness?.context_window !== void 0) {
+        return modelInfo.harness.context_window;
+      }
+      if (modelInfo?.context_window !== void 0) {
+        return modelInfo.context_window;
+      }
+      const pricing = ProviderRegistry.getModelPricing(
+        resolvedModel.provider,
+        resolvedModel.modelId
+      );
+      if (pricing?.context_window !== void 0) {
+        return pricing.context_window;
+      }
+    } catch {
+    }
+    if (resolvedModel.source === "compatibility") {
+      return resolveLegacyContextWindow(resolvedModel.provider, resolvedModel.modelId);
+    }
+    return void 0;
+  }
+  static getMaxOutputTokens(provider, model, options = {}) {
+    const resolvedModel = _ModelMetadataResolver.resolveModel(provider, model, options);
+    if (!resolvedModel) {
+      return void 0;
+    }
+    const maxOutputHook = providerMetadataHooks(resolvedModel.provider).resolveMaxOutputTokens;
+    if (maxOutputHook) {
+      return maxOutputHook(resolvedModel.modelId);
+    }
+    try {
+      const config = ProviderRegistry.getProviderConfig(resolvedModel.provider);
+      return findModelInfo(config, resolvedModel.modelId)?.max_output_tokens;
+    } catch {
+      return void 0;
+    }
+  }
+  static getPricing(provider, model, options = {}) {
+    const resolvedModel = _ModelMetadataResolver.resolveModel(provider, model, options);
+    if (resolvedModel?.matchType === "fuzzy") {
+      return void 0;
+    }
+    if (!resolvedModel) {
+      try {
+        const normalizedProvider = normalizeProvider(provider);
+        const providerPricing = ProviderRegistry.getProviderPricing(normalizedProvider);
+        const directModelPricing = ProviderRegistry.getModelPricing(normalizedProvider, model);
+        if (!providerPricing || !directModelPricing) {
+          return void 0;
+        }
+        return {
+          resolvedModel: {
+            provider: normalizedProvider,
+            requestedModel: model,
+            modelId: model,
+            matchType: "exact",
+            source: "provider-registry"
+          },
+          modelPricing: directModelPricing,
+          providerPricing
+        };
+      } catch {
+        return void 0;
+      }
+    }
+    try {
+      const providerPricing = ProviderRegistry.getProviderPricing(resolvedModel.provider);
+      const pricingKey = findPricingKey(providerPricing, resolvedModel.modelId);
+      if (!providerPricing) {
+        return void 0;
+      }
+      if (!pricingKey || !providerPricing.models) {
+        const directModelPricing = ProviderRegistry.getModelPricing(
+          resolvedModel.provider,
+          resolvedModel.modelId
+        );
+        if (!directModelPricing) {
+          return void 0;
+        }
+        return {
+          resolvedModel,
+          modelPricing: directModelPricing,
+          providerPricing
+        };
+      }
+      const modelPricing = providerPricing.models[pricingKey];
+      if (!modelPricing) {
+        const directModelPricing = ProviderRegistry.getModelPricing(
+          resolvedModel.provider,
+          resolvedModel.modelId
+        );
+        if (!directModelPricing) {
+          return void 0;
+        }
+        return {
+          resolvedModel,
+          modelPricing: directModelPricing,
+          providerPricing
+        };
+      }
+      return {
+        resolvedModel: {
+          ...resolvedModel,
+          modelId: pricingKey
+        },
+        modelPricing,
+        providerPricing
+      };
+    } catch {
+      return void 0;
+    }
+  }
+};
+
+export {
+  codexNativeHome,
+  readCodexNativeDefaults,
+  readGrokNativeDefaults,
+  deriveOpencodePrefixes,
+  getOpencodeCatalogEntry,
+  findOpencodeFallbackContextWindow,
+  resolveOpencodeContextWindow,
+  isExactCompatibilityMatch,
+  ModelMetadataResolver
+};
+//# sourceMappingURL=chunk-YVCMDVBB.js.map