@desplega.ai/agent-swarm 1.158.0 → 1.160.0

package/dist/cli-tfky2838.js

@@ -0,0 +1,756 @@
+import {
+  buildModelsDevSeedRows,
+  loadModelsDevCache
+} from "./cli-vctdqs5h.js";
+import {
+  createLogEntry,
+  getActivePricingRow,
+  getDbClient,
+  init_db,
+  insertPricingRow
+} from "./cli-qydf22qq.js";
+import {
+  init_runtime_model_catalog,
+  setRuntimeModelCatalog
+} from "./cli-kmcpfwn2.js";
+import {
+  init_secret_scrubber,
+  scrubSecrets
+} from "./cli-r2ap2czm.js";
+
+// src/be/pricing-refresh.ts
+init_secret_scrubber();
+init_db();
+
+// src/be/model-catalog-store.ts
+init_runtime_model_catalog();
+init_db();
+
+// src/be/models-catalog.ts
+var CATALOG_PROVIDER_IDS = [
+  "openrouter",
+  "anthropic",
+  "openai",
+  "amazon-bedrock",
+  "opencode"
+];
+var PINNED_MODELSDEV_ENTRIES = [
+  "anthropic/claude-opus-5-5",
+  "anthropic/claude-sonnet-5-5",
+  "anthropic/claude-mythos-5",
+  "anthropic/claude-sonnet-5",
+  "amazon-bedrock/anthropic.claude-sonnet-5",
+  "openai/gpt-5-codex",
+  "openai/gpt-5.1-codex",
+  "openai/gpt-5.1-codex-max",
+  "openai/gpt-5.1-codex-mini",
+  "openai/gpt-5.2-codex"
+];
+function slimModel(modelKey, model) {
+  const reasoningOptions = Array.isArray(model.reasoning_options) ? model.reasoning_options.filter((o) => typeof o.type === "string").map((o) => ({
+    type: o.type,
+    ...Array.isArray(o.values) ? { values: o.values } : {}
+  })) : [];
+  return {
+    id: model.id ?? modelKey,
+    ...model.name !== undefined ? { name: model.name } : {},
+    ...model.cost !== undefined ? {
+      cost: {
+        input: model.cost.input,
+        output: model.cost.output,
+        ...model.cost.cache_read !== undefined ? { cache_read: model.cost.cache_read } : {},
+        ...model.cost.cache_write !== undefined ? { cache_write: model.cost.cache_write } : {}
+      }
+    } : {},
+    ...model.limit?.context !== undefined ? { limit: { context: model.limit.context } } : {},
+    ...typeof model.release_date === "string" ? { release_date: model.release_date } : {},
+    ...typeof model.status === "string" ? { status: model.status } : {},
+    ...model.reasoning !== undefined ? { reasoning: model.reasoning } : {},
+    ...reasoningOptions.length > 0 ? { reasoning_options: reasoningOptions } : {}
+  };
+}
+function buildModelsCatalog(cache) {
+  const catalog = {};
+  for (const providerId of CATALOG_PROVIDER_IDS) {
+    const provider = cache[providerId];
+    if (!provider?.models)
+      continue;
+    const models = {};
+    for (const [modelKey, model] of Object.entries(provider.models)) {
+      models[modelKey] = slimModel(modelKey, model);
+    }
+    catalog[providerId] = {
+      id: provider.id ?? providerId,
+      ...provider.name !== undefined ? { name: provider.name } : {},
+      models
+    };
+  }
+  return catalog;
+}
+var liveCatalog = null;
+var liveUpdatedAt = null;
+var snapshotCatalog;
+function bundledSnapshotCatalog() {
+  if (snapshotCatalog === undefined) {
+    const raw = loadModelsDevCache();
+    snapshotCatalog = raw ? buildModelsCatalog(raw) : null;
+  }
+  return snapshotCatalog ?? {};
+}
+function mergePinnedEntries(catalog) {
+  const snapshot = bundledSnapshotCatalog();
+  for (const entryPath of PINNED_MODELSDEV_ENTRIES) {
+    const slashIndex = entryPath.indexOf("/");
+    const providerId = entryPath.slice(0, slashIndex);
+    const modelId = entryPath.slice(slashIndex + 1);
+    if (catalog[providerId]?.models[modelId])
+      continue;
+    const pinned = snapshot[providerId]?.models[modelId];
+    if (!pinned)
+      continue;
+    catalog[providerId] ??= { id: providerId, models: {} };
+    catalog[providerId].models[modelId] = pinned;
+  }
+}
+function setLiveModelsCatalog(catalog, updatedAt) {
+  mergePinnedEntries(catalog);
+  liveCatalog = catalog;
+  liveUpdatedAt = updatedAt;
+}
+function invalidateModelsCatalog() {
+  liveCatalog = null;
+  liveUpdatedAt = null;
+  snapshotOverride = null;
+}
+function snapshotModelsCatalog() {
+  return structuredClone(bundledSnapshotCatalog());
+}
+var snapshotOverride = null;
+function setSnapshotOverlayCatalog(catalog) {
+  snapshotOverride = catalog;
+}
+function getModelsCatalog() {
+  if (liveCatalog) {
+    return { source: "live", updatedAt: liveUpdatedAt, providers: liveCatalog };
+  }
+  return {
+    source: "snapshot",
+    updatedAt: null,
+    providers: snapshotOverride ?? bundledSnapshotCatalog()
+  };
+}
+
+// src/be/model-catalog-store.ts
+var FACT_KEYS = [
+  "name",
+  "family",
+  "releaseDate",
+  "contextWindow",
+  "maxOutput",
+  "reasoning",
+  "reasoningOptions",
+  "pricing",
+  "status"
+];
+function parseJson(value) {
+  if (value === null)
+    return null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+function rowToFacts(row) {
+  return {
+    name: row.name,
+    family: row.family,
+    releaseDate: row.releaseDate,
+    contextWindow: row.contextWindow,
+    maxOutput: row.maxOutput,
+    reasoning: row.reasoning === null ? null : row.reasoning === 1,
+    reasoningOptions: parseJson(row.reasoningOptions),
+    pricing: parseJson(row.pricing),
+    status: row.status
+  };
+}
+function factParams(facts) {
+  return [
+    facts.name ?? null,
+    facts.family ?? null,
+    facts.releaseDate ?? null,
+    facts.contextWindow ?? null,
+    facts.maxOutput ?? null,
+    facts.reasoning === undefined || facts.reasoning === null ? null : facts.reasoning ? 1 : 0,
+    facts.reasoningOptions ? JSON.stringify(facts.reasoningOptions) : null,
+    facts.pricing ? JSON.stringify(facts.pricing) : null,
+    facts.status ?? null
+  ];
+}
+function pickNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function buildCatalogEntries(cache, checkedAt) {
+  const entries = [];
+  for (const providerId of CATALOG_PROVIDER_IDS) {
+    const provider = cache[providerId];
+    if (!provider?.models)
+      continue;
+    for (const [modelKey, rawModel] of Object.entries(provider.models)) {
+      const model = rawModel;
+      const reasoningOptions = Array.isArray(model.reasoning_options) ? model.reasoning_options.filter((o) => typeof o?.type === "string").map((o) => ({
+        type: o.type,
+        ...Array.isArray(o.values) ? { values: o.values } : {}
+      })) : [];
+      const pricing = {};
+      for (const key of ["input", "output", "cache_read", "cache_write"]) {
+        const value = pickNumber(model.cost?.[key]);
+        if (value !== undefined)
+          pricing[key] = value;
+      }
+      entries.push({
+        provider: providerId,
+        modelId: modelKey,
+        providerName: provider.name ?? null,
+        name: model.name ?? null,
+        family: model.family ?? null,
+        releaseDate: model.release_date ?? null,
+        contextWindow: pickNumber(model.limit?.context) ?? null,
+        maxOutput: pickNumber(model.limit?.output) ?? null,
+        reasoning: typeof model.reasoning === "boolean" ? model.reasoning : null,
+        reasoningOptions: reasoningOptions.length > 0 ? reasoningOptions : null,
+        pricing: Object.keys(pricing).length > 0 ? pricing : null,
+        status: model.status ?? null,
+        checkedAt
+      });
+    }
+  }
+  return entries;
+}
+async function replaceModelCatalog(entries) {
+  return await getDbClient().transaction(async (tx) => {
+    const before = await tx.query("SELECT provider, modelId FROM model_catalog");
+    const known = new Set(before.map((r) => `${r.provider}/${r.modelId}`));
+    await tx.run("DELETE FROM model_catalog");
+    const added = [];
+    for (const entry of entries) {
+      await tx.run(`INSERT INTO model_catalog
+           (provider, modelId, name, family, releaseDate, contextWindow, maxOutput, reasoning,
+            reasoningOptions, pricing, status, providerName, checkedAt)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+        entry.provider,
+        entry.modelId,
+        ...factParams(entry),
+        entry.providerName ?? null,
+        entry.checkedAt
+      ]);
+      const key = `${entry.provider}/${entry.modelId}`;
+      if (known.size > 0 && !known.has(key))
+        added.push(key);
+    }
+    return added;
+  });
+}
+async function touchModelCatalogCheckedAt(now) {
+  await getDbClient().run("UPDATE model_catalog SET checkedAt = ?", [now]);
+}
+async function listModelCatalog() {
+  const rows = await getDbClient().query("SELECT * FROM model_catalog ORDER BY provider, modelId");
+  return rows.map((row) => ({
+    provider: row.provider,
+    modelId: row.modelId,
+    providerName: row.providerName,
+    checkedAt: row.checkedAt,
+    ...rowToFacts(row)
+  }));
+}
+async function countModelCatalog() {
+  const row = await getDbClient().get("SELECT COUNT(*) AS n FROM model_catalog");
+  return row?.n ?? 0;
+}
+async function getModelCatalogMeta() {
+  const row = await getDbClient().get("SELECT etag, lastModified, lastFetchAt, lastCheckedAt FROM model_catalog_meta WHERE id = 1");
+  return row ?? { etag: null, lastModified: null, lastFetchAt: null, lastCheckedAt: null };
+}
+async function updateModelCatalogMeta(patch) {
+  const current = await getModelCatalogMeta();
+  const next = { ...current, ...patch };
+  await getDbClient().run(`INSERT INTO model_catalog_meta (id, etag, lastModified, lastFetchAt, lastCheckedAt)
+     VALUES (1, ?, ?, ?, ?)
+     ON CONFLICT(id) DO UPDATE SET
+       etag = excluded.etag,
+       lastModified = excluded.lastModified,
+       lastFetchAt = excluded.lastFetchAt,
+       lastCheckedAt = excluded.lastCheckedAt`, [next.etag, next.lastModified, next.lastFetchAt, next.lastCheckedAt]);
+}
+function overlayRowToEntry(row) {
+  return {
+    provider: row.provider,
+    modelId: row.modelId,
+    reason: row.reason,
+    verifiedBy: row.verifiedBy,
+    expiresWhenUpstreamMatches: row.expiresWhenUpstreamMatches === 1,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    ...rowToFacts(row)
+  };
+}
+async function listModelCatalogOverlay() {
+  const rows = await getDbClient().query("SELECT * FROM model_catalog_overlay ORDER BY provider, modelId");
+  return rows.map(overlayRowToEntry);
+}
+async function upsertModelCatalogOverlay(input, opts = {}) {
+  const now = opts.now ?? Date.now();
+  const userId = opts.userId ?? null;
+  await getDbClient().run(`INSERT INTO model_catalog_overlay
+       (provider, modelId, name, family, releaseDate, contextWindow, maxOutput, reasoning,
+        reasoningOptions, pricing, status, reason, verifiedBy, expiresWhenUpstreamMatches,
+        createdAt, updatedAt, created_by, updated_by)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(provider, modelId) DO UPDATE SET
+       name = excluded.name,
+       family = excluded.family,
+       releaseDate = excluded.releaseDate,
+       contextWindow = excluded.contextWindow,
+       maxOutput = excluded.maxOutput,
+       reasoning = excluded.reasoning,
+       reasoningOptions = excluded.reasoningOptions,
+       pricing = excluded.pricing,
+       status = excluded.status,
+       reason = excluded.reason,
+       verifiedBy = excluded.verifiedBy,
+       expiresWhenUpstreamMatches = excluded.expiresWhenUpstreamMatches,
+       updatedAt = excluded.updatedAt,
+       updated_by = excluded.updated_by`, [
+    input.provider,
+    input.modelId,
+    ...factParams(input),
+    input.reason,
+    input.verifiedBy ?? null,
+    input.expiresWhenUpstreamMatches === false ? 0 : 1,
+    now,
+    now,
+    userId,
+    userId
+  ]);
+  await applyOverlayPricingRows(now);
+  markModelsCatalogStale();
+  const row = await getDbClient().get("SELECT * FROM model_catalog_overlay WHERE provider = ? AND modelId = ?", [input.provider, input.modelId]);
+  if (!row)
+    throw new Error("overlay row vanished after upsert");
+  return overlayRowToEntry(row);
+}
+async function deleteModelCatalogOverlay(provider, modelId) {
+  const result = await getDbClient().run("DELETE FROM model_catalog_overlay WHERE provider = ? AND modelId = ?", [provider, modelId]);
+  markModelsCatalogStale();
+  return result.changes > 0;
+}
+function factEquals(key, overlay, upstream) {
+  if (key === "pricing") {
+    const o = overlay;
+    const u = upstream ?? {};
+    return Object.keys(o).every((k) => o[k] === undefined || o[k] === null || o[k] === u[k]);
+  }
+  if (key === "reasoningOptions")
+    return JSON.stringify(overlay) === JSON.stringify(upstream);
+  return overlay === upstream;
+}
+async function expireMatchedOverlays() {
+  const overlays = await listModelCatalogOverlay();
+  if (overlays.length === 0)
+    return [];
+  const upstream = new Map((await listModelCatalog()).map((e) => [`${e.provider}/${e.modelId}`, e]));
+  const expired = [];
+  for (const overlay of overlays) {
+    if (!overlay.expiresWhenUpstreamMatches)
+      continue;
+    const key = `${overlay.provider}/${overlay.modelId}`;
+    const up = upstream.get(key);
+    if (!up)
+      continue;
+    const matches = FACT_KEYS.every((fact) => {
+      const value = overlay[fact];
+      if (value === null || value === undefined)
+        return true;
+      return factEquals(fact, value, up[fact]);
+    });
+    if (!matches)
+      continue;
+    await deleteModelCatalogOverlay(overlay.provider, overlay.modelId);
+    expired.push(key);
+  }
+  return expired;
+}
+async function applyOverlayPricingRows(now = Date.now()) {
+  const overlays = await listModelCatalogOverlay();
+  const upstream = new Set((await listModelCatalog()).map((e) => `${e.provider}/${e.modelId}`));
+  const synthetic = {};
+  const overlayOnly = {};
+  for (const overlay of overlays) {
+    if (!overlay.pricing || Object.keys(overlay.pricing).length === 0)
+      continue;
+    for (const target of upstream.has(`${overlay.provider}/${overlay.modelId}`) ? [synthetic] : [synthetic, overlayOnly]) {
+      target[overlay.provider] ??= { models: {} };
+      const models = target[overlay.provider]?.models;
+      if (models)
+        models[overlay.modelId] = { cost: overlay.pricing };
+    }
+  }
+  if (Object.keys(synthetic).length === 0)
+    return 0;
+  const rows = buildModelsDevSeedRows(synthetic);
+  const tripleKey = (r) => `${r.provider}|${r.model}|${r.tokenClass}`;
+  const emptyBlocks = Object.fromEntries(Object.keys(overlayOnly).map((provider) => [provider, { models: {} }]));
+  const fallbackKeys = new Set(buildModelsDevSeedRows(emptyBlocks).map(tripleKey));
+  const overlayOwned = new Set(buildModelsDevSeedRows(overlayOnly).map(tripleKey).filter((key) => !fallbackKeys.has(key)));
+  return await getDbClient().transaction(async () => {
+    let inserted = 0;
+    for (const row of rows) {
+      const existing = await getActivePricingRow(row.provider, row.model, row.tokenClass, now);
+      if (existing) {
+        if (!overlayOwned.has(tripleKey(row)))
+          continue;
+        if (existing.pricePerMillionUsd === row.pricePerMillionUsd)
+          continue;
+        if (existing.effectiveFrom === now) {
+          await getDbClient().run("UPDATE pricing SET price_per_million_usd = ?, lastUpdatedAt = ? WHERE provider = ? AND model = ? AND token_class = ? AND effective_from = ?", [row.pricePerMillionUsd, now, row.provider, row.model, row.tokenClass, now]);
+          inserted += 1;
+          continue;
+        }
+      }
+      const input = { ...row, effectiveFrom: now };
+      await insertPricingRow(input);
+      inserted += 1;
+    }
+    return inserted;
+  });
+}
+function toCatalogModel(modelId, facts) {
+  const cost = facts.pricing && (facts.pricing.input !== undefined || facts.pricing.output !== undefined) ? {
+    input: facts.pricing.input,
+    output: facts.pricing.output,
+    ...facts.pricing.cache_read !== undefined ? { cache_read: facts.pricing.cache_read } : {},
+    ...facts.pricing.cache_write !== undefined ? { cache_write: facts.pricing.cache_write } : {}
+  } : undefined;
+  const reasoning = facts.reasoning ?? (facts.reasoningOptions && facts.reasoningOptions.length > 0 ? true : null);
+  return {
+    id: modelId,
+    ...facts.name ? { name: facts.name } : {},
+    ...cost ? { cost } : {},
+    ...facts.contextWindow != null ? { limit: { context: facts.contextWindow } } : {},
+    ...facts.releaseDate ? { release_date: facts.releaseDate } : {},
+    ...facts.status ? { status: facts.status } : {},
+    ...reasoning != null ? { reasoning } : {},
+    ...facts.reasoningOptions && facts.reasoningOptions.length > 0 ? { reasoning_options: facts.reasoningOptions } : {}
+  };
+}
+function mergeFacts(base, overlay) {
+  const merged = { ...base };
+  for (const key of FACT_KEYS) {
+    const value = overlay[key];
+    if (value === null || value === undefined)
+      continue;
+    if (key === "pricing") {
+      merged.pricing = { ...base.pricing ?? {}, ...value };
+    } else {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+function applyOverlays(catalog, baseFacts, overlays) {
+  for (const overlay of overlays) {
+    const providerId = overlay.provider;
+    const key = `${overlay.provider}/${overlay.modelId}`;
+    const base = baseFacts.get(key) ?? {};
+    catalog[providerId] ??= { id: providerId, models: {} };
+    catalog[providerId].models[overlay.modelId] = toCatalogModel(overlay.modelId, mergeFacts(base, overlay));
+  }
+}
+function catalogModelToFacts(model) {
+  return {
+    name: model.name ?? null,
+    contextWindow: model.limit?.context ?? null,
+    releaseDate: model.release_date ?? null,
+    status: model.status ?? null,
+    reasoning: model.reasoning ?? null,
+    reasoningOptions: model.reasoning_options ?? null,
+    pricing: model.cost ? { ...model.cost } : null
+  };
+}
+var catalogLoaded = false;
+var catalogGeneration = 0;
+function getCatalogGeneration() {
+  return catalogGeneration;
+}
+async function reloadModelsCatalog() {
+  catalogGeneration++;
+  invalidateModelsCatalog();
+  const [entries, overlays, meta] = await Promise.all([
+    listModelCatalog(),
+    listModelCatalogOverlay(),
+    getModelCatalogMeta()
+  ]);
+  if (entries.length === 0) {
+    if (overlays.length > 0) {
+      const snapshot = snapshotModelsCatalog();
+      const baseFacts2 = new Map;
+      for (const [providerId, provider] of Object.entries(snapshot)) {
+        for (const [modelId, model] of Object.entries(provider?.models ?? {})) {
+          baseFacts2.set(`${providerId}/${modelId}`, catalogModelToFacts(model));
+        }
+      }
+      applyOverlays(snapshot, baseFacts2, overlays);
+      setSnapshotOverlayCatalog(snapshot);
+    }
+    catalogLoaded = true;
+    return publishRuntimeCatalog(getModelsCatalog());
+  }
+  const catalog = {};
+  const baseFacts = new Map;
+  for (const entry of entries) {
+    const providerId = entry.provider;
+    catalog[providerId] ??= {
+      id: providerId,
+      ...entry.providerName ? { name: entry.providerName } : {},
+      models: {}
+    };
+    catalog[providerId].models[entry.modelId] = toCatalogModel(entry.modelId, entry);
+    baseFacts.set(`${entry.provider}/${entry.modelId}`, entry);
+  }
+  applyOverlays(catalog, baseFacts, overlays);
+  setLiveModelsCatalog(catalog, meta.lastFetchAt);
+  catalogLoaded = true;
+  return publishRuntimeCatalog(getModelsCatalog());
+}
+function publishRuntimeCatalog(result) {
+  setRuntimeModelCatalog(result.providers, Date.now(), result.source);
+  return result;
+}
+function markModelsCatalogStale() {
+  catalogLoaded = false;
+  catalogGeneration++;
+  invalidateModelsCatalog();
+}
+async function loadModelsCatalog() {
+  if (!catalogLoaded)
+    return await reloadModelsCatalog();
+  return getModelsCatalog();
+}
+
+// src/be/pricing-refresh.ts
+var MODELSDEV_API_URL = "https://models.dev/api.json";
+var PRICING_REFRESH_INTERVAL_MS = 12 * 60 * 60 * 1000;
+var MODEL_CATALOG_FRESH_MS = 4 * 60 * 60 * 1000;
+var refreshLoopStarted = false;
+function logPricingRefresh(message) {
+  console.log(scrubSecrets(`[pricing-refresh] ${message}`));
+}
+function logPricingRefreshError(message, err) {
+  const detail = err instanceof Error ? err.message : String(err);
+  console.warn(scrubSecrets(`[pricing-refresh] ${message}: ${detail}`));
+}
+async function insertChangedPricingRows(rows, now) {
+  return await getDbClient().transaction(async () => {
+    let inserted = 0;
+    let unchanged = 0;
+    for (const row of rows) {
+      const existing = await getActivePricingRow(row.provider, row.model, row.tokenClass, now);
+      if (existing?.pricePerMillionUsd === row.pricePerMillionUsd) {
+        unchanged += 1;
+        continue;
+      }
+      const input = {
+        ...row,
+        effectiveFrom: now
+      };
+      await insertPricingRow(input);
+      inserted += 1;
+    }
+    return { inserted, unchanged };
+  });
+}
+async function prunePricingHistory(keepLatest = 2) {
+  const result = await getDbClient().run(`DELETE FROM pricing
+     WHERE rowid IN (
+       SELECT rowid
+       FROM (
+         SELECT
+           rowid,
+           ROW_NUMBER() OVER (
+             PARTITION BY provider, model, token_class
+             ORDER BY effective_from DESC
+           ) AS rn
+         FROM pricing
+       )
+       WHERE rn > ?
+     )`, [keepLatest]);
+  return result.changes;
+}
+async function auditPricingRefresh(result) {
+  try {
+    await createLogEntry({
+      eventType: "pricing.refresh",
+      newValue: `${result.status}: inserted=${result.inserted}; unchanged=${result.unchanged}; pruned=${result.pruned}`,
+      metadata: {
+        status: result.status,
+        candidateRows: result.candidateRows,
+        inserted: result.inserted,
+        unchanged: result.unchanged,
+        pruned: result.pruned,
+        etag: result.etag
+      }
+    });
+  } catch (err) {
+    logPricingRefreshError("audit log write failed", err);
+  }
+}
+async function auditPricingRefreshFailure(err) {
+  try {
+    await createLogEntry({
+      eventType: "pricing.refresh.failed",
+      newValue: scrubSecrets(err instanceof Error ? err.message : String(err))
+    });
+  } catch (auditErr) {
+    logPricingRefreshError("failure audit log write failed", auditErr);
+  }
+}
+async function refreshPricingFromModelsDev(opts = {}) {
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const now = opts.now ?? Date.now();
+  const meta = await getModelCatalogMeta();
+  const catalogCount = await countModelCatalog();
+  const headers = {};
+  if (catalogCount > 0 && meta.etag)
+    headers["If-None-Match"] = meta.etag;
+  if (catalogCount > 0 && meta.lastModified)
+    headers["If-Modified-Since"] = meta.lastModified;
+  const response = await fetchImpl(MODELSDEV_API_URL, { headers });
+  if (response.status === 304) {
+    await touchModelCatalogCheckedAt(now);
+    await updateModelCatalogMeta({ lastCheckedAt: now });
+    await reloadModelsCatalog();
+    const result2 = {
+      status: "not_modified",
+      candidateRows: 0,
+      inserted: 0,
+      unchanged: 0,
+      pruned: 0,
+      etag: meta.etag ?? undefined,
+      added: [],
+      expiredOverlays: [],
+      catalogModels: catalogCount
+    };
+    await auditPricingRefresh(result2);
+    logPricingRefresh("models.dev returned 304; pricing rows unchanged");
+    return result2;
+  }
+  if (!response.ok) {
+    throw new Error(`models.dev returned HTTP ${response.status}`);
+  }
+  const cache = await response.json();
+  const etag = response.headers.get("etag");
+  const lastModified = response.headers.get("last-modified");
+  const entries = buildCatalogEntries(cache, now);
+  const added = await replaceModelCatalog(entries);
+  const rows = buildModelsDevSeedRows(cache);
+  const { inserted, unchanged } = await insertChangedPricingRows(rows, now);
+  const expiredOverlays = await expireMatchedOverlays();
+  const overlayInserted = await applyOverlayPricingRows(now);
+  const pruned = await prunePricingHistory(2);
+  await updateModelCatalogMeta({ etag, lastModified, lastFetchAt: now, lastCheckedAt: now });
+  await reloadModelsCatalog();
+  const result = {
+    status: "refreshed",
+    candidateRows: rows.length,
+    inserted: inserted + overlayInserted,
+    unchanged,
+    pruned,
+    etag: etag ?? undefined,
+    added,
+    expiredOverlays,
+    catalogModels: entries.length
+  };
+  await auditPricingRefresh(result);
+  logPricingRefresh(`refreshed ${rows.length} candidate row(s); inserted=${inserted}; unchanged=${unchanged}; pruned=${pruned}; catalog=${entries.length}; added=${added.length}; expiredOverlays=${expiredOverlays.length}`);
+  return result;
+}
+var MODEL_CATALOG_FORCE_COOLDOWN_MS = 60 * 1000;
+var refreshInFlight = null;
+var lastForcedRefreshAt = null;
+function resetModelCatalogRefreshGuardForTests() {
+  refreshInFlight = null;
+  lastForcedRefreshAt = null;
+}
+function refreshModelCatalog(opts = {}) {
+  if (refreshInFlight)
+    return refreshInFlight;
+  const run = runModelCatalogRefresh(opts).finally(() => {
+    if (refreshInFlight === run)
+      refreshInFlight = null;
+  });
+  refreshInFlight = run;
+  return run;
+}
+async function requestModelCatalogRefresh(opts = {}) {
+  const now = opts.now ?? Date.now();
+  if (opts.force) {
+    const waitMs = lastForcedRefreshAt === null ? 0 : lastForcedRefreshAt + MODEL_CATALOG_FORCE_COOLDOWN_MS - now;
+    if (waitMs > 0) {
+      const meta = await getModelCatalogMeta().catch(() => null);
+      return {
+        status: "skipped-cooldown",
+        models: await countModelCatalog().catch(() => 0),
+        added: [],
+        checkedAt: meta?.lastCheckedAt ?? null,
+        retryAfterMs: waitMs
+      };
+    }
+    lastForcedRefreshAt = now;
+  }
+  return refreshModelCatalog({ ...opts, now });
+}
+async function runModelCatalogRefresh(opts = {}) {
+  const now = opts.now ?? Date.now();
+  try {
+    const meta = await getModelCatalogMeta();
+    const count = await countModelCatalog();
+    if (!opts.force && count > 0 && meta.lastCheckedAt !== null && now - meta.lastCheckedAt < MODEL_CATALOG_FRESH_MS) {
+      await reloadModelsCatalog();
+      return { status: "skipped-fresh", models: count, added: [], checkedAt: meta.lastCheckedAt };
+    }
+    const result = await refreshPricingFromModelsDev({ fetchImpl: opts.fetchImpl, now });
+    return {
+      status: result.status === "refreshed" ? "updated" : "not-modified",
+      models: result.catalogModels ?? await countModelCatalog(),
+      added: result.added ?? [],
+      checkedAt: now
+    };
+  } catch (err) {
+    logPricingRefreshError("model catalog refresh failed", err);
+    await auditPricingRefreshFailure(err);
+    const meta = await getModelCatalogMeta().catch(() => null);
+    return {
+      status: "error",
+      models: await countModelCatalog().catch(() => 0),
+      added: [],
+      checkedAt: meta?.lastCheckedAt ?? null,
+      error: scrubSecrets(err instanceof Error ? err.message : String(err))
+    };
+  }
+}
+async function runPricingRefreshSafely() {
+  await refreshModelCatalog();
+}
+function startPricingRefreshLoop() {
+  if (refreshLoopStarted)
+    return;
+  refreshLoopStarted = true;
+  runPricingRefreshSafely();
+  const interval = setInterval(() => {
+    runPricingRefreshSafely();
+  }, PRICING_REFRESH_INTERVAL_MS);
+  interval.unref?.();
+}
+
+export { buildCatalogEntries, listModelCatalog, listModelCatalogOverlay, upsertModelCatalogOverlay, deleteModelCatalogOverlay, getCatalogGeneration, loadModelsCatalog, PRICING_REFRESH_INTERVAL_MS, MODEL_CATALOG_FRESH_MS, refreshPricingFromModelsDev, MODEL_CATALOG_FORCE_COOLDOWN_MS, resetModelCatalogRefreshGuardForTests, refreshModelCatalog, requestModelCatalogRefresh, startPricingRefreshLoop };