@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-NVOHIJKG.js

@@ -0,0 +1,1319 @@
+import {
+  PROVIDER_ID_MAP,
+  YAML_TO_V1_PROVIDER
+} from "./chunk-7DJ6SQH3.js";
+import {
+  createDefaultPricingSources
+} from "./chunk-OZAUKWHB.js";
+import {
+  ProviderRegistry,
+  resolveSharedRefreshPaths
+} from "./chunk-QJ6OEH4K.js";
+
+// src/core/providers/model-update/existence-index.ts
+import * as fs2 from "fs/promises";
+import * as path4 from "path";
+
+// src/core/providers/model-update/pricing/fetchers/litellm-fetcher.ts
+import * as path2 from "path";
+
+// src/core/providers/model-update/pricing/price-arithmetic.ts
+import Decimal from "decimal.js";
+Decimal.set({
+  precision: 20,
+  // Sufficient for any token pricing
+  rounding: Decimal.ROUND_HALF_UP
+});
+var MIN_DECIMALS = 2;
+var MAX_DECIMALS = 6;
+var MILLION = new Decimal(1e6);
+var THOUSAND = new Decimal(1e3);
+function perTokenToPerMillion(perToken) {
+  const decimal = new Decimal(perToken);
+  const perMillion = decimal.times(MILLION);
+  return formatPriceString(perMillion);
+}
+function formatPriceString(value) {
+  const rounded = value.toDecimalPlaces(MAX_DECIMALS, Decimal.ROUND_HALF_UP);
+  const withMaxDecimals = rounded.toFixed(MAX_DECIMALS);
+  const parts = withMaxDecimals.split(".");
+  const integerPart = parts[0];
+  if (parts.length < 2) {
+    return `${integerPart}.00`;
+  }
+  const decimalPart = parts[1];
+  if (!decimalPart) {
+    return `${integerPart}.00`;
+  }
+  let significantLength = MIN_DECIMALS;
+  for (let i = decimalPart.length - 1; i >= MIN_DECIMALS; i--) {
+    if (decimalPart[i] !== "0") {
+      significantLength = i + 1;
+      break;
+    }
+  }
+  return `${integerPart}.${decimalPart.slice(0, significantLength)}`;
+}
+function normalizePriceString(price) {
+  try {
+    const decimal = new Decimal(price);
+    if (decimal.isNaN() || !decimal.isFinite() || decimal.isNegative()) {
+      return null;
+    }
+    return formatPriceString(decimal);
+  } catch {
+    return null;
+  }
+}
+function calculatePriceDeltaPercent(oldPrice, newPrice) {
+  const oldDecimal = new Decimal(oldPrice);
+  const newDecimal = new Decimal(newPrice);
+  if (oldDecimal.isZero()) {
+    return newDecimal.isZero() ? 0 : 100;
+  }
+  return newDecimal.minus(oldDecimal).div(oldDecimal).times(100).toDecimalPlaces(2, Decimal.ROUND_HALF_UP).toNumber();
+}
+function isValidPriceString(price) {
+  if (typeof price !== "string") return false;
+  const pattern = /^\d+\.\d{2,6}$/;
+  if (!pattern.test(price)) return false;
+  try {
+    const decimal = new Decimal(price);
+    return decimal.isFinite() && !decimal.isNegative();
+  } catch {
+    return false;
+  }
+}
+function ensurePriceString(value) {
+  if (typeof value === "string") {
+    const normalized = normalizePriceString(value);
+    if (normalized === null) {
+      throw new Error(`Invalid price string: ${value}`);
+    }
+    return normalized;
+  }
+  return formatPriceString(new Decimal(value));
+}
+function convertOpenRouterPricing(pricing) {
+  const result = {
+    input_per_1m_tokens: perTokenToPerMillion(pricing.prompt),
+    output_per_1m_tokens: perTokenToPerMillion(pricing.completion)
+  };
+  if (pricing.input_cache_read && pricing.input_cache_read !== "0") {
+    result.cache_read_per_1m_tokens = perTokenToPerMillion(pricing.input_cache_read);
+  }
+  if (pricing.input_cache_write && pricing.input_cache_write !== "0") {
+    result.cache_write_per_1m_tokens = perTokenToPerMillion(pricing.input_cache_write);
+  }
+  return result;
+}
+function convertLiteLLMPricing(pricing) {
+  if (pricing.input_cost_per_token === void 0 || pricing.output_cost_per_token === void 0) {
+    return null;
+  }
+  const result = {
+    input_per_1m_tokens: perTokenToPerMillion(pricing.input_cost_per_token),
+    output_per_1m_tokens: perTokenToPerMillion(pricing.output_cost_per_token)
+  };
+  if (pricing.cache_read_input_token_cost !== void 0 && pricing.cache_read_input_token_cost !== 0) {
+    result.cache_read_per_1m_tokens = perTokenToPerMillion(pricing.cache_read_input_token_cost);
+  }
+  if (pricing.cache_creation_input_token_cost !== void 0 && pricing.cache_creation_input_token_cost !== 0) {
+    result.cache_write_per_1m_tokens = perTokenToPerMillion(
+      pricing.cache_creation_input_token_cost
+    );
+  }
+  return result;
+}
+
+// src/core/providers/model-update/pricing/fetchers/pricing-cache.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+function isPricingCacheExpired(expiresAt) {
+  return new Date(expiresAt) < /* @__PURE__ */ new Date();
+}
+async function readPricingCache(cachePath, isCacheEntry) {
+  try {
+    const content = await fs.readFile(cachePath, "utf-8");
+    const cache = JSON.parse(content);
+    return isCacheEntry(cache) ? cache : null;
+  } catch {
+    return null;
+  }
+}
+async function writePricingCache(cacheDir, filename, data, ttlHours, source) {
+  const cachePath = path.join(cacheDir, filename);
+  const now = /* @__PURE__ */ new Date();
+  const expiresAt = new Date(now.getTime() + ttlHours * 60 * 60 * 1e3);
+  const entry = {
+    data,
+    fetchedAt: now.toISOString(),
+    expiresAt: expiresAt.toISOString(),
+    ...source !== void 0 ? { source } : {}
+  };
+  await fs.mkdir(cacheDir, { recursive: true });
+  await fs.writeFile(cachePath, JSON.stringify(entry, null, 2));
+}
+
+// src/core/providers/model-update/pricing/fetchers/pricing-operation.ts
+function createPricingOperation() {
+  return { observations: /* @__PURE__ */ new Map() };
+}
+function acquirePricingOnce(operation, key, forceRefresh, acquire) {
+  if (!operation) return acquire();
+  const previous = operation.observations.get(key);
+  if (previous && (!forceRefresh || previous.forceRefresh)) return previous.result;
+  const result = previous ? previous.result.then((observation) => observation.cached ? acquire() : observation) : acquire();
+  const entry = { forceRefresh, result };
+  operation.observations.set(key, entry);
+  const forgetFailure = () => {
+    if (operation.observations.get(key) === entry) operation.observations.delete(key);
+  };
+  void result.then((observation) => {
+    if (!observation.success) forgetFailure();
+  }, forgetFailure);
+  return result;
+}
+
+// src/core/providers/model-update/pricing/fetchers/litellm-fetcher.ts
+var DEFAULT_CONFIG = {
+  timeoutMs: 3e4,
+  cacheTtlHours: 24
+};
+var LITELLM_ALLOWED_HOSTS = /* @__PURE__ */ new Set(["raw.githubusercontent.com"]);
+function isAllowedPricingSourceUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" && (LITELLM_ALLOWED_HOSTS.has(url.hostname) || Array.from(LITELLM_ALLOWED_HOSTS).some((host) => url.hostname.endsWith(`.${host}`)));
+  } catch {
+    return false;
+  }
+}
+function safeSourceName(name) {
+  return String(name).replace(/[^A-Za-z0-9_-]/g, "_");
+}
+function isLiteLLMCacheEntry(value) {
+  return typeof value === "object" && value !== null && typeof value.fetchedAt === "string" && typeof value.expiresAt === "string" && typeof value.source === "string" && typeof value.data === "object" && value.data !== null && !Array.isArray(value.data);
+}
+async function loadCache(cacheDir, sourceName) {
+  const cachePath = path2.join(cacheDir, `${safeSourceName(sourceName)}-pricing.json`);
+  return readPricingCache(
+    cachePath,
+    (value) => isLiteLLMCacheEntry(value) && !isPricingCacheExpired(value.expiresAt)
+  );
+}
+async function saveCache(cacheDir, sourceName, data, ttlHours) {
+  await writePricingCache(
+    cacheDir,
+    `${safeSourceName(sourceName)}-pricing.json`,
+    data,
+    ttlHours,
+    sourceName
+  );
+}
+async function fetchLiteLLMPricing(config = {}) {
+  const cfg = {
+    ...DEFAULT_CONFIG,
+    ...config,
+    cacheDir: config.cacheDir ?? path2.join(resolveSharedRefreshPaths().storageRoot, "cache", "pricing"),
+    sources: config.sources ?? createDefaultPricingSources()
+  };
+  return acquirePricingOnce(
+    cfg.pricingOperation,
+    JSON.stringify(["litellm", path2.resolve(cfg.cacheDir), cfg.sources]),
+    cfg.forceRefresh === true,
+    () => readLiteLLMPricing(cfg)
+  );
+}
+async function readLiteLLMPricing(cfg) {
+  const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const sortedSources = [...cfg.sources].filter((s) => s.enabled).sort((a, b) => a.priority - b.priority);
+  for (const source of sortedSources) {
+    if (!isAllowedPricingSourceUrl(source.url)) {
+      console.warn(`[LiteLLM Fetcher] Skipping non-allowlisted pricing source: ${source.url}`);
+      continue;
+    }
+    const cached = cfg.forceRefresh ? null : await loadCache(cfg.cacheDir, source.name);
+    if (cached) {
+      return {
+        success: true,
+        models: parseLiteLLMData(cached.data, cached.fetchedAt, source.name, source.url),
+        fetchedAt: cached.fetchedAt,
+        source: source.name,
+        cached: true
+      };
+    }
+    const result = await fetchFromSource(source, cfg.timeoutMs, fetchedAt);
+    if (result.success && result.data) {
+      await saveCache(cfg.cacheDir, source.name, result.data, cfg.cacheTtlHours);
+      return {
+        success: true,
+        models: parseLiteLLMData(result.data, fetchedAt, source.name, source.url),
+        fetchedAt,
+        source: source.name,
+        cached: false
+      };
+    }
+    console.warn(`[LiteLLM Fetcher] Source ${source.name} failed: ${result.error}`);
+  }
+  for (const source of sortedSources) {
+    const cachePath = path2.join(cfg.cacheDir, `${safeSourceName(source.name)}-pricing.json`);
+    try {
+      const cache = await readPricingCache(cachePath, isLiteLLMCacheEntry);
+      if (!cache) {
+        continue;
+      }
+      return {
+        success: true,
+        models: parseLiteLLMData(cache.data, cache.fetchedAt, source.name, source.url),
+        fetchedAt: cache.fetchedAt,
+        source: `${source.name}-stale-cache`,
+        cached: true,
+        error: "Using stale cache - all live sources failed"
+      };
+    } catch {
+    }
+  }
+  return {
+    success: false,
+    models: /* @__PURE__ */ new Map(),
+    fetchedAt,
+    source: "none",
+    cached: false,
+    error: "All pricing sources failed and no cache available"
+  };
+}
+async function fetchFromSource(source, timeoutMs, _fetchedAt) {
+  try {
+    if (!isAllowedPricingSourceUrl(source.url)) {
+      return {
+        success: false,
+        error: `Pricing source URL must be HTTPS and allowlisted: ${source.url}`
+      };
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(source.url, {
+        method: "GET",
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        return {
+          success: false,
+          error: `HTTP ${response.status}: ${response.statusText}`
+        };
+      }
+      const data = await response.json();
+      if (!data || typeof data !== "object" || Array.isArray(data)) {
+        return {
+          success: false,
+          error: "Invalid response: expected JSON object"
+        };
+      }
+      return { success: true, data };
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      return { success: false, error: `Request timed out after ${timeoutMs}ms` };
+    }
+    return {
+      success: false,
+      error: `Fetch failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function parseLiteLLMData(data, fetchedAt, sourceName, sourceUrl) {
+  const models = /* @__PURE__ */ new Map();
+  for (const [modelId, modelData] of Object.entries(data)) {
+    if (modelData.input_cost_per_token === void 0 || modelData.output_cost_per_token === void 0) {
+      continue;
+    }
+    const canonicalPricing = convertLiteLLMPricing({
+      input_cost_per_token: modelData.input_cost_per_token,
+      output_cost_per_token: modelData.output_cost_per_token,
+      cache_read_input_token_cost: modelData.cache_read_input_token_cost,
+      cache_creation_input_token_cost: modelData.cache_creation_input_token_cost
+    });
+    if (!canonicalPricing) {
+      continue;
+    }
+    const provenance = {
+      source: sourceName === "litellm" ? "litellm" : "tokencost",
+      source_url: sourceUrl,
+      fetched_at: fetchedAt,
+      source_model_id: modelId,
+      source_unit: "usd_per_token",
+      normalized_unit: "usd_per_1m_tokens",
+      normalized_precision_decimals: 2
+    };
+    const features = {};
+    if (modelData.supports_function_calling) features.function_calling = true;
+    if (modelData.supports_vision) features.vision = true;
+    if (modelData.supports_prompt_caching) features.prompt_caching = true;
+    const contextWindow = modelData.max_input_tokens ?? modelData.max_tokens ?? (modelData.max_output_tokens ? modelData.max_output_tokens * 4 : void 0);
+    const pricing = {
+      input_per_1m_tokens: canonicalPricing.input_per_1m_tokens,
+      output_per_1m_tokens: canonicalPricing.output_per_1m_tokens,
+      ...canonicalPricing.cache_read_per_1m_tokens && {
+        cache_read_per_1m_tokens: canonicalPricing.cache_read_per_1m_tokens
+      },
+      ...canonicalPricing.cache_write_per_1m_tokens && {
+        cache_write_per_1m_tokens: canonicalPricing.cache_write_per_1m_tokens
+      },
+      context_window: contextWindow,
+      features,
+      _meta: provenance
+    };
+    models.set(modelId, {
+      litellmId: modelId,
+      pricing,
+      provider: modelData.litellm_provider,
+      mode: modelData.mode,
+      maxInputTokens: modelData.max_input_tokens,
+      maxOutputTokens: modelData.max_output_tokens,
+      features,
+      provenance,
+      deprecationDate: modelData.deprecation_date
+    });
+  }
+  return models;
+}
+function mapLiteLLMProviderToBuild(litellmProvider) {
+  const mapping = {
+    anthropic: "claude",
+    openai: "codex",
+    "vertex_ai-anthropic_models": "claude",
+    "vertex_ai-chat-models": "gemini",
+    bedrock: "claude",
+    // Most bedrock models are Claude
+    gemini: "gemini",
+    google: "gemini",
+    xai: "xai"
+  };
+  return mapping[litellmProvider.toLowerCase()] ?? null;
+}
+
+// src/core/providers/model-update/pricing/fetchers/openrouter-fetcher.ts
+import * as path3 from "path";
+var DEFAULT_CONFIG2 = {
+  apiUrl: "https://openrouter.ai/api/v1/models",
+  timeoutMs: 1e4,
+  cacheTtlHours: 24
+};
+var OPENROUTER_ALLOWED_HOSTS = /* @__PURE__ */ new Set(["openrouter.ai"]);
+function isAllowedOpenRouterUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" && (OPENROUTER_ALLOWED_HOSTS.has(url.hostname) || Array.from(OPENROUTER_ALLOWED_HOSTS).some((host) => url.hostname.endsWith(`.${host}`)));
+  } catch {
+    return false;
+  }
+}
+function isOpenRouterModelsResponse(value) {
+  return typeof value === "object" && value !== null && Array.isArray(value.data);
+}
+async function loadCache2(cacheDir) {
+  const cachePath = path3.join(cacheDir, "openrouter-models.json");
+  return readPricingCache(cachePath, (value) => {
+    const cache = value;
+    return !isPricingCacheExpired(cache.expiresAt) && isOpenRouterModelsResponse(cache.data);
+  });
+}
+async function saveCache2(cacheDir, data, ttlHours) {
+  await writePricingCache(cacheDir, "openrouter-models.json", data, ttlHours);
+}
+async function fetchOpenRouterPricing(config = {}) {
+  const cfg = {
+    ...DEFAULT_CONFIG2,
+    ...config,
+    cacheDir: config.cacheDir ?? path3.join(resolveSharedRefreshPaths().storageRoot, "cache", "pricing")
+  };
+  return acquirePricingOnce(
+    cfg.pricingOperation,
+    JSON.stringify(["openrouter", path3.resolve(cfg.cacheDir), cfg.apiUrl]),
+    cfg.forceRefresh === true,
+    () => readOpenRouterPricing(cfg)
+  );
+}
+async function readOpenRouterPricing(cfg) {
+  const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (!isAllowedOpenRouterUrl(cfg.apiUrl)) {
+    return {
+      success: false,
+      models: /* @__PURE__ */ new Map(),
+      fetchedAt,
+      cached: false,
+      error: `OpenRouter API URL must be HTTPS and allowlisted: ${cfg.apiUrl}`
+    };
+  }
+  const cached = cfg.forceRefresh ? null : await loadCache2(cfg.cacheDir);
+  if (cached) {
+    return {
+      success: true,
+      models: parseOpenRouterResponse(cached.data, cached.fetchedAt),
+      fetchedAt: cached.fetchedAt,
+      cached: true
+    };
+  }
+  try {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (cfg.apiKey) {
+      headers.Authorization = `Bearer ${cfg.apiKey}`;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), cfg.timeoutMs);
+    try {
+      const response = await fetch(cfg.apiUrl, {
+        method: "GET",
+        headers,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        return {
+          success: false,
+          models: /* @__PURE__ */ new Map(),
+          fetchedAt,
+          cached: false,
+          error: `OpenRouter API returned ${response.status}: ${response.statusText}`
+        };
+      }
+      const data = await response.json();
+      if (!isOpenRouterModelsResponse(data)) {
+        return {
+          success: false,
+          models: /* @__PURE__ */ new Map(),
+          fetchedAt,
+          cached: false,
+          error: "Invalid OpenRouter API response: missing data array"
+        };
+      }
+      await saveCache2(cfg.cacheDir, data, cfg.cacheTtlHours);
+      return {
+        success: true,
+        models: parseOpenRouterResponse(data, fetchedAt),
+        fetchedAt,
+        cached: false
+      };
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      return {
+        success: false,
+        models: /* @__PURE__ */ new Map(),
+        fetchedAt,
+        cached: false,
+        error: `OpenRouter API request timed out after ${cfg.timeoutMs}ms`
+      };
+    }
+    return {
+      success: false,
+      models: /* @__PURE__ */ new Map(),
+      fetchedAt,
+      cached: false,
+      error: `Failed to fetch from OpenRouter API: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function parseOpenRouterResponse(response, fetchedAt) {
+  const models = /* @__PURE__ */ new Map();
+  for (const model of response.data) {
+    if (!model.pricing) continue;
+    const maxCompletionTokens = typeof model.top_provider?.max_completion_tokens === "number" ? model.top_provider.max_completion_tokens : void 0;
+    const canonicalPricing = convertOpenRouterPricing({
+      prompt: model.pricing.prompt,
+      completion: model.pricing.completion,
+      input_cache_read: model.pricing.input_cache_read,
+      input_cache_write: model.pricing.input_cache_write
+    });
+    const provenance = {
+      source: "openrouter",
+      source_url: "https://openrouter.ai/api/v1/models",
+      fetched_at: fetchedAt,
+      source_model_id: model.id,
+      source_unit: "usd_per_token",
+      normalized_unit: "usd_per_1m_tokens",
+      normalized_precision_decimals: 2
+    };
+    const pricing = {
+      input_per_1m_tokens: canonicalPricing.input_per_1m_tokens,
+      output_per_1m_tokens: canonicalPricing.output_per_1m_tokens,
+      ...canonicalPricing.cache_read_per_1m_tokens && {
+        cache_read_per_1m_tokens: canonicalPricing.cache_read_per_1m_tokens
+      },
+      ...canonicalPricing.cache_write_per_1m_tokens && {
+        cache_write_per_1m_tokens: canonicalPricing.cache_write_per_1m_tokens
+      },
+      context_window: model.context_length ?? model.top_provider?.context_length,
+      _meta: provenance
+    };
+    models.set(model.id, {
+      openRouterId: model.id,
+      name: model.name,
+      pricing,
+      contextLength: model.context_length,
+      maxCompletionTokens,
+      provenance
+    });
+  }
+  return models;
+}
+function getOpenRouterApiKey() {
+  return process.env.OPENROUTER_API_KEY;
+}
+
+// src/core/providers/model-update/pricing/model-id-normalizer.ts
+var PROVIDER_VENDOR_MAP = {
+  claude: "anthropic",
+  codex: "openai",
+  gemini: "google",
+  cursor: "cursor",
+  copilot: "github",
+  openrouter: "openrouter",
+  xai: "xai"
+};
+var VENDOR_PROVIDER_MAP = {
+  anthropic: "claude",
+  openai: "codex",
+  google: "gemini",
+  cursor: "cursor",
+  github: "copilot",
+  openrouter: "openrouter",
+  xai: "xai"
+};
+var BUILD_TO_LITELLM = {
+  claude: {
+    // claude-opus-4-7 / 4-8 use the dateless id form on LiteLLM; both bare ids
+    // are present in the live LiteLLM catalog (verified 2026-06-19 against
+    // model_prices_and_context_window.json), so they map directly like 4-6.
+    "claude-opus-4-8": "claude-opus-4-8",
+    "claude-opus-4-7": "claude-opus-4-7",
+    "claude-opus-4-6": "claude-opus-4-6",
+    "claude-sonnet-4-6": "claude-sonnet-4-6",
+    // NOTE: Explicit entries for 'claude-opus-4-5' and 'claude-haiku-4-5' were
+    // removed: they reused the Sonnet-4 date suffix (-20250514), which is not
+    // verified against live LiteLLM data. Until verified IDs are confirmed,
+    // these models fall through to the YAML catalog (_meta.external_ids) and
+    // then the heuristic/low-confidence rejection path, surfacing as unmapped
+    // instead of silently mapping to a suspect ID.
+    "claude-sonnet-4-5": "claude-sonnet-4-5-20250514",
+    "claude-sonnet-4": "claude-sonnet-4-20250514",
+    "claude-haiku-3-5": "claude-3-5-haiku-20241022",
+    "claude-3-5-sonnet": "claude-3-5-sonnet-20241022",
+    "claude-3-opus": "claude-3-opus-20240229",
+    "claude-3-sonnet": "claude-3-sonnet-20240229",
+    "claude-3-haiku": "claude-3-haiku-20240307"
+  },
+  codex: {
+    "gpt-5": "gpt-5",
+    "gpt-5-mini": "gpt-5-mini",
+    "gpt-5-codex-mini": "gpt-5-codex-mini",
+    "gpt-4.1": "gpt-4.1",
+    "gpt-4.1-mini": "gpt-4.1-mini",
+    "gpt-4.1-nano": "gpt-4.1-nano",
+    "gpt-4o": "gpt-4o-2024-11-20",
+    "gpt-4o-mini": "gpt-4o-mini-2024-07-18",
+    "gpt-4-turbo": "gpt-4-turbo-2024-04-09",
+    o1: "o1-2024-12-17",
+    "o1-mini": "o1-mini-2024-09-12",
+    "o1-pro": "o1-pro",
+    o3: "o3",
+    "o3-mini": "o3-mini",
+    "o4-mini": "o4-mini"
+  },
+  gemini: {
+    "gemini-3-pro": "gemini-3.0-pro",
+    "gemini-2.5-pro": "gemini-2.5-pro-preview-05-06",
+    "gemini-2.5-flash": "gemini-2.5-flash",
+    "gemini-2.0-flash": "gemini-2.0-flash-001",
+    "gemini-2.0-flash-thinking": "gemini-2.0-flash-thinking-exp",
+    "gemini-1.5-pro": "gemini-1.5-pro-002",
+    "gemini-1.5-flash": "gemini-1.5-flash-002"
+  }
+};
+var BUILD_TO_OPENROUTER = {
+  claude: {
+    // OpenRouter uses a DOTTED version form for the 4.x generation
+    // (`anthropic/claude-opus-4.8`), verified live 2026-06-19 against
+    // https://openrouter.ai/api/v1/models. The DASHED forms (`...-4-6`) 404 on
+    // OpenRouter, so each current 4.x id needs an explicit dotted entry here: the
+    // dash->dot rewrite is NOT in the heuristic (heuristicToOpenRouter only adds
+    // the `anthropic/` prefix), so an unmapped 4.x id would still emit a dashed,
+    // non-resolving slug and miss before the LiteLLM fallback. (OpenRouter is a
+    // pricing-only catalog — Build shells out to the `claude` CLI for Claude
+    // execution — so this affects cost data, not runs.)
+    "claude-opus-4-8": "anthropic/claude-opus-4.8",
+    "claude-opus-4-7": "anthropic/claude-opus-4.7",
+    "claude-opus-4-6": "anthropic/claude-opus-4.6",
+    "claude-sonnet-4-6": "anthropic/claude-sonnet-4.6",
+    "claude-opus-4-5": "anthropic/claude-opus-4.5",
+    "claude-sonnet-4-5": "anthropic/claude-sonnet-4.5",
+    "claude-haiku-4-5": "anthropic/claude-haiku-4.5",
+    "claude-sonnet-4": "anthropic/claude-sonnet-4",
+    "claude-haiku-3-5": "anthropic/claude-3.5-haiku",
+    "claude-3-5-sonnet": "anthropic/claude-3.5-sonnet",
+    "claude-3-opus": "anthropic/claude-3-opus",
+    "claude-3-sonnet": "anthropic/claude-3-sonnet",
+    "claude-3-haiku": "anthropic/claude-3-haiku"
+  },
+  codex: {
+    "gpt-5": "openai/gpt-5",
+    "gpt-5-mini": "openai/gpt-5-mini",
+    "gpt-4o": "openai/gpt-4o",
+    "gpt-4o-mini": "openai/gpt-4o-mini",
+    "gpt-4-turbo": "openai/gpt-4-turbo",
+    o1: "openai/o1",
+    "o1-mini": "openai/o1-mini",
+    "o1-pro": "openai/o1-pro",
+    o3: "openai/o3",
+    "o3-mini": "openai/o3-mini"
+  },
+  gemini: {
+    "gemini-3-pro": "google/gemini-3.0-pro",
+    "gemini-2.5-pro": "google/gemini-2.5-pro-preview",
+    "gemini-2.5-flash": "google/gemini-2.5-flash",
+    "gemini-2.0-flash": "google/gemini-2.0-flash-001",
+    "gemini-1.5-pro": "google/gemini-1.5-pro",
+    "gemini-1.5-flash": "google/gemini-1.5-flash"
+  }
+};
+function heuristicToLiteLLM(providerId, modelId) {
+  const normalized = modelId.toLowerCase().trim();
+  if (providerId === "claude") {
+    if (/\d{8}$/.test(normalized)) {
+      return { id: normalized, confidence: "high" };
+    }
+    if (normalized.includes("opus-4-6") || normalized.includes("opus-4.6")) {
+      return { id: "claude-opus-4-6", confidence: "medium" };
+    }
+    if (normalized.includes("sonnet-4-6") || normalized.includes("sonnet-4.6")) {
+      return { id: "claude-sonnet-4-6", confidence: "medium" };
+    }
+    if (normalized.includes("sonnet-4-5") || normalized.includes("sonnet-4.5")) {
+      return { id: "claude-sonnet-4-5-20250514", confidence: "medium" };
+    }
+    return { id: normalized, confidence: "low" };
+  }
+  if (providerId === "codex") {
+    if (/\d{4}-\d{2}-\d{2}/.test(normalized) || /\d{8}/.test(normalized)) {
+      return { id: normalized, confidence: "high" };
+    }
+    return { id: normalized, confidence: "medium" };
+  }
+  if (providerId === "gemini") {
+    if (!normalized.startsWith("gemini/") && !normalized.startsWith("google/")) {
+      return { id: `gemini/${normalized}`, confidence: "medium" };
+    }
+    return { id: normalized, confidence: "medium" };
+  }
+  return { id: normalized, confidence: "low" };
+}
+function heuristicToOpenRouter(providerId, modelId) {
+  const vendor = PROVIDER_VENDOR_MAP[providerId];
+  if (!vendor) return null;
+  const normalized = modelId.toLowerCase().trim();
+  if (normalized.includes("/")) {
+    return { id: normalized, confidence: "high" };
+  }
+  return { id: `${vendor}/${normalized}`, confidence: "medium" };
+}
+function parseOpenRouterId(openRouterId) {
+  const parts = openRouterId.split("/");
+  if (parts.length < 2) return null;
+  const vendor = parts[0];
+  const model = parts.slice(1).join("/");
+  if (!vendor || !model) return null;
+  const providerId = VENDOR_PROVIDER_MAP[vendor.toLowerCase()];
+  if (!providerId) return null;
+  if (providerId === "openrouter") {
+    return { providerId, modelId: openRouterId };
+  }
+  return { providerId, modelId: model };
+}
+var DefaultModelIdNormalizer = class {
+  /**
+   * Try to get explicit mapping from model catalog.
+   */
+  getExplicitMapping(providerId, modelId) {
+    try {
+      const providerConfig = ProviderRegistry.getProviderConfig(providerId);
+      const models = providerConfig.models.available;
+      const model = models.find(
+        (m) => m.id.toLowerCase() === modelId.toLowerCase() || m.id === modelId
+      );
+      if (model && "_meta" in model) {
+        const meta = model._meta;
+        if (meta?.external_ids) {
+          return meta.external_ids;
+        }
+      }
+    } catch {
+    }
+    return null;
+  }
+  toOpenRouter(buildProviderId, buildModelId) {
+    const normalizedProvider = buildProviderId.toLowerCase();
+    const normalizedModel = buildModelId.toLowerCase();
+    const explicitCodeMap = BUILD_TO_OPENROUTER[normalizedProvider];
+    if (explicitCodeMap?.[normalizedModel]) {
+      return explicitCodeMap[normalizedModel] ?? null;
+    }
+    const yamlMapping = this.getExplicitMapping(normalizedProvider, normalizedModel);
+    if (yamlMapping?.openrouter) {
+      return yamlMapping.openrouter ?? null;
+    }
+    const heuristic = heuristicToOpenRouter(normalizedProvider, normalizedModel);
+    if (heuristic && heuristic.confidence !== "low") {
+      return heuristic.id;
+    }
+    return null;
+  }
+  toLiteLLM(buildProviderId, buildModelId, meta) {
+    const normalizedProvider = buildProviderId.toLowerCase();
+    const normalizedModel = buildModelId.toLowerCase();
+    if (meta?.litellm) {
+      return meta.litellm ?? null;
+    }
+    const explicitCodeMap = BUILD_TO_LITELLM[normalizedProvider];
+    if (explicitCodeMap?.[normalizedModel]) {
+      return explicitCodeMap[normalizedModel] ?? null;
+    }
+    const yamlMapping = this.getExplicitMapping(normalizedProvider, normalizedModel);
+    if (yamlMapping?.litellm) {
+      return yamlMapping.litellm ?? null;
+    }
+    const heuristic = heuristicToLiteLLM(normalizedProvider, normalizedModel);
+    if (heuristic && heuristic.confidence !== "low") {
+      return heuristic.id;
+    }
+    return null;
+  }
+  fromExternal(externalId, source) {
+    if (source === "openrouter") {
+      return parseOpenRouterId(externalId);
+    }
+    const normalized = externalId.toLowerCase();
+    if (normalized.startsWith("claude-") || normalized.startsWith("anthropic/")) {
+      const modelId = normalized.replace("anthropic/", "");
+      return { providerId: "claude", modelId };
+    }
+    if (normalized.startsWith("gpt-") || normalized.startsWith("o1") || normalized.startsWith("o3") || normalized.startsWith("o4")) {
+      return { providerId: "codex", modelId: normalized };
+    }
+    if (normalized.startsWith("gemini") || normalized.startsWith("google/")) {
+      const modelId = normalized.replace("google/", "");
+      return { providerId: "gemini", modelId };
+    }
+    return null;
+  }
+};
+var DetailedModelIdNormalizer = class extends DefaultModelIdNormalizer {
+  /**
+   * Map to LiteLLM with detailed result information.
+   */
+  toLiteLLMDetailed(buildProviderId, buildModelId, meta) {
+    const normalizedProvider = buildProviderId.toLowerCase();
+    const normalizedModel = buildModelId.toLowerCase();
+    const warnings = [];
+    if (meta?.litellm) {
+      return {
+        success: true,
+        externalId: meta.litellm,
+        source: "explicit_yaml",
+        confidence: meta.verified ? "high" : "medium",
+        warnings
+      };
+    }
+    const explicitCodeMap = BUILD_TO_LITELLM[normalizedProvider];
+    const explicitId = explicitCodeMap?.[normalizedModel];
+    if (explicitId) {
+      return {
+        success: true,
+        externalId: explicitId,
+        source: "explicit_code",
+        confidence: "high",
+        warnings
+      };
+    }
+    const heuristic = heuristicToLiteLLM(normalizedProvider, normalizedModel);
+    if (heuristic) {
+      if (heuristic.confidence === "low") {
+        warnings.push(
+          `Low confidence mapping for ${buildProviderId}:${buildModelId} \u2192 ${heuristic.id}`
+        );
+      }
+      return {
+        success: heuristic.confidence !== "low",
+        externalId: heuristic.confidence !== "low" ? heuristic.id : null,
+        source: "heuristic",
+        confidence: heuristic.confidence,
+        warnings
+      };
+    }
+    return {
+      success: false,
+      externalId: null,
+      source: null,
+      confidence: null,
+      warnings: [`No mapping found for ${buildProviderId}:${buildModelId}`]
+    };
+  }
+  /**
+   * Map to OpenRouter with detailed result information.
+   */
+  toOpenRouterDetailed(buildProviderId, buildModelId) {
+    const normalizedProvider = buildProviderId.toLowerCase();
+    const normalizedModel = buildModelId.toLowerCase();
+    const warnings = [];
+    const explicitCodeMap = BUILD_TO_OPENROUTER[normalizedProvider];
+    const explicitId = explicitCodeMap?.[normalizedModel];
+    if (explicitId) {
+      return {
+        success: true,
+        externalId: explicitId,
+        source: "explicit_code",
+        confidence: "high",
+        warnings
+      };
+    }
+    const heuristic = heuristicToOpenRouter(normalizedProvider, normalizedModel);
+    if (heuristic) {
+      if (heuristic.confidence === "low") {
+        warnings.push(
+          `Low confidence mapping for ${buildProviderId}:${buildModelId} \u2192 ${heuristic.id}`
+        );
+      }
+      return {
+        success: heuristic.confidence !== "low",
+        externalId: heuristic.confidence !== "low" ? heuristic.id : null,
+        source: "heuristic",
+        confidence: heuristic.confidence,
+        warnings
+      };
+    }
+    return {
+      success: false,
+      externalId: null,
+      source: null,
+      confidence: null,
+      warnings: [`No mapping found for ${buildProviderId}:${buildModelId}`]
+    };
+  }
+};
+var modelIdNormalizer = new DefaultModelIdNormalizer();
+var detailedNormalizer = new DetailedModelIdNormalizer();
+
+// src/core/providers/model-update/existence-index.ts
+function toCanonicalProviderId(providerId) {
+  const lower = providerId.toLowerCase();
+  if (Object.hasOwn(PROVIDER_ID_MAP, lower)) {
+    return PROVIDER_ID_MAP[lower];
+  }
+  return lower;
+}
+function providerIdAliases(providerId) {
+  const lower = providerId.toLowerCase();
+  const aliases = /* @__PURE__ */ new Set([lower, toCanonicalProviderId(lower)]);
+  const v1 = YAML_TO_V1_PROVIDER[lower];
+  if (v1) aliases.add(v1);
+  return [...aliases];
+}
+var DEFAULT_CONFIG3 = {
+  cacheTtlHours: 24,
+  offline: false,
+  forceRefresh: false,
+  maxRetries: 3,
+  retryDelayMs: 1e3,
+  allowStaleCache: true
+};
+async function loadCache3(cacheDir) {
+  const cachePath = path4.join(cacheDir, "existence-index.json");
+  try {
+    const content = await fs2.readFile(cachePath, "utf-8");
+    const cache = JSON.parse(content);
+    if (!cache.index || !cache.fetchedAt || !cache.expiresAt || !cache.stats) {
+      return null;
+    }
+    return cache;
+  } catch {
+    return null;
+  }
+}
+function isCacheValid(cache) {
+  return new Date(cache.expiresAt) > /* @__PURE__ */ new Date();
+}
+async function saveCache3(cacheDir, index, stats, ttlHours) {
+  const cachePath = path4.join(cacheDir, "existence-index.json");
+  const tempPath = path4.join(
+    cacheDir,
+    `existence-index.json.tmp.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}`
+  );
+  const now = /* @__PURE__ */ new Date();
+  const expiresAt = new Date(now.getTime() + ttlHours * 60 * 60 * 1e3);
+  const indexObj = {};
+  for (const [key, value] of index.entries()) {
+    indexObj[key] = value;
+  }
+  const entry = {
+    index: indexObj,
+    fetchedAt: now.toISOString(),
+    expiresAt: expiresAt.toISOString(),
+    stats
+  };
+  await fs2.mkdir(cacheDir, { recursive: true });
+  try {
+    await fs2.writeFile(tempPath, JSON.stringify(entry, null, 2));
+    await fs2.rename(tempPath, cachePath);
+  } catch (error) {
+    await fs2.unlink(tempPath).catch(() => {
+    });
+    throw error;
+  }
+}
+async function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+async function withRetry(fn, maxRetries, initialDelayMs, providerName) {
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const result = await fn();
+      if (result.success) {
+        return result;
+      }
+      lastError = result.error || `${providerName} fetch failed`;
+      if (attempt === maxRetries) {
+        return result;
+      }
+      const delayMs = initialDelayMs * 2 ** attempt;
+      await sleep(delayMs);
+    } catch (error) {
+      lastError = error instanceof Error ? error.message : String(error);
+      if (attempt === maxRetries) {
+        return {
+          success: false,
+          error: `${providerName} fetch failed after ${maxRetries + 1} attempts: ${lastError}`
+        };
+      }
+      const delayMs = initialDelayMs * 2 ** attempt;
+      await sleep(delayMs);
+    }
+  }
+  return {
+    success: false,
+    error: `${providerName} fetch failed after ${maxRetries + 1} attempts: ${lastError}`
+  };
+}
+function normalizeToBuild(externalId, source) {
+  const result = detailedNormalizer.fromExternal(externalId, source);
+  if (result) {
+    return { providerId: toCanonicalProviderId(result.providerId), modelId: result.modelId };
+  }
+  const normalized = externalId.toLowerCase();
+  if (source === "openrouter") {
+    const openRouterGrok = normalized.match(/^(?:x-ai|xai)\/(.+)$/);
+    if (openRouterGrok?.[1]) {
+      return { providerId: "grok", modelId: openRouterGrok[1] };
+    }
+  }
+  if (source === "litellm") {
+    if (normalized.includes(".")) {
+      const parts = normalized.split(".");
+      const providerPart = parts[0];
+      const modelPart = parts.slice(1).join(".");
+      if (providerPart && modelPart) {
+        const providerMap = {
+          anthropic: "claude",
+          openai: "codex",
+          google: "gemini",
+          vertex_ai: "gemini",
+          xai: "grok",
+          "x-ai": "grok"
+        };
+        const buildProvider = providerMap[providerPart];
+        if (buildProvider) {
+          const cleanModel = stripVersionSuffix(modelPart);
+          return { providerId: buildProvider, modelId: cleanModel };
+        }
+      }
+    }
+    if (normalized.startsWith("claude-")) {
+      return { providerId: "claude", modelId: stripVersionSuffix(normalized) };
+    }
+    if (normalized.startsWith("gpt-") || normalized.startsWith("o1") || normalized.startsWith("o3") || normalized.startsWith("o4")) {
+      return { providerId: "codex", modelId: stripVersionSuffix(normalized) };
+    }
+    if (normalized.startsWith("gemini")) {
+      return { providerId: "gemini", modelId: stripVersionSuffix(normalized) };
+    }
+    if (normalized.startsWith("grok")) {
+      return { providerId: "grok", modelId: stripVersionSuffix(normalized) };
+    }
+  }
+  return null;
+}
+function stripVersionSuffix(modelId) {
+  let cleaned = modelId.replace(/-v\d+:\d+$/, "");
+  cleaned = cleaned.replace(/-\d{8}$/, "").replace(/-\d{4}-\d{2}-\d{2}$/, "");
+  cleaned = cleaned.replace(/-\d{3}$/, "");
+  return cleaned;
+}
+function makeIndexKey(providerId, modelId) {
+  return `${providerId.toLowerCase()}:${modelId.toLowerCase()}`;
+}
+function mergeFeatures(existing, incoming) {
+  if (!existing && !incoming) return void 0;
+  return {
+    ...existing ?? {},
+    ...incoming ?? {}
+  };
+}
+async function buildExistenceIndex(config = {}) {
+  const cfg = {
+    ...DEFAULT_CONFIG3,
+    ...config,
+    cacheDir: config.cacheDir ?? path4.join(resolveSharedRefreshPaths().storageRoot, "cache", "verification")
+  };
+  const index = /* @__PURE__ */ new Map();
+  const openRouterAliasToCanonicalKey = /* @__PURE__ */ new Map();
+  const cachedEntry = await loadCache3(cfg.cacheDir);
+  const isCacheFresh = cachedEntry ? isCacheValid(cachedEntry) : false;
+  if (!cfg.forceRefresh && isCacheFresh && cachedEntry) {
+    const indexMap = new Map(Object.entries(cachedEntry.index));
+    return {
+      success: true,
+      index: indexMap,
+      stats: cachedEntry.stats,
+      cached: true
+    };
+  }
+  if (cfg.offline) {
+    return {
+      success: false,
+      index,
+      stats: {
+        verified: 0,
+        highConfidence: 0,
+        openRouterTotal: 0,
+        litellmTotal: 0
+      },
+      cached: false,
+      error: "Offline mode: no cached existence index available"
+    };
+  }
+  const maxRetries = cfg.maxRetries ?? 3;
+  const retryDelayMs = cfg.retryDelayMs ?? 1e3;
+  const [openRouterResult, litellmResult] = await Promise.all([
+    cfg.pricingConfig?.openrouter?.enabled === false ? Promise.resolve({
+      success: false,
+      models: /* @__PURE__ */ new Map(),
+      cached: false,
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      error: "OpenRouter pricing source disabled"
+    }) : withRetry(
+      () => fetchOpenRouterPricing({
+        cacheDir: path4.join(path4.dirname(cfg.cacheDir), "pricing"),
+        forceRefresh: cfg.forceRefresh,
+        pricingOperation: cfg.pricingOperation,
+        ...cfg.pricingConfig?.openrouter?.api_url ? { apiUrl: cfg.pricingConfig.openrouter.api_url } : {}
+      }),
+      maxRetries,
+      retryDelayMs,
+      "OpenRouter"
+    ),
+    withRetry(
+      () => fetchLiteLLMPricing({
+        cacheDir: path4.join(path4.dirname(cfg.cacheDir), "pricing"),
+        forceRefresh: cfg.forceRefresh,
+        pricingOperation: cfg.pricingOperation,
+        ...cfg.pricingConfig ? { sources: cfg.pricingConfig.pricing_sources } : {}
+      }),
+      maxRetries,
+      retryDelayMs,
+      "LiteLLM"
+    )
+  ]);
+  const stats = {
+    verified: 0,
+    highConfidence: 0,
+    openRouterTotal: 0,
+    litellmTotal: 0
+  };
+  if (openRouterResult.success) {
+    stats.openRouterTotal = openRouterResult.models.size;
+    for (const [openRouterId, openRouterModel] of openRouterResult.models) {
+      const normalized = normalizeToBuild(openRouterId, "openrouter");
+      if (!normalized) continue;
+      const canonicalKey = makeIndexKey(normalized.providerId, normalized.modelId);
+      const openRouterKey = makeIndexKey("openrouter", openRouterId);
+      openRouterAliasToCanonicalKey.set(openRouterKey, canonicalKey);
+      const existing = index.get(canonicalKey);
+      if (existing) {
+        existing.foundIn.push("openrouter");
+        existing.externalIds.openrouter = openRouterId;
+        existing.verificationStatus = "verified";
+        existing.contextWindow ??= openRouterModel.contextLength;
+        existing.maxCompletionTokens ??= openRouterModel.maxCompletionTokens;
+        existing.maxOutputTokens ??= openRouterModel.maxCompletionTokens;
+      } else {
+        index.set(canonicalKey, {
+          buildId: normalized.modelId,
+          providerId: normalized.providerId,
+          foundIn: ["openrouter"],
+          externalIds: { openrouter: openRouterId },
+          verificationStatus: "high-confidence",
+          contextWindow: openRouterModel.contextLength,
+          maxCompletionTokens: openRouterModel.maxCompletionTokens,
+          maxOutputTokens: openRouterModel.maxCompletionTokens,
+          lastVerified: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+      const existingOpenRouter = index.get(openRouterKey);
+      if (!existingOpenRouter) {
+        index.set(openRouterKey, {
+          buildId: openRouterId,
+          providerId: "openrouter",
+          foundIn: ["openrouter"],
+          externalIds: { openrouter: openRouterId },
+          verificationStatus: "high-confidence",
+          contextWindow: openRouterModel.contextLength,
+          maxCompletionTokens: openRouterModel.maxCompletionTokens,
+          maxOutputTokens: openRouterModel.maxCompletionTokens,
+          lastVerified: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    }
+  }
+  if (litellmResult.success) {
+    stats.litellmTotal = litellmResult.models.size;
+    for (const [litellmId, model] of litellmResult.models) {
+      let providerId = null;
+      let modelId;
+      if (model.provider) {
+        providerId = mapLiteLLMProviderToBuild(model.provider);
+      }
+      if (!providerId) {
+        const normalized = normalizeToBuild(litellmId, "litellm");
+        if (!normalized) continue;
+        providerId = normalized.providerId;
+        modelId = normalized.modelId;
+      } else {
+        providerId = toCanonicalProviderId(providerId);
+        modelId = stripVersionSuffix(litellmId.replace(/^(?:[a-z]+\.)?anthropic\./i, ""));
+      }
+      const key = makeIndexKey(providerId, modelId);
+      const existing = index.get(key);
+      if (existing) {
+        if (!existing.foundIn.includes("litellm")) {
+          existing.foundIn.push("litellm");
+          existing.externalIds.litellm = litellmId;
+          existing.verificationStatus = "verified";
+        }
+        existing.maxInputTokens ??= model.maxInputTokens;
+        existing.maxOutputTokens = model.maxOutputTokens ?? existing.maxOutputTokens;
+        existing.contextWindow ??= model.maxInputTokens;
+        existing.features = mergeFeatures(existing.features, model.features);
+      } else {
+        index.set(key, {
+          buildId: modelId,
+          providerId,
+          foundIn: ["litellm"],
+          externalIds: { litellm: litellmId },
+          verificationStatus: "high-confidence",
+          maxInputTokens: model.maxInputTokens,
+          maxOutputTokens: model.maxOutputTokens,
+          contextWindow: model.maxInputTokens,
+          features: model.features,
+          lastVerified: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    }
+  }
+  for (const [openRouterKey, canonicalKey] of openRouterAliasToCanonicalKey.entries()) {
+    const canonical = index.get(canonicalKey);
+    const alias = index.get(openRouterKey);
+    if (!canonical || !alias) continue;
+    if (canonical.verificationStatus === "verified" && !alias.foundIn.includes("litellm")) {
+      alias.foundIn.push("litellm");
+      alias.externalIds.litellm = canonical.externalIds.litellm;
+      alias.verificationStatus = "verified";
+      alias.maxInputTokens ??= canonical.maxInputTokens;
+      alias.maxOutputTokens ??= canonical.maxOutputTokens;
+      alias.contextWindow ??= canonical.contextWindow;
+      alias.maxCompletionTokens ??= canonical.maxCompletionTokens;
+      alias.features = mergeFeatures(alias.features, canonical.features);
+    }
+  }
+  for (const entry of index.values()) {
+    if (entry.providerId === "openrouter") continue;
+    if (entry.verificationStatus === "verified") stats.verified++;
+    else stats.highConfidence++;
+  }
+  const bothFailed = !openRouterResult.success && !litellmResult.success;
+  if (bothFailed && cfg.allowStaleCache && cachedEntry) {
+    const indexMap = new Map(Object.entries(cachedEntry.index));
+    return {
+      success: true,
+      index: indexMap,
+      stats: cachedEntry.stats,
+      cached: true,
+      error: "Using stale cache due to fetch failures"
+    };
+  }
+  if (bothFailed) {
+    return {
+      success: false,
+      index,
+      stats: {
+        verified: 0,
+        highConfidence: 0,
+        openRouterTotal: 0,
+        litellmTotal: 0
+      },
+      cached: false,
+      error: "Both OpenRouter and LiteLLM fetches failed"
+    };
+  }
+  await saveCache3(cfg.cacheDir, index, stats, cfg.cacheTtlHours);
+  return {
+    success: true,
+    index,
+    stats,
+    cached: false,
+    error: bothFailed ? "Both OpenRouter and LiteLLM fetches failed" : void 0
+  };
+}
+function lookupModel(providerId, modelId, index) {
+  const strippedModelId = stripVersionSuffix(modelId);
+  for (const alias of providerIdAliases(providerId)) {
+    const exactMatch = index.get(makeIndexKey(alias, modelId));
+    if (exactMatch) {
+      return exactMatch;
+    }
+    const strippedMatch = index.get(makeIndexKey(alias, strippedModelId));
+    if (strippedMatch) {
+      return strippedMatch;
+    }
+  }
+  return null;
+}
+
+export {
+  createPricingOperation,
+  calculatePriceDeltaPercent,
+  isValidPriceString,
+  ensurePriceString,
+  fetchLiteLLMPricing,
+  fetchOpenRouterPricing,
+  getOpenRouterApiKey,
+  modelIdNormalizer,
+  buildExistenceIndex,
+  lookupModel
+};
+//# sourceMappingURL=chunk-NVOHIJKG.js.map