@jeffusion/bungee-core 5.9.0 → 5.11.0

package/dist/plugins/token-stats/index.js

@@ -14823,7 +14823,98 @@ function definePlugin(plugin) {
   return plugin;
 }
 
+// packages/core/src/plugin-services/host-rpc.ts
+import { AsyncLocalStorage } from "async_hooks";
+
+// packages/core/src/plugin-services/wire-contract.ts
+var RPC_JSON_MAX_BYTES = 64 * 1024;
+var RPC_CONTRACT_MAX_BYTES = 256 * 1024;
+var RPC_CALL_PURPOSES = new Set(["bootstrap", "background", "management", "request", "attempt"]);
+var RPC_COMMAND_DEDUPLICATION = new Set(["local-transaction", "external-contract", "none"]);
+var RPC_COMMAND_POLICY_KEYS = new Set(["deduplication", "resultRetentionMs", "quotaBytes", "maxResultBytes"]);
+
+// packages/core/src/plugin-services/rpc-runtime.ts
+var PROCESSES = new Set(["control", "worker", "ingress"]);
+var SCOPES = new Set(["global", "binding"]);
+var PURPOSES = new Set(["bootstrap", "background", "management", "request", "attempt"]);
+var ENDPOINTS = new WeakMap;
+var REVOKED = new WeakMap;
+
+// packages/core/src/plugin-services/host-rpc.ts
+var SERVICE_ERROR_MESSAGES = {
+  unauthorized: "RPC call is not authorized",
+  not_ready: "RPC endpoint is not ready",
+  retired: "RPC endpoint is retiring",
+  revoked: "RPC endpoint generation was revoked",
+  unsupported_method: "RPC method is not published",
+  wrong_purpose: "RPC method is not published for this purpose",
+  invalid_input: "RPC input is not valid",
+  invalid_output: "RPC output is not valid",
+  invalid_operation_id: "RPC command operation id is invalid",
+  overloaded: "RPC runtime is at capacity",
+  cancelled: "RPC call was cancelled",
+  timeout: "RPC call deadline exceeded",
+  unknown: "RPC command outcome is unknown",
+  capability_unavailable: "RPC command execution is unavailable",
+  closed: "RPC runtime is closed",
+  failed: "RPC call failed",
+  conflict: "RPC command identity conflicts with an existing record",
+  expired: "RPC command result has expired",
+  pending: "RPC command is still pending",
+  rejected: "RPC command was rejected",
+  missing: "RPC command has no stored result",
+  storage_failure: "RPC command storage failed",
+  deadlock: "RPC call chain would deadlock",
+  call_depth_exceeded: "RPC call depth exceeded",
+  undeclared: "RPC service is not declared by the manifest",
+  unavailable: "RPC service is unavailable",
+  ambiguous_placement: "RPC service placement is ambiguous",
+  invalid_registration: "RPC registration is invalid"
+};
+var SERVICE_ERROR_CODES = new Set(Object.keys(SERVICE_ERROR_MESSAGES));
+var EMPTY_OPTIONS = Object.freeze({});
+var FRAME_STORE = new AsyncLocalStorage;
+var CALLEE_INFO = new WeakMap;
+// packages/core/src/plugin-services/peer-channel-protocol.ts
+var CHANNEL_REQUEST_MAX_BYTES = 4 * 1024;
+var CHANNEL_RESULT_MAX_BYTES = 60 * 1024;
+var CHANNEL_MAX_CHUNK_BYTES = 60 * 1024;
+var PLUGIN_CHANNEL_LANES = Object.freeze(["event", "snapshot", "stream"]);
+var ERROR_CODES = new Set([
+  "unavailable",
+  "ambiguous",
+  "unauthorized",
+  "invalid",
+  "overloaded",
+  "expired",
+  "conflict",
+  "gap",
+  "truncated",
+  "rejected",
+  "cancelled",
+  "closed",
+  "unknown",
+  "failed"
+]);
+var RPC_CALL_PURPOSES2 = new Set(["bootstrap", "background", "management", "request", "attempt"]);
+
+// packages/core/src/plugin-services/peer-channel-hub.ts
+var CHANNEL_MAX_TRANSFER_BUFFER_BYTES = 4 * CHANNEL_MAX_CHUNK_BYTES;
+var CHANNEL_MAX_TOTAL_BUFFER_BYTES = 16 * CHANNEL_MAX_CHUNK_BYTES;
+var CHANNEL_STREAM_MAX_TOTAL_BYTES = 64 * 1024 * 1024;
+var CHANNEL_STREAM_MAX_CREDIT_BYTES = 8 * CHANNEL_MAX_CHUNK_BYTES;
+var CHANNEL_STREAM_DEFAULT_CREDIT_BYTES = 4 * CHANNEL_MAX_CHUNK_BYTES;
+var CHANNEL_SNAPSHOT_MAX_BYTES = 64 * 1024 * 1024;
+var CHANNEL_EVENT_MAX_PAYLOAD_BYTES = 60 * 1024;
+var EMPTY = new Uint8Array(0);
+var HANDLE_REGISTRATIONS = new WeakMap;
+
+// packages/core/src/plugin-services/snapshot-store.ts
+var DEFAULT_CHUNK_BYTES = 60 * 1024;
+var SNAPSHOT_FAMILY_REFS = new Map;
+
 // packages/core/src/plugin-services.ts
+var CHANNEL_KINDS = new Set(["events", "snapshot", "stream"]);
 var TOKEN_METERING_SERVICE_ID = "token-metering.v1";
 var TOKEN_METERING_CONTRACT_VERSION = 1;
 var TOKEN_PRICING_SERVICE_ID = "token-stats.pricing.v1";
@@ -15089,6 +15180,38 @@ function withReportingWriteTimeout(db, operation) {
   }
 }
 
+// plugins/token-stats/server/model-mappings.ts
+var PRICE_MODEL_MAPPINGS_KEY = "pricing:model-mappings:v1";
+var MAX_PRICE_MODEL_MAPPINGS = 100;
+async function readPriceModelMappings(storage) {
+  if (!storage.observation)
+    return parsePriceModelMappings(await storage.get(PRICE_MODEL_MAPPINGS_KEY) ?? []);
+  return storage.observation.withDatabase((db) => {
+    const row = db.query("SELECT value, ttl FROM plugin_storage WHERE plugin_name = ? AND key = ?").get("token-stats", PRICE_MODEL_MAPPINGS_KEY);
+    if (!row || row.ttl !== null && row.ttl < Math.floor(Date.now() / 1000))
+      return [];
+    return parsePriceModelMappings(JSON.parse(row.value));
+  });
+}
+function parsePriceModelMappings(value) {
+  if (!Array.isArray(value) || value.length > MAX_PRICE_MODEL_MAPPINGS)
+    throw new Error("invalid_input");
+  const sources = new Set;
+  return value.map((item) => {
+    if (!item || typeof item !== "object" || Array.isArray(item) || Object.keys(item).some((key) => !["source", "provider", "model"].includes(key)))
+      throw new Error("invalid_input");
+    const { source, provider, model } = item;
+    for (const [text, limit] of [[source, 256], [provider, 128], [model, 256]]) {
+      if (typeof text !== "string" || !text.trim() || text !== text.trim() || text.length > limit || /[\u0000-\u001f\u007f]/.test(text))
+        throw new Error("invalid_input");
+    }
+    if (sources.has(source))
+      throw new Error("invalid_input");
+    sources.add(source);
+    return { source, provider, model };
+  });
+}
+
 // plugins/token-stats/server/repository.ts
 var TOKEN_ACCOUNTING_AUTHORITIES = ["official", "local", "heuristic", "partial", "none"];
 
@@ -15098,6 +15221,9 @@ class TokenStatsRepositoryError extends Error {
     this.name = "TokenStatsRepositoryError";
   }
 }
+var MAX_CLIENT_MODEL_PAGE_SIZE = 100;
+var MAX_CLIENT_MODEL_PAGE = 400;
+var CLIENT_MODEL_KEYWORD_MAX = 256;
 var REPORTING_INCOMPLETE_KEY = "reporting:incomplete";
 var MAX_PENDING_ATTEMPTS = 256;
 var LOG_INTERVAL_MS = 60000;
@@ -15237,504 +15363,130 @@ class TokenStatsRepository {
       })).sort(groupBy === "model" ? (a, b) => b.inputTokens + b.outputTokens - a.inputTokens - a.outputTokens || b.upstreamAttempts - a.upstreamAttempts || a.dimension.localeCompare(b.dimension) : (a, b) => a.bucketStartMs - b.bucketStartMs || a.dimension.localeCompare(b.dimension))
     };
   }
-}
-
-// node_modules/@tokenlens/fetch/dist/index.js
-class FetchModelsError extends Error {
-  code;
-  status;
-  constructor(opts) {
-    super(opts.message);
-    this.name = "FetchModelsError";
-    this.code = opts.code;
-    this.status = opts.status;
-  }
-}
-async function fetchModels(opts = {}) {
-  if (typeof opts === "string") {
-    return fetchModels({ provider: opts });
-  }
-  const url = opts.baseUrl ?? "https://models.dev/api.json";
-  const fetchImpl = opts.fetch ?? globalThis.fetch;
-  if (typeof fetchImpl !== "function") {
-    throw new FetchModelsError({
-      code: "UNAVAILABLE",
-      message: "No fetch implementation found. Pass a custom `fetch` in options or run on a platform with global fetch (Node 18+, modern browsers)."
+  async listClientModels(input = {}) {
+    const pageSize = Math.max(1, Math.min(MAX_CLIENT_MODEL_PAGE_SIZE, Math.trunc(input.pageSize ?? 50)));
+    const page = Math.max(1, Math.trunc(input.page ?? 1));
+    if (!Number.isSafeInteger(page) || page > MAX_CLIENT_MODEL_PAGE)
+      throw new TokenStatsRepositoryError("invalid token-stats page");
+    const keyword = input.keyword;
+    if (keyword !== undefined && (typeof keyword !== "string" || keyword.length > CLIENT_MODEL_KEYWORD_MAX)) {
+      throw new TokenStatsRepositoryError("invalid token-stats keyword");
+    }
+    const observation = this.storage.observation;
+    if (observation === undefined)
+      throw new TokenStatsRepositoryError("token-stats observation storage is required");
+    const since = Date.now() - TOKEN_STATS_RETENTION_MS;
+    const hasKeyword = keyword !== undefined && keyword.length > 0;
+    const escaped = hasKeyword ? keyword.replace(/[\\%_]/g, (character) => `\\${character}`) : null;
+    return observation.withDatabase((db) => {
+      const countSql = hasKeyword ? "SELECT COUNT(DISTINCT model) AS total FROM token_stats_attempts WHERE finished_at_ms >= ? AND model LIKE ? ESCAPE '\\'" : "SELECT COUNT(DISTINCT model) AS total FROM token_stats_attempts WHERE finished_at_ms >= ?";
+      const totalRow = db.query(countSql).get(...hasKeyword ? [since, `%${escaped}%`] : [since]);
+      const total = Number(totalRow?.total ?? 0);
+      const pageSql = hasKeyword ? "SELECT DISTINCT model FROM token_stats_attempts WHERE finished_at_ms >= ? AND model LIKE ? ESCAPE '\\' ORDER BY model ASC LIMIT ? OFFSET ?" : "SELECT DISTINCT model FROM token_stats_attempts WHERE finished_at_ms >= ? ORDER BY model ASC LIMIT ? OFFSET ?";
+      const rows = db.query(pageSql).all(...hasKeyword ? [since, `%${escaped}%`, pageSize, (page - 1) * pageSize] : [since, pageSize, (page - 1) * pageSize]);
+      return {
+        models: rows.map((row) => String(row.model)),
+        total: Number.isSafeInteger(total) && total >= 0 ? total : 0,
+        page,
+        pageSize
+      };
     });
   }
-  let res;
-  try {
-    res = await fetchImpl(url, opts.signal ? { signal: opts.signal } : undefined);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "Unknown network error";
-    throw new FetchModelsError({ code: "NETWORK", message });
+  async mappings() {
+    return readPriceModelMappings(this.storage);
   }
-  if (!res.ok) {
-    let body = "";
-    try {
-      body = await res.text();
-    } catch {}
-    const snippet = body ? ` Body: ${body.slice(0, 256)}${body.length > 256 ? "\u2026" : ""}` : "";
-    throw new FetchModelsError({
-      code: "HTTP",
-      status: res.status,
-      message: `Failed to fetch models.dev API (${res.status} ${res.statusText}).${snippet}`
-    });
+  async configureMappings(mappings) {
+    await this.storage.set(PRICE_MODEL_MAPPINGS_KEY, mappings);
   }
-  let data;
-  try {
-    data = await res.json();
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "Invalid JSON";
-    throw new FetchModelsError({ code: "PARSE", message });
-  }
-  const catalog = data;
-  const { provider, model } = opts;
-  if (!provider && !model)
-    return catalog;
-  if (provider && !model)
-    return catalog[provider];
-  if (provider && model)
-    return catalog[provider]?.models?.[model];
-  const matches = [];
-  if (!model)
-    return matches;
-  for (const [provKey, prov] of Object.entries(catalog)) {
-    const m = prov?.models?.[model];
-    if (m)
-      matches.push({ provider: provKey, model: m });
-  }
-  return matches;
-}
-
-// node_modules/@tokenlens/helpers/dist/context.js
-var TOKENS_PER_MILLION = 1e6;
-function normalizeUsage(usage) {
-  if (!usage)
-    return { input: 0, output: 0, total: 0 };
-  if (typeof usage.input === "number" && typeof usage.output === "number") {
-    const u = usage;
-    return {
-      input: u.input,
-      output: u.output,
-      total: u.total ?? u.input + u.output
-    };
-  }
-  const ul = usage;
-  const inputCandidates = [
-    ul.input_tokens,
-    ul.prompt_tokens,
-    ul.promptTokens,
-    ul.inputTokens
-  ].filter((v) => typeof v === "number");
-  const outputCandidates = [
-    ul.output_tokens,
-    ul.completion_tokens,
-    ul.completionTokens,
-    ul.outputTokens
-  ].filter((v) => typeof v === "number");
-  const totalCandidates = [
-    ul.total_tokens,
-    ul.totalTokens,
-    ul.totalTokens
-  ].filter((v) => typeof v === "number");
-  const input = inputCandidates[0] ?? 0;
-  const output = outputCandidates[0] ?? 0;
-  const total = totalCandidates[0];
-  if (total !== undefined)
-    return { input, output, total };
-  return { input, output, total: input + output };
-}
-function breakdownTokens(usage) {
-  if (!usage)
-    return {
-      input: 0,
-      output: 0,
-      total: 0,
-      cacheReads: 0,
-      cacheWrites: 0,
-      reasoningTokens: 0
-    };
-  if (typeof usage.input === "number" && typeof usage.output === "number" && (("cacheReads" in usage) || ("cacheWrites" in usage) || ("total" in usage))) {
-    const u0 = usage;
-    return {
-      input: u0.input,
-      output: u0.output,
-      total: u0.total ?? u0.input + u0.output,
-      cacheReads: u0.cacheReads,
-      cacheWrites: u0.cacheWrites,
-      reasoningTokens: u0.reasoningTokens
-    };
-  }
-  const base = normalizeUsage(usage);
-  const u = usage;
-  const cacheReadCandidates = [
-    u.cache_read_input_tokens,
-    u.cache_read_tokens,
-    u.prompt_cache_hit_tokens,
-    u.prompt_tokens_details?.cached_tokens,
-    u.promptTokensDetails?.cachedTokens,
-    u.cachedInputTokens,
-    u.cacheReads
-  ].filter((v) => typeof v === "number");
-  const cacheWriteCandidates = [
-    u.cache_creation_input_tokens,
-    u.cache_creation_tokens,
-    u.prompt_cache_write_tokens,
-    u.promptTokensDetails?.cacheCreationTokens,
-    u.cacheWrites
-  ].filter((v) => typeof v === "number");
-  const cacheReads = cacheReadCandidates[0];
-  const cacheWrites = cacheWriteCandidates[0];
-  const reasoningCandidates = [u.reasoning_tokens, u.reasoningTokens].filter((v) => typeof v === "number");
-  const reasoningTokens = reasoningCandidates[0];
-  return { ...base, cacheReads, cacheWrites, reasoningTokens };
-}
-function estimateCost({ modelId, usage, catalog }) {
-  const model = resolveModelFromCatalog(modelId, catalog);
-  if (!model?.pricing)
-    return {};
-  const base = normalizeUsage(usage);
-  const breakdown = breakdownTokens(usage);
-  const inputUSD = model.pricing.inputPerMTokens !== undefined ? base.input / TOKENS_PER_MILLION * model.pricing.inputPerMTokens : undefined;
-  const outputUSD = model.pricing.outputPerMTokens !== undefined ? base.output / TOKENS_PER_MILLION * model.pricing.outputPerMTokens : undefined;
-  const reasoningUSD = model.pricing.reasoningPerMTokens !== undefined && typeof breakdown.reasoningTokens === "number" ? breakdown.reasoningTokens / TOKENS_PER_MILLION * model.pricing.reasoningPerMTokens : undefined;
-  const cacheReadUSD = model.pricing.cacheReadPerMTokens !== undefined && typeof breakdown.cacheReads === "number" ? breakdown.cacheReads / TOKENS_PER_MILLION * model.pricing.cacheReadPerMTokens : undefined;
-  const cacheWriteUSD = model.pricing.cacheWritePerMTokens !== undefined && typeof breakdown.cacheWrites === "number" ? breakdown.cacheWrites / TOKENS_PER_MILLION * model.pricing.cacheWritePerMTokens : undefined;
-  const totalParts = [
-    inputUSD,
-    outputUSD,
-    reasoningUSD,
-    cacheReadUSD,
-    cacheWriteUSD
-  ].filter((v) => typeof v === "number");
-  const totalUSD = totalParts.length ? totalParts.reduce((a, b) => a + b, 0) : undefined;
-  return {
-    inputUSD,
-    outputUSD,
-    reasoningUSD,
-    cacheReadUSD,
-    cacheWriteUSD,
-    totalUSD
-  };
-}
-function resolveModelFromCatalog(idOrAlias, providers) {
-  if (!providers)
-    return;
-  const base = idOrAlias.trim().toLowerCase();
-  const candidates = [base];
-  if (base.includes("/")) {
-    const i = base.indexOf("/");
-    const p = base.slice(0, i);
-    const rest = base.slice(i + 1);
-    candidates.push(`${p}:${rest}`);
-    candidates.push(`${p}:${rest.replace(/(\d)\.(\d)/g, "$1-$2")}`);
-  }
-  if (base.includes(":")) {
-    const i = base.indexOf(":");
-    const p = base.slice(0, i);
-    const rest = base.slice(i + 1);
-    candidates.push(`${p}:${rest.replace(/(\d)\.(\d)/g, "$1-$2")}`);
-  }
-  if (!base.includes(":") && !base.includes("/")) {
-    candidates.push(base.replace(/(\d)\.(\d)/g, "$1-$2"));
-  }
-  for (const key of candidates) {
-    const idx = key.indexOf(":");
-    if (idx > 0) {
-      const providerKey = key.slice(0, idx);
-      const mid = key.slice(idx + 1);
-      for (const [provKey, prov] of iterateProviders(providers)) {
-        if (mid) {
-          const m = prov?.models?.[mid];
-          if (m && (provKey === providerKey || providerKey.length > 0))
-            return mapModelsDevEntry(provKey, mid, m, prov);
-        }
-      }
-    }
-    for (const [provKey, prov] of iterateProviders(providers)) {
-      const m = prov?.models?.[key];
-      if (m)
-        return mapModelsDevEntry(provKey, key, m, prov);
-    }
-  }
-  return;
-}
-function mapModelsDevEntry(provider, modelId, m, prov) {
-  const inputMods = Array.isArray(m?.modalities?.input) ? m.modalities?.input : [];
-  const outputMods = Array.isArray(m?.modalities?.output) ? m.modalities?.output : [];
-  const textIn = inputMods.includes("text");
-  const imageIn = inputMods.includes("image");
-  const textOut = outputMods.includes("text");
-  const combinedMax = typeof m?.limit?.context === "number" ? m.limit.context : undefined;
-  const inputMax = typeof m?.limit?.input === "number" ? m.limit.input : undefined;
-  const outputMax = typeof m?.limit?.output === "number" ? m.limit.output : undefined;
-  const pricing = m?.cost && (typeof m.cost.input === "number" || typeof m.cost.output === "number" || typeof m.cost.reasoning === "number" || typeof m.cost.cache_read === "number" || typeof m.cost.cache_write === "number") ? {
-    ...typeof m.cost.input === "number" ? { inputPerMTokens: m.cost.input } : {},
-    ...typeof m.cost.output === "number" ? { outputPerMTokens: m.cost.output } : {},
-    ...typeof m.cost.reasoning === "number" ? { reasoningPerMTokens: m.cost.reasoning } : {},
-    ...typeof m.cost.cache_read === "number" ? { cacheReadPerMTokens: m.cost.cache_read } : {},
-    ...typeof m.cost.cache_write === "number" ? { cacheWritePerMTokens: m.cost.cache_write } : {}
-  } : undefined;
-  return {
-    id: `${provider}:${modelId}`,
-    provider,
-    vendorId: modelId,
-    displayName: m?.name || modelId,
-    family: modelId,
-    status: "stable",
-    context: Object.fromEntries(Object.entries({ combinedMax, inputMax, outputMax }).filter(([, v]) => typeof v === "number")),
-    modalities: textIn || textOut || imageIn ? {
-      ...textIn && { textIn: true },
-      ...textOut && { textOut: true },
-      ...imageIn && { imageIn: true }
-    } : undefined,
-    pricing,
-    pricingSource: "models.dev",
-    aliases: [`${provider}/${modelId}`],
-    releasedAt: m?.release_date || undefined,
-    source: prov?.doc || prov.docs || "https://models.dev",
-    contextSource: prov?.doc || prov.docs || undefined,
-    verifiedAt: m?.last_updated || undefined
-  };
-}
-function* iterateProviders(providers) {
-  if (providers?.models) {
-    const p = providers;
-    const key = p.id || "provider";
-    yield [key, p];
-    return;
-  }
-  for (const [key, prov] of Object.entries(providers)) {
-    yield [key, prov];
-  }
-}
-
-// node_modules/@tokenlens/helpers/dist/simple.js
-function costFromUsage(args) {
-  const c = estimateCost({
-    modelId: args.id,
-    usage: args.usage,
-    catalog: args.catalog
-  });
-  return c.totalUSD;
-}
-
-// plugins/token-stats/server/price-catalog.ts
-var PRICE_CACHE_KEY = "pricing:catalog:v1";
-var PRICE_STATUS_KEY = "pricing:status:v1";
-function pricedCatalog(value) {
-  if (!value || typeof value !== "object")
-    throw new Error("invalid_catalog");
-  const input = value;
-  const output = {};
-  let count = 0;
-  for (const id of ["openai", "anthropic", "google", "xai"]) {
-    const provider = input[id];
-    if (!provider?.models || typeof provider.models !== "object")
-      continue;
-    const models = {};
-    for (const [modelId, model] of Object.entries(provider.models)) {
-      const cost = model?.cost;
-      if (!cost || typeof cost.input !== "number" || !Number.isFinite(cost.input) || cost.input < 0 || typeof cost.output !== "number" || !Number.isFinite(cost.output) || cost.output < 0)
-        continue;
-      if (++count > 1e4)
-        throw new Error("invalid_catalog");
-      Object.defineProperty(models, modelId, { value: { id: modelId, name: model.name, cost }, enumerable: true });
-    }
-    if (Object.keys(models).length)
-      output[id] = { id, name: provider.name, models };
-  }
-  if (!count)
-    throw new Error("invalid_catalog");
-  return output;
 }
 
 // plugins/token-stats/server/pricing.ts
-var DIRECT_PROVIDERS = new Set(["openai", "anthropic", "google", "xai"]);
-var DEFAULT_TIMEOUT_MS = 4000;
-var DEFAULT_REFRESH_MS = 60 * 60 * 1000;
-function isDirectProvider(value) {
-  return DIRECT_PROVIDERS.has(value);
+var TOKENS_PER_UNIT = 1e6;
+function isNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
-function isNonNegativeNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0;
-}
-function exactModel(model, providerHint, catalog) {
-  const delimiterIndex = [model.indexOf(":"), model.indexOf("/")].filter((index) => index > 0).sort((a, b) => a - b)[0];
-  const prefixedProvider = delimiterIndex === undefined ? undefined : model.slice(0, delimiterIndex);
-  const modelId = delimiterIndex === undefined ? model : model.slice(delimiterIndex + 1);
-  if (!modelId)
-    return;
-  if (prefixedProvider === undefined && providerHint === undefined) {
-    const matches = [...DIRECT_PROVIDERS].filter((provider) => catalog[provider]?.models?.[modelId]);
-    if (matches.length !== 1)
-      return;
-    const provider = matches[0];
-    return { provider, modelId, entry: catalog[provider].models[modelId] };
-  }
-  const provider = prefixedProvider ?? providerHint;
-  if (!provider || !isDirectProvider(provider) || !modelId)
-    return;
-  const entry = catalog[provider]?.models?.[modelId];
-  return entry ? { provider, modelId, entry } : undefined;
-}
-function hasTieredPricing(cost) {
-  return Object.keys(cost).some((key) => /context|tier|over_\d/i.test(key));
-}
-function calculateTokenStatsCost(catalog, input) {
-  const { model, inputTokens, outputTokens } = input;
-  if (!catalog || !model || !Number.isSafeInteger(inputTokens) || inputTokens < 0 || !Number.isSafeInteger(outputTokens) || outputTokens < 0)
-    return null;
-  const match = exactModel(model, input.provider, catalog);
-  if (!match)
-    return null;
-  const rawCost = match.entry.cost;
-  if (!rawCost || !isNonNegativeNumber(rawCost.input) || !isNonNegativeNumber(rawCost.output))
-    return null;
-  if (hasTieredPricing(rawCost) && inputTokens >= 200000)
+function costOf(match, input) {
+  const inputTokens = input.inputTokens;
+  const outputTokens = input.outputTokens;
+  if (!isNonNegativeInteger(inputTokens) || !isNonNegativeInteger(outputTokens))
     return null;
   const cacheReads = input.cacheReadTokens ?? 0;
   const cacheWrites = input.cacheWriteTokens ?? 0;
-  if (!Number.isSafeInteger(cacheReads) || cacheReads < 0 || !Number.isSafeInteger(cacheWrites) || cacheWrites < 0 || cacheReads + cacheWrites > inputTokens)
-    return null;
-  if (cacheReads > 0 && !isNonNegativeNumber(rawCost.cache_read))
+  if (!isNonNegativeInteger(cacheReads) || !isNonNegativeInteger(cacheWrites) || cacheReads + cacheWrites > inputTokens)
     return null;
-  if (cacheWrites > 0 && !isNonNegativeNumber(rawCost.cache_write))
-    return null;
-  const restrictedCatalog = {
-    [match.provider]: { ...catalog[match.provider], models: { [match.modelId]: match.entry } }
-  };
-  try {
-    const cost = costFromUsage({
-      id: `${match.provider}:${match.modelId}`,
-      catalog: restrictedCatalog,
-      usage: {
-        input: inputTokens - cacheReads - cacheWrites,
-        output: outputTokens,
-        ...cacheReads > 0 ? { cacheReads } : {},
-        ...cacheWrites > 0 ? { cacheWrites } : {}
-      }
-    });
-    return isNonNegativeNumber(cost) ? cost : null;
-  } catch {
+  let rates = match;
+  for (const tier of match.contextTiers ?? []) {
+    if (inputTokens < tier.minimumInputTokens)
+      break;
+    rates = tier;
+  }
+  const cacheRead = rates.cacheRead ?? match.cacheRead ?? rates.input;
+  const cacheWrite = rates.cacheWrite ?? match.cacheWrite ?? rates.input;
+  const baseInput = inputTokens - cacheReads - cacheWrites;
+  const total = baseInput * rates.input + outputTokens * rates.output + cacheReads * cacheRead + cacheWrites * cacheWrite;
+  const cost = total / TOKENS_PER_UNIT;
+  return Number.isFinite(cost) && cost >= 0 ? cost : null;
+}
+function calculateTokenStatsCost(catalog, input, mappings = []) {
+  if (catalog === null || typeof input.model !== "string" || input.model.length === 0)
     return null;
-  }
+  const mapping = mappings.find((item) => item.source === input.model);
+  if (mapping !== undefined) {
+    const target = catalog.resolveModel({ model: mapping.model, pricingProvider: mapping.provider });
+    return target === null ? null : costOf(target, input);
+  }
+  const match = catalog.resolveModel({
+    model: input.model,
+    mode: "estimate",
+    ...input.provider === undefined ? {} : { pricingProvider: input.provider },
+    ...input.url === undefined ? {} : { url: input.url }
+  });
+  return match === null ? null : costOf(match, input);
 }
 
 class TokenStatsPricing {
-  options;
   catalog;
-  interval;
-  inFlight;
-  controller;
-  initialLoadStarted = false;
-  initialLoadReady = Promise.resolve();
-  cacheTimestamp = null;
-  constructor(options = {}) {
-    this.options = options;
-  }
-  start() {
-    if (this.options.storage) {
-      this.initialLoadReady = this.readCache();
-      return;
-    }
-    if (this.interval !== undefined)
-      return;
-    this.refresh();
-    this.interval = setInterval(() => {
-      this.refresh();
-    }, this.options.refreshMs ?? DEFAULT_REFRESH_MS);
-  }
-  stop() {
-    if (this.interval !== undefined)
-      clearInterval(this.interval);
-    this.interval = undefined;
-    this.controller?.abort();
-  }
-  async refresh() {
-    if (this.inFlight)
-      return this.inFlight;
-    const task = this.loadCatalog();
-    this.inFlight = task;
-    if (!this.initialLoadStarted) {
-      this.initialLoadStarted = true;
-      this.initialLoadReady = this.waitForInitialLoad(task);
-    }
-    try {
-      return await task;
-    } finally {
-      if (this.inFlight === task)
-        this.inFlight = undefined;
-    }
+  mappings = [];
+  constructor(catalog) {
+    this.catalog = catalog;
   }
-  ready() {
-    if (this.options.storage)
-      return this.readCache();
-    return this.initialLoadReady;
+  setMappings(mappings) {
+    this.mappings = mappings;
   }
-  async readCache() {
-    try {
-      const status = await this.options.storage.get(PRICE_STATUS_KEY);
-      if (this.catalog && status?.lastSuccessAt === this.cacheTimestamp)
-        return;
-      const cache = await this.options.storage.get(PRICE_CACHE_KEY);
-      if (cache?.version !== 1 || !Number.isFinite(cache.fetchedAt) || cache.fetchedAt === this.cacheTimestamp)
-        return;
-      this.catalog = pricedCatalog(cache.catalog);
-      this.cacheTimestamp = cache.fetchedAt;
-    } catch {}
+  hasMappings() {
+    return this.mappings !== undefined;
   }
   estimate(input) {
-    return calculateTokenStatsCost(this.catalog, input);
-  }
-  async loadCatalog() {
-    const controller = new AbortController;
-    this.controller = controller;
-    let timeout;
-    try {
-      const fetch = fetchModels(this.options.fetch ? { fetch: this.options.fetch, signal: controller.signal } : { signal: controller.signal });
-      const timeoutFailure = new Promise((_resolve, reject) => {
-        timeout = setTimeout(() => {
-          controller.abort();
-          reject(new Error("TokenLens catalog request timed out"));
-        }, this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
-      });
-      const catalog = await Promise.race([fetch, timeoutFailure]);
-      if (!catalog || typeof catalog !== "object")
-        return false;
-      this.catalog = catalog;
-      return true;
-    } catch {
-      return false;
-    } finally {
-      if (timeout !== undefined)
-        clearTimeout(timeout);
-      if (this.controller === controller)
-        this.controller = undefined;
-    }
+    if (this.mappings === undefined)
+      return null;
+    return calculateTokenStatsCost(this.catalog, input, this.mappings);
   }
-  async waitForInitialLoad(task) {
-    let timeout;
-    try {
-      await Promise.race([
-        task.then(() => {
-          return;
-        }, () => {
-          return;
-        }),
-        new Promise((resolve) => {
-          timeout = setTimeout(resolve, this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
-        })
-      ]);
-    } finally {
-      if (timeout !== undefined)
-        clearTimeout(timeout);
-    }
+  ready() {
+    return Promise.resolve();
   }
 }
 
+// plugins/models-dev/contract.ts
+var MODELS_DEV_CATALOG_SERVICE_ID = "models-dev.catalog.v1";
+var MODELS_DEV_CATALOG_CONTRACT_VERSION = 1;
+var MODELS_DEV_CATALOG_SNAPSHOT_ID = "models-dev.catalog.snapshot.v1";
+var MODELS_DEV_CATALOG_SNAPSHOT_CONTRACT_VERSION = 1;
+var MODELS_DEV_CATALOG_SNAPSHOT_SCHEMA = Object.freeze({
+  type: "object",
+  properties: {
+    version: { type: "number", integer: true, minimum: 1 },
+    fetchedAt: { type: "number", minimum: 0 },
+    catalog: { type: "json", maxBytes: 32 * 1024 * 1024 }
+  }
+});
+var MODELS_DEV_CATALOG_SNAPSHOT_CONTRACT = Object.freeze({
+  id: MODELS_DEV_CATALOG_SNAPSHOT_ID,
+  version: MODELS_DEV_CATALOG_SNAPSHOT_CONTRACT_VERSION,
+  content: MODELS_DEV_CATALOG_SNAPSHOT_SCHEMA
+});
+
 // plugins/token-stats/server/index.ts
+var MAPPING_REFRESH_INTERVAL_MS = 1e4;
 function rowFromResult(result) {
   const inputKnown = result.outcome === "completed" || result.inputSource === "official";
   const outputKnown = result.outcome === "completed" || result.outputSource === "official";
@@ -15767,14 +15519,7 @@ class TokenStatsPricingService {
     this.pricing = pricing;
   }
   canPrice = async (input) => {
-    await this.pricing.ready().catch(() => {});
-    const cost = this.pricing.estimate({
-      model: input.model,
-      provider: input.pricingProvider,
-      inputTokens: 0,
-      outputTokens: 0
-    });
-    return cost !== null && Number.isFinite(cost) && cost >= 0;
+    return this.pricing.estimate({ model: input.model, provider: input.pricingProvider, inputTokens: 0, outputTokens: 0 }) !== null;
   };
   price = (result) => {
     const row = rowFromResult(result);
@@ -15793,7 +15538,6 @@ class TokenStatsPricingService {
     if (existing)
       return existing;
     const pending = Promise.resolve().then(async () => {
-      await this.pricing.ready().catch(() => {});
       const raw = this.pricing.estimate({
         model: result.model,
         provider: result.pricingProvider,
@@ -15812,16 +15556,48 @@ class TokenStatsPricingService {
     return pending;
   };
 }
+
+class MappingCache {
+  load;
+  mappings = undefined;
+  loadedAt = 0;
+  inFlight = false;
+  constructor(load) {
+    this.load = load;
+  }
+  current() {
+    return this.mappings;
+  }
+  async refresh(now = Date.now()) {
+    if (this.inFlight)
+      return;
+    this.inFlight = true;
+    try {
+      this.mappings = await this.load();
+      this.loadedAt = now;
+    } catch {
+      this.mappings = undefined;
+    } finally {
+      this.inFlight = false;
+    }
+  }
+  maybeRefresh(now = Date.now()) {
+    if (this.inFlight || now - this.loadedAt < MAPPING_REFRESH_INTERVAL_MS)
+      return;
+    this.refresh(now);
+  }
+}
 var TokenStatsPlugin = definePlugin(class {
   pricingFactory;
   static name = "token-stats";
-  static version = "3.2.0";
+  static version = "4.0.0";
   storage;
   logger;
   repository;
   pricing;
   reportingIncomplete = false;
   unsubscribe;
+  mappingRefresh;
   markReportingIncomplete() {
     if (this.reportingIncomplete)
       return;
@@ -15844,19 +15620,34 @@ var TokenStatsPlugin = definePlugin(class {
   constructor(_config = {}, pricingFactory) {
     this.pricingFactory = pricingFactory;
   }
+  applyMappings(mappings) {
+    if (typeof this.pricing.setMappings === "function")
+      this.pricing.setMappings(mappings);
+  }
   async init(context) {
     if (!context.services)
       throw new Error("token-stats requires token-metering service");
     const metering = context.services.consume("token-metering", TOKEN_METERING_SERVICE_ID, TOKEN_METERING_CONTRACT_VERSION);
+    let catalog = null;
+    try {
+      catalog = context.services.consume("models-dev", MODELS_DEV_CATALOG_SERVICE_ID, MODELS_DEV_CATALOG_CONTRACT_VERSION);
+    } catch {
+      catalog = null;
+    }
     this.storage = context.storage.uncached?.() ?? context.storage;
     this.logger = context.logger;
     this.repository = new TokenStatsRepository(context.storage);
-    this.pricing = this.pricingFactory?.() ?? new TokenStatsPricing({ storage: this.storage });
+    this.pricing = this.pricingFactory?.() ?? new TokenStatsPricing(catalog);
+    const mappings = new MappingCache(() => this.repository.mappings());
+    await mappings.refresh();
+    this.applyMappings(mappings.current());
     const pricingService = new TokenStatsPricingService(this.pricing);
     context.services.publish(TOKEN_PRICING_SERVICE_ID, TOKEN_PRICING_CONTRACT_VERSION, { canPrice: pricingService.canPrice, price: pricingService.price });
     this.unsubscribe = metering.subscribe({
       onResult: (result) => {
         const row = rowFromResult(result);
+        mappings.maybeRefresh();
+        this.applyMappings(mappings.current());
         const price = pricingService.price(result);
         price.catch(() => {});
         const accepted = this.repository.enqueueAttempt(async () => {
@@ -15884,18 +15675,24 @@ var TokenStatsPlugin = definePlugin(class {
         this.markReportingIncomplete();
       }
     });
+    this.mappingRefresh = setInterval(() => {
+      mappings.refresh().then(() => this.applyMappings(mappings.current()));
+    }, MAPPING_REFRESH_INTERVAL_MS);
+    if (typeof this.mappingRefresh.unref === "function")
+      this.mappingRefresh.unref();
     context.services.onDispose(() => {
       this.unsubscribe?.();
       this.unsubscribe = undefined;
     });
-    this.pricing.start();
     this.logger.info("TokenStatsPlugin initialized");
   }
   register(_hooks) {}
   async onDestroy() {
     this.unsubscribe?.();
     this.unsubscribe = undefined;
-    this.pricing?.stop();
+    if (this.mappingRefresh !== undefined)
+      clearInterval(this.mappingRefresh);
+    this.mappingRefresh = undefined;
     this.logger?.info("TokenStatsPlugin destroyed");
   }
 });
@@ -15906,4 +15703,4 @@ export {
   server_default as default
 };
 
-//# debugId=E23970FB349FF94664756E2164756E21
+//# debugId=667505D0D6B6158D64756E2164756E21