@x12i/ai-tools 1.0.4 → 2.0.0

package/dist/chunk-U2YDDUVP.js

@@ -0,0 +1,970 @@
+import {
+  LOCAL_PROVIDERS,
+  loadOpenRouterRoutingEnv,
+  normalizeProvider,
+  normalizeString,
+  shouldDefaultRouteViaOpenRouter,
+  stripModelVersionSuffix
+} from "./chunk-B3V2EHRY.js";
+import {
+  UnknownModelCostError
+} from "./chunk-2PTCWPHV.js";
+
+// src/cost/constants.ts
+var DEFAULT_OPENROUTER_MARKUP_RATE = 0.05;
+var PROFILE_TIERED_CONTEXT_THRESHOLD = 2e5;
+
+// src/cost/enrichCostResult.ts
+function toCostExtraction(provenance) {
+  return {
+    model: { field: provenance.model.field, path: provenance.model.path },
+    tokens: {
+      source: provenance.tokens.source,
+      path: provenance.tokens.path,
+      estimated: provenance.tokens.estimated
+    },
+    ...provenance.modelUsed ? {
+      modelUsed: {
+        field: provenance.modelUsed.field,
+        path: provenance.modelUsed.path
+      }
+    } : {},
+    ...provenance.provider ? {
+      provider: {
+        field: provenance.provider.field,
+        path: provenance.provider.path
+      }
+    } : {}
+  };
+}
+function enrichCostResult(result, input, extraction) {
+  const receivedModelId = input.usedModel ?? input.modelUsed ?? input.model;
+  return {
+    ...result,
+    provider: input.provider,
+    usage: { ...input.tokens },
+    ...receivedModelId ? { usedModel: receivedModelId } : {},
+    ...input.model && input.model !== receivedModelId ? { model: input.model } : {},
+    ...extraction ? { extraction } : {}
+  };
+}
+
+// src/cost/extractUsageInput.ts
+var MODEL_FIELD_PRIORITY = [
+  { key: "usedModel", score: 1e3 },
+  { key: "modelUsed", score: 990 },
+  { key: "resolvedModel", score: 980 },
+  { key: "model", score: 500 },
+  { key: "xynthesisModel", score: 120 },
+  { key: "skillModel", score: 110 }
+];
+var MODEL_PATH_BONUS = [
+  { pattern: /(^|\.)response(\.|$)/i, bonus: 40 },
+  { pattern: /(^|\.)outer\.input(\.|$)/i, bonus: 35 },
+  { pattern: /(^|\.)config(?!\.rawConfig)(\.|$)/i, bonus: 30 },
+  { pattern: /(^|\.)outer\.input\.config(\.|$)/i, bonus: 28 },
+  { pattern: /(^|\.)usage(\.|$)/i, bonus: 15 },
+  { pattern: /(^|\.)rawConfig(\.|$)/i, bonus: -40 },
+  { pattern: /workingMemory/i, bonus: -50 },
+  { pattern: /requestExample/i, bonus: -80 },
+  { pattern: /graphsStudio/i, bonus: -80 }
+];
+var PROVIDER_FIELD_PRIORITY = [
+  { key: "provider", score: 500 },
+  { key: "providerId", score: 480 }
+];
+var PROVIDER_PATH_BONUS = [
+  { pattern: /(^|\.)config(?!\.rawConfig)(\.|$)/i, bonus: 30 },
+  { pattern: /(^|\.)outer\.input(\.|$)/i, bonus: 20 },
+  { pattern: /(^|\.)rawConfig(\.|$)/i, bonus: -20 }
+];
+var PROMPT_TOKEN_KEYS = /* @__PURE__ */ new Set([
+  "prompt",
+  "prompt_tokens",
+  "promptTokens",
+  "input_tokens",
+  "inputTokens",
+  "estimatedInputTokens",
+  "input"
+]);
+var COMPLETION_TOKEN_KEYS = /* @__PURE__ */ new Set([
+  "completion",
+  "completion_tokens",
+  "completionTokens",
+  "output_tokens",
+  "outputTokens",
+  "estimatedOutputTokens",
+  "output"
+]);
+var OPTIONAL_TOKEN_KEYS = {
+  total: "total",
+  total_tokens: "total",
+  totalTokens: "total",
+  cached: "cached",
+  cached_tokens: "cached",
+  cache_read_tokens: "cached",
+  cacheReadTokens: "cached",
+  cacheWrite: "cacheWrite",
+  cache_write_tokens: "cacheWrite",
+  cacheWriteTokens: "cacheWrite",
+  reasoning: "reasoning",
+  reasoning_tokens: "reasoning",
+  reasoningTokens: "reasoning",
+  audio: "audio",
+  audio_tokens: "audio",
+  image: "image",
+  image_tokens: "image"
+};
+function isPlainObject(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function modelKeyScore(key) {
+  return MODEL_FIELD_PRIORITY.find((e) => e.key === key)?.score ?? 0;
+}
+function providerKeyScore(key) {
+  return PROVIDER_FIELD_PRIORITY.find((e) => e.key === key)?.score ?? 0;
+}
+function pathBonus(path, rules) {
+  let bonus = 0;
+  for (const { pattern, bonus: b } of rules) {
+    if (pattern.test(path)) bonus += b;
+  }
+  return bonus;
+}
+function normalizeModelValue(v) {
+  if (typeof v !== "string") return void 0;
+  const t = v.trim();
+  return t.length > 0 ? t : void 0;
+}
+function normalizeProviderValue(v) {
+  if (typeof v !== "string") return void 0;
+  const t = v.trim().toLowerCase();
+  if (!t || t === "null") return void 0;
+  return t;
+}
+function collectModelCandidates(node, path, out, depth, maxDepth) {
+  if (depth > maxDepth || node === null || node === void 0) return;
+  if (isPlainObject(node)) {
+    for (const [key, value] of Object.entries(node)) {
+      const childPath = path ? `${path}.${key}` : key;
+      const base = modelKeyScore(key);
+      if (base > 0) {
+        const model = normalizeModelValue(value);
+        if (model) {
+          out.push({
+            field: key,
+            path: childPath,
+            value: model,
+            score: base + pathBonus(childPath, MODEL_PATH_BONUS)
+          });
+        }
+      }
+      collectModelCandidates(value, childPath, out, depth + 1, maxDepth);
+    }
+    return;
+  }
+  if (Array.isArray(node)) {
+    for (let i = 0; i < node.length; i++) {
+      collectModelCandidates(node[i], `${path}[${i}]`, out, depth + 1, maxDepth);
+    }
+  }
+}
+function collectProviderCandidates(node, path, out, depth, maxDepth) {
+  if (depth > maxDepth || node === null || node === void 0) return;
+  if (isPlainObject(node)) {
+    for (const [key, value] of Object.entries(node)) {
+      const childPath = path ? `${path}.${key}` : key;
+      const base = providerKeyScore(key);
+      if (base > 0) {
+        const provider = normalizeProviderValue(value);
+        if (provider) {
+          out.push({
+            field: key,
+            path: childPath,
+            value: provider,
+            score: base + pathBonus(childPath, PROVIDER_PATH_BONUS)
+          });
+        }
+      }
+      collectProviderCandidates(value, childPath, out, depth + 1, maxDepth);
+    }
+    return;
+  }
+  if (Array.isArray(node)) {
+    for (let i = 0; i < node.length; i++) {
+      collectProviderCandidates(node[i], `${path}[${i}]`, out, depth + 1, maxDepth);
+    }
+  }
+}
+function readNumber(obj, keys) {
+  for (const [k, v] of Object.entries(obj)) {
+    if (!keys.has(k)) continue;
+    if (typeof v === "number" && Number.isFinite(v) && v >= 0) return v;
+  }
+  return void 0;
+}
+function readOptionalNumbers(obj) {
+  const extra = {};
+  for (const [k, v] of Object.entries(obj)) {
+    const target = OPTIONAL_TOKEN_KEYS[k];
+    if (!target || typeof v !== "number" || !Number.isFinite(v) || v < 0) continue;
+    extra[target] = v;
+  }
+  return extra;
+}
+function looksLikeUsageObject(obj) {
+  const hasPrompt = readNumber(obj, PROMPT_TOKEN_KEYS) !== void 0;
+  const hasCompletion = readNumber(obj, COMPLETION_TOKEN_KEYS) !== void 0;
+  return hasPrompt && hasCompletion;
+}
+function looksLikeDiagnosticsObject(obj) {
+  return typeof obj.estimatedInputTokens === "number" && typeof obj.estimatedOutputTokens === "number";
+}
+function tokensFromObject(obj, source, path, estimated, score) {
+  const prompt = readNumber(obj, PROMPT_TOKEN_KEYS);
+  const completion = readNumber(obj, COMPLETION_TOKEN_KEYS);
+  if (prompt === void 0 || completion === void 0) return null;
+  const extra = readOptionalNumbers(obj);
+  const total = typeof extra.total === "number" ? extra.total : prompt + completion;
+  return {
+    tokens: {
+      prompt,
+      completion,
+      total,
+      ...extra
+    },
+    provenance: { source, path, estimated },
+    score
+  };
+}
+function collectTokenCandidates(node, path, out, depth, maxDepth) {
+  if (depth > maxDepth || node === null || node === void 0) return;
+  if (isPlainObject(node)) {
+    if (path.endsWith("diagnostics") || looksLikeDiagnosticsObject(node)) {
+      const cand = tokensFromObject(node, "diagnostics", path, true, 200);
+      if (cand) out.push(cand);
+    } else if (path.endsWith("usage") || path.endsWith("tokens") || looksLikeUsageObject(node)) {
+      const source = path.endsWith("tokens") ? "tokens" : "usage";
+      const estimated = false;
+      const score = path.endsWith("usage") ? 500 : 450;
+      const cand = tokensFromObject(node, source, path, estimated, score);
+      if (cand) out.push(cand);
+    }
+    for (const [key, value] of Object.entries(node)) {
+      const childPath = path ? `${path}.${key}` : key;
+      if (key === "usage" || key === "tokens" || key === "diagnostics") {
+        if (isPlainObject(value)) {
+          collectTokenCandidates(value, childPath, out, depth + 1, maxDepth);
+        }
+      } else {
+        collectTokenCandidates(value, childPath, out, depth + 1, maxDepth);
+      }
+    }
+    return;
+  }
+  if (Array.isArray(node)) {
+    for (let i = 0; i < node.length; i++) {
+      collectTokenCandidates(node[i], `${path}[${i}]`, out, depth + 1, maxDepth);
+    }
+  }
+}
+function pickBestModel(candidates) {
+  if (candidates.length === 0) return null;
+  return [...candidates].sort((a, b) => b.score - a.score)[0];
+}
+function pickBestProvider(candidates) {
+  if (candidates.length === 0) return null;
+  return [...candidates].sort((a, b) => b.score - a.score)[0];
+}
+function pickBestTokens(candidates) {
+  if (candidates.length === 0) return null;
+  return [...candidates].sort((a, b) => b.score - a.score)[0];
+}
+function inferProviderFromModel(model, fallback) {
+  const slash = model.indexOf("/");
+  if (slash > 0) {
+    const prefix = model.slice(0, slash).toLowerCase();
+    if (prefix !== "openrouter") return prefix;
+  }
+  return fallback;
+}
+function extractUsageInput(record, options = {}) {
+  const defaultProvider = options.defaultProvider ?? "openrouter";
+  const maxDepth = 24;
+  const modelCandidates = [];
+  const providerCandidates = [];
+  const tokenCandidates = [];
+  collectModelCandidates(record, "", modelCandidates, 0, maxDepth);
+  collectProviderCandidates(record, "", providerCandidates, 0, maxDepth);
+  collectTokenCandidates(record, "", tokenCandidates, 0, maxDepth);
+  const bestModel = pickBestModel(modelCandidates);
+  if (!bestModel) {
+    throw new Error(
+      "[ai-tools] Could not extract a model from the record (looked for usedModel, modelUsed, model, \u2026)."
+    );
+  }
+  const runtimeFields = /* @__PURE__ */ new Set(["usedModel", "modelUsed", "resolvedModel"]);
+  const isRuntimeModel = runtimeFields.has(bestModel.field);
+  const requestModel = modelCandidates.find(
+    (c) => c.field === "model" && c.path !== bestModel.path
+  );
+  const bestProvider = pickBestProvider(providerCandidates);
+  const provider = bestProvider?.value ?? inferProviderFromModel(bestModel.value, defaultProvider);
+  const bestTokens = pickBestTokens(tokenCandidates);
+  if (!bestTokens) {
+    throw new Error(
+      "[ai-tools] Could not extract token usage from the record (usage, tokens, or metadata.diagnostics)."
+    );
+  }
+  const input = {
+    tokens: bestTokens.tokens,
+    provider,
+    ...isRuntimeModel ? { modelUsed: bestModel.value, model: requestModel?.value } : { model: bestModel.value }
+  };
+  const provenance = {
+    model: {
+      field: bestModel.field,
+      path: bestModel.path,
+      score: bestModel.score
+    },
+    tokens: bestTokens.provenance
+  };
+  if (bestProvider) {
+    provenance.provider = {
+      field: bestProvider.field,
+      path: bestProvider.path,
+      score: bestProvider.score
+    };
+  }
+  if (isRuntimeModel && requestModel) {
+    provenance.modelUsed = {
+      field: bestModel.field,
+      path: bestModel.path,
+      score: bestModel.score
+    };
+  } else if (input.modelUsed) {
+    provenance.modelUsed = provenance.model;
+  }
+  return { input, provenance };
+}
+
+// src/cost/resolveUsageModel.ts
+function resolveUsageModel(input) {
+  const value = input.usedModel ?? input.modelUsed ?? input.model;
+  if (!value?.trim()) {
+    throw new Error(
+      "[ai-tools] Cost calculation requires `usedModel`, `modelUsed`, or `model` on usage input."
+    );
+  }
+  return value.trim();
+}
+
+// src/cost/aiProfilesMatch.ts
+import { createRequire } from "module";
+import { dirname, join } from "path";
+import { AIProfilesError, resolveAIProfile } from "@x12i/ai-profiles";
+
+// src/cost/costModelResolution.ts
+function isOpenRouterProvider(provider) {
+  return normalizeProvider(provider) === "openrouter";
+}
+function isLocalProvider(provider) {
+  const p = normalizeProvider(provider) ?? normalizeString(provider ?? "");
+  return LOCAL_PROVIDERS.has(p);
+}
+function isLocalProviderResolution(resolved, inputProvider) {
+  if (!resolved?.found || resolved.record) return false;
+  if (resolved.resolvedVia.includes("local-provider-passthrough")) return true;
+  return isLocalProvider(inputProvider);
+}
+function underlyingProviderFromModel(model, providerHint) {
+  const normalized = normalizeString(model);
+  if (normalized.includes("/")) {
+    const prefix = normalized.split("/")[0];
+    if (!isOpenRouterProvider(prefix)) return prefix;
+  }
+  if (providerHint && !isOpenRouterProvider(providerHint)) {
+    return normalizeProvider(providerHint);
+  }
+  return void 0;
+}
+function providerHintForProfiles(model, provider) {
+  if (isOpenRouterProvider(provider)) {
+    return underlyingProviderFromModel(model, provider);
+  }
+  return normalizeProvider(provider);
+}
+function buildCatalogResolveAttempts(model, provider) {
+  const attempts = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (m, p) => {
+    const key = `${p ?? ""}\0${normalizeString(m)}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    attempts.push({ model: m, provider: p });
+  };
+  add(model, provider);
+  const underlying = underlyingProviderFromModel(model, provider);
+  if (provider) add(model, void 0);
+  if (underlying) add(model, underlying);
+  if (!isOpenRouterProvider(provider)) {
+    add(model, "openrouter");
+  }
+  return attempts;
+}
+async function resolveFromCatalogAttempts(catalog, attempts, options) {
+  let last = null;
+  let localPassthrough = null;
+  for (const attempt of attempts) {
+    const result = await catalog.resolveModel(attempt, options);
+    last = result;
+    if (result.found && result.record) return result;
+    if (result.found && !result.record && isLocalProviderResolution(result, attempt.provider)) {
+      localPassthrough = result;
+    }
+  }
+  return localPassthrough ?? last;
+}
+function resolveRoutedViaOpenRouter(inputProvider, resolved, modelId, routingEnv) {
+  const env = routingEnv ?? loadOpenRouterRoutingEnv();
+  if (isOpenRouterProvider(inputProvider)) return true;
+  if (resolved?.found) {
+    return resolved.routedViaOpenRouter;
+  }
+  const vendor = underlyingProviderFromModel(
+    modelId ?? (resolved?.found ? resolved.modelId : "") ?? "",
+    inputProvider
+  );
+  if (vendor && shouldDefaultRouteViaOpenRouter(vendor, env)) {
+    return true;
+  }
+  return false;
+}
+
+// src/cost/aiProfilesMatch.ts
+var require2 = createRequire(import.meta.url);
+function loadProfilesRegistry() {
+  const entry = dirname(require2.resolve("@x12i/ai-profiles"));
+  const loader = require2(join(entry, "loader/loadAIProfilesRegistry.js"));
+  return loader.loadAIProfilesRegistry({ source: "auto" });
+}
+function profileKey(value) {
+  return value.trim().toLowerCase();
+}
+function canonicalModelId(provider, modelId) {
+  const normalized = normalizeString(modelId);
+  if (normalized.includes("/")) return normalized;
+  const p = normalizeProvider(provider) ?? normalizeString(provider);
+  return `${p}/${normalized}`;
+}
+var cachedIndex = null;
+function indexRegistry(registry) {
+  const byKey = /* @__PURE__ */ new Map();
+  const add = (key, entry) => {
+    const k = profileKey(key);
+    if (!k) return;
+    const list = byKey.get(k) ?? [];
+    if (list.some(
+      (e) => e.canonicalModelId === entry.canonicalModelId && e.choice === entry.choice && e.profile === entry.profile
+    )) {
+      return;
+    }
+    list.push(entry);
+    byKey.set(k, list);
+  };
+  for (const shortcutKey of Object.keys(registry.shortcuts)) {
+    const shortcut = registry.shortcuts[shortcutKey];
+    const profile = registry.profiles[shortcut.profile];
+    if (!profile) continue;
+    const choiceKey = shortcut.choice ?? profile.defaultChoice;
+    const choice = profile.choices[choiceKey];
+    if (!choice) continue;
+    const entry = choiceEntry(choice, profile.profile, choiceKey, "shortcut");
+    add(shortcutKey, entry);
+  }
+  for (const profile of Object.values(registry.profiles)) {
+    for (const [choiceKey, choice] of Object.entries(profile.choices)) {
+      const entry = choiceEntry(choice, profile.profile, choiceKey, "model-id");
+      add(choice.modelId, entry);
+      add(canonicalModelId(choice.provider, choice.modelId), entry);
+    }
+    const defaultChoice = profile.choices[profile.defaultChoice];
+    if (defaultChoice) {
+      add(
+        profile.profile,
+        choiceEntry(defaultChoice, profile.profile, profile.defaultChoice, "profile")
+      );
+    }
+    for (const alias of profile.aliases ?? []) {
+      if (defaultChoice) {
+        add(
+          alias,
+          choiceEntry(
+            defaultChoice,
+            profile.profile,
+            profile.defaultChoice,
+            "profile-alias"
+          )
+        );
+      }
+    }
+  }
+  return byKey;
+}
+function choiceEntry(choice, profile, choiceKey, matchedVia) {
+  const canonical = canonicalModelId(choice.provider, choice.modelId);
+  return {
+    provider: normalizeProvider(choice.provider) ?? choice.provider,
+    modelId: normalizeString(choice.modelId),
+    canonicalModelId: canonical,
+    pricing: choice.pricing,
+    matchedVia,
+    profile,
+    choice: choiceKey
+  };
+}
+async function getProfileIndex() {
+  const registry = await loadProfilesRegistry();
+  const cacheKey = `${registry.version}:${registry.generatedAt ?? ""}:${registry.source}`;
+  if (cachedIndex?.cacheKey === cacheKey) {
+    return cachedIndex.byKey;
+  }
+  const byKey = indexRegistry(registry);
+  cachedIndex = { cacheKey, byKey };
+  return byKey;
+}
+function scoreCandidate(entry, model, providerHint) {
+  const normalized = normalizeString(model);
+  let score = 0;
+  if (normalized === entry.canonicalModelId) score += 100;
+  if (normalized === entry.modelId) score += 80;
+  if (providerHint && entry.provider === providerHint) score += 50;
+  if (entry.matchedVia === "model-id") score += 10;
+  if (entry.matchedVia === "shortcut") score += 5;
+  if (entry.matchedVia === "profile") score += 3;
+  if (entry.pricing) score += 2;
+  return score;
+}
+function pickBest(candidates, model, providerHint) {
+  if (candidates.length === 0) return null;
+  if (candidates.length === 1) return candidates[0];
+  let best = candidates[0];
+  let bestScore = scoreCandidate(best, model, providerHint);
+  for (let i = 1; i < candidates.length; i++) {
+    const c = candidates[i];
+    const s = scoreCandidate(c, model, providerHint);
+    if (s > bestScore) {
+      best = c;
+      bestScore = s;
+    }
+  }
+  return best;
+}
+function fromIndexed(entry) {
+  return {
+    provider: entry.provider,
+    modelId: entry.modelId,
+    canonicalModelId: entry.canonicalModelId,
+    pricing: entry.pricing,
+    matchedVia: entry.matchedVia,
+    profile: entry.profile,
+    choice: entry.choice
+  };
+}
+function lookupInIndex(index, model, provider) {
+  const providerHint = provider ? normalizeProvider(provider) : void 0;
+  const keys = [
+    profileKey(model),
+    profileKey(normalizeString(model))
+  ];
+  if (providerHint) {
+    keys.push(profileKey(canonicalModelId(providerHint, model)));
+  }
+  const pooled = [];
+  for (const key of keys) {
+    const hits = index.get(key);
+    if (hits) pooled.push(...hits);
+  }
+  const bare = normalizeString(model);
+  if (!bare.includes("/")) {
+    for (const list of index.values()) {
+      for (const entry of list) {
+        if (entry.modelId === bare) pooled.push(entry);
+      }
+    }
+  }
+  const unique = /* @__PURE__ */ new Map();
+  for (const e of pooled) {
+    unique.set(`${e.profile}:${e.choice}:${e.canonicalModelId}`, e);
+  }
+  const best = pickBest([...unique.values()], model, providerHint);
+  return best ? fromIndexed(best) : null;
+}
+async function matchModelInAiProfiles(model, provider) {
+  try {
+    const resolved = await resolveAIProfile(model);
+    return {
+      provider: normalizeProvider(resolved.provider) ?? resolved.provider,
+      modelId: normalizeString(resolved.modelId),
+      canonicalModelId: canonicalModelId(resolved.provider, resolved.modelId),
+      pricing: resolved.pricing,
+      matchedVia: resolved.shortcut ? "shortcut" : "profile",
+      profile: resolved.profile,
+      choice: resolved.choice
+    };
+  } catch (err) {
+    if (!(err instanceof AIProfilesError) || err.code !== "UNKNOWN_PROFILE") {
+      throw err;
+    }
+  }
+  const index = await getProfileIndex();
+  const hint = providerHintForProfiles(model, provider);
+  const direct = lookupInIndex(index, model, hint);
+  if (direct) return direct;
+  const stripped = stripModelVersionSuffix(model);
+  if (stripped && stripped !== normalizeString(model)) {
+    return lookupInIndex(index, stripped, providerHintForProfiles(stripped, provider));
+  }
+  return null;
+}
+
+// src/cost/profilePricing.ts
+var TOKENS_PER_UNIT = 1e6;
+function usdPerToken(perMillion) {
+  return (perMillion ?? 0) / TOKENS_PER_UNIT;
+}
+function pickInputRatePerMillion(pricing, promptTokens) {
+  if (pricing.inputBelow200k !== void 0 && pricing.inputAbove200k !== void 0) {
+    return promptTokens <= PROFILE_TIERED_CONTEXT_THRESHOLD ? pricing.inputBelow200k : pricing.inputAbove200k;
+  }
+  return pricing.input ?? pricing.inputBelow200k ?? pricing.inputAbove200k;
+}
+function pickOutputRatePerMillion(pricing, promptTokens) {
+  if (pricing.outputBelow200k !== void 0 && pricing.outputAbove200k !== void 0) {
+    return promptTokens <= PROFILE_TIERED_CONTEXT_THRESHOLD ? pricing.outputBelow200k : pricing.outputAbove200k;
+  }
+  return pricing.output ?? pricing.outputBelow200k ?? pricing.outputAbove200k;
+}
+function aiProfilesPricingToCatalogPricing(pricing, pricedAt, options = {}) {
+  const promptTokens = options.promptTokens ?? 0;
+  const promptUsdPerToken = usdPerToken(pickInputRatePerMillion(pricing, promptTokens));
+  const completionUsdPerToken = usdPerToken(
+    pickOutputRatePerMillion(pricing, promptTokens)
+  );
+  const snapshot = {
+    promptUsdPerToken,
+    completionUsdPerToken,
+    cacheReadUsdPerToken: usdPerToken(pricing.cachedInput ?? pricing.cacheHit),
+    cacheWriteUsdPerToken: usdPerToken(pricing.cacheWrite5m ?? pricing.cacheWrite1h),
+    imageUsdPerUnit: 0,
+    requestUsdPerRequest: 0,
+    pricedAt,
+    source: "manual"
+  };
+  if (options.routedViaOpenRouter) {
+    snapshot.openRouterMarkupUsdPerInputToken = promptUsdPerToken * DEFAULT_OPENROUTER_MARKUP_RATE;
+    snapshot.openRouterMarkupUsdPerOutputToken = completionUsdPerToken * DEFAULT_OPENROUTER_MARKUP_RATE;
+  }
+  return snapshot;
+}
+function computeCostFromPricing(input, pricing, routedViaOpenRouter, includeBreakdown) {
+  const { tokens } = input;
+  let promptCost = tokens.prompt * pricing.promptUsdPerToken;
+  let completionCost = tokens.completion * pricing.completionUsdPerToken;
+  const cachingCost = (tokens.cacheWrite ?? 0) * (pricing.cacheWriteUsdPerToken ?? 0) + (tokens.cached ?? 0) * (pricing.cacheReadUsdPerToken ?? 0);
+  const reasoningCost = (tokens.reasoning ?? 0) * (pricing.reasoningUsdPerToken ?? pricing.promptUsdPerToken);
+  const audioCost = (tokens.audio ?? 0) * pricing.promptUsdPerToken;
+  const imageCost = (tokens.image ?? 0) * (pricing.imageUsdPerUnit ?? 0);
+  const requestFlat = pricing.requestUsdPerRequest;
+  if (routedViaOpenRouter) {
+    promptCost += tokens.prompt * (pricing.openRouterMarkupUsdPerInputToken ?? 0);
+    completionCost += tokens.completion * (pricing.openRouterMarkupUsdPerOutputToken ?? 0);
+  }
+  const cost = promptCost + completionCost + cachingCost + reasoningCost + audioCost + imageCost + requestFlat;
+  if (!includeBreakdown) {
+    return { cost };
+  }
+  return {
+    cost,
+    breakdown: {
+      promptCostUsd: promptCost,
+      completionCostUsd: completionCost,
+      cachingCostUsd: cachingCost || void 0,
+      reasoningCostUsd: reasoningCost || void 0,
+      audioCostUsd: audioCost || void 0,
+      imageCostUsd: imageCost || void 0,
+      requestFlatCostUsd: requestFlat || void 0
+    }
+  };
+}
+
+// src/cost/CostCalculator.ts
+function emptyPricing() {
+  return {
+    promptUsdPerToken: 0,
+    completionUsdPerToken: 0,
+    imageUsdPerUnit: 0,
+    requestUsdPerRequest: 0,
+    pricedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    source: "manual"
+  };
+}
+function mergeAttempts(...groups) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const group of groups) {
+    for (const a of group) {
+      const key = `${a.provider ?? ""}\0${a.model}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push(a);
+    }
+  }
+  return out;
+}
+var CostCalculator = class {
+  constructor(catalog, options = {}) {
+    this.catalog = catalog;
+    this.aliasRegistry = options.aliasRegistry;
+    this.includeBreakdown = options.includeBreakdown ?? true;
+    this.resolverOptions = options.resolverOptions;
+    this.throwOnUnknownModel = options.throwOnUnknownModel ?? false;
+  }
+  catalog;
+  aliasRegistry;
+  includeBreakdown;
+  resolverOptions;
+  throwOnUnknownModel;
+  /**
+   * Extract model, provider, and token usage from an activity / gateway record
+   * (MongoDB export, nested `outer`, `config`, `metadata.diagnostics`, etc.)
+   * then run {@link calculate}.
+   */
+  async calculateFromRecord(record, extractOptions) {
+    const { input, provenance } = extractUsageInput(record, extractOptions);
+    const warnings = [];
+    if (provenance.tokens.estimated) {
+      warnings.push({
+        code: "ESTIMATED_TOKEN_USAGE",
+        message: `Token counts are estimates from ${provenance.tokens.path} (not billed usage).`
+      });
+    }
+    const result = await this.calculate(input);
+    const enriched = enrichCostResult(result, input, toCostExtraction(provenance));
+    if (warnings.length > 0) {
+      enriched.warnings = [...enriched.warnings ?? [], ...warnings];
+    }
+    return enriched;
+  }
+  async calculate(input) {
+    const modelInput = resolveUsageModel(input);
+    const resolverOpts = {
+      ...this.resolverOptions,
+      aliasRegistry: this.aliasRegistry ?? this.resolverOptions?.aliasRegistry
+    };
+    let resolved = await resolveFromCatalogAttempts(
+      this.catalog,
+      buildCatalogResolveAttempts(modelInput, input.provider),
+      resolverOpts
+    );
+    if (isLocalProviderResolution(resolved, input.provider)) {
+      return this.localProviderResult(modelInput, input, resolved);
+    }
+    let profileMatch = null;
+    const warnings = [];
+    if (!resolved?.found || !resolved.record) {
+      if (!isLocalProvider(input.provider)) {
+        profileMatch = await matchModelInAiProfiles(modelInput, input.provider);
+      }
+      if (profileMatch) {
+        resolved = await resolveFromCatalogAttempts(
+          this.catalog,
+          mergeAttempts(
+            buildCatalogResolveAttempts(
+              profileMatch.canonicalModelId,
+              input.provider ?? profileMatch.provider
+            ),
+            buildCatalogResolveAttempts(
+              profileMatch.canonicalModelId,
+              profileMatch.provider
+            )
+          ),
+          resolverOpts
+        );
+      }
+      if (isLocalProviderResolution(resolved, input.provider)) {
+        return this.localProviderResult(modelInput, input, resolved);
+      }
+      if ((!resolved?.found || !resolved.record) && profileMatch?.pricing) {
+        const routedViaOpenRouter2 = resolveRoutedViaOpenRouter(
+          input.provider,
+          resolved,
+          profileMatch.canonicalModelId,
+          resolverOpts?.routingEnv
+        );
+        const pricing2 = aiProfilesPricingToCatalogPricing(
+          profileMatch.pricing,
+          (/* @__PURE__ */ new Date()).toISOString(),
+          {
+            promptTokens: input.tokens.prompt,
+            routedViaOpenRouter: routedViaOpenRouter2
+          }
+        );
+        const { cost: cost2, breakdown: breakdown2 } = computeCostFromPricing(
+          input,
+          pricing2,
+          routedViaOpenRouter2,
+          this.includeBreakdown
+        );
+        warnings.push({
+          code: "AI_PROFILES_ESTIMATE",
+          message: `Catalog has no pricing for "${modelInput}"; estimated from ai-profiles (${profileMatch.matchedVia} \u2192 ${profileMatch.canonicalModelId}).`
+        });
+        if (routedViaOpenRouter2 && pricing2.openRouterMarkupUsdPerInputToken !== void 0) {
+          warnings.push({
+            code: "OPENROUTER_MARKUP_ESTIMATED",
+            message: "OpenRouter markup estimated at 5% of base token rates (catalog markup fields absent)."
+          });
+        }
+        console.warn(`[ai-tools] ${warnings.map((w) => w.message).join(" ")}`);
+        return this.finish(
+          {
+            cost: cost2,
+            breakdown: breakdown2,
+            resolvedModelId: profileMatch.canonicalModelId,
+            routedViaOpenRouter: routedViaOpenRouter2,
+            isAuthoritative: false,
+            pricingSnapshot: pricing2,
+            source: "ai-profiles",
+            warnings
+          },
+          input,
+          resolved
+        );
+      }
+    }
+    if (!resolved?.found || !resolved.record) {
+      return this.unknownModelResult(modelInput, input, resolved);
+    }
+    const { record, modelId } = resolved;
+    const routedViaOpenRouter = resolveRoutedViaOpenRouter(
+      input.provider,
+      resolved,
+      modelId,
+      resolverOpts?.routingEnv
+    );
+    const pricing = record.pricing;
+    const { cost, breakdown } = computeCostFromPricing(
+      input,
+      pricing,
+      routedViaOpenRouter,
+      this.includeBreakdown
+    );
+    return this.finish(
+      {
+        cost,
+        breakdown,
+        resolvedModelId: modelId,
+        routedViaOpenRouter,
+        isAuthoritative: true,
+        pricingSnapshot: pricing,
+        source: "catalog"
+      },
+      input,
+      resolved
+    );
+  }
+  versionSuffixWarnings(input, pricedModelId, resolved) {
+    const received = input.usedModel ?? input.modelUsed ?? input.model;
+    if (!received) return [];
+    const normalizedReceived = normalizeString(received);
+    const normalizedPriced = normalizeString(pricedModelId);
+    if (normalizedReceived === normalizedPriced) return [];
+    const stripped = stripModelVersionSuffix(received);
+    const viaResolver = resolved?.found === true && resolved.resolvedVia.some(
+      (s) => s === "version-suffix-strip" || s === "date-suffix-strip"
+    );
+    const pricedViaStrip = stripped !== null && normalizeString(stripped) === normalizedPriced;
+    if (!viaResolver && !pricedViaStrip) return [];
+    return [
+      {
+        code: "VERSION_SUFFIX_PRICING",
+        message: `Priced using catalog model "${pricedModelId}" (no exact pricing for "${received}").`
+      }
+    ];
+  }
+  finish(partial, input, resolved) {
+    const enriched = enrichCostResult(partial, input);
+    const suffixWarnings = this.versionSuffixWarnings(
+      input,
+      partial.resolvedModelId,
+      resolved
+    );
+    if (suffixWarnings.length > 0) {
+      enriched.warnings = [...enriched.warnings ?? [], ...suffixWarnings];
+    }
+    return enriched;
+  }
+  localProviderResult(modelInput, input, resolved) {
+    const warnings = [
+      {
+        code: "LOCAL_PROVIDER_NO_PRICING",
+        message: `Local provider "${input.provider}" has no catalog pricing for "${modelInput}".`
+      }
+    ];
+    console.warn(`[ai-tools] ${warnings[0].message}`);
+    return this.finish(
+      {
+        cost: 0,
+        resolvedModelId: resolved?.found ? resolved.modelId : modelInput,
+        routedViaOpenRouter: false,
+        isAuthoritative: false,
+        pricingSnapshot: emptyPricing(),
+        source: "local",
+        warnings
+      },
+      input
+    );
+  }
+  unknownModelResult(modelInput, input, resolved) {
+    if (this.throwOnUnknownModel) {
+      throw new UnknownModelCostError(modelInput, input.provider);
+    }
+    const warnings = [
+      {
+        code: "UNKNOWN_MODEL",
+        message: `Unknown model "${modelInput}" (provider: "${input.provider}") \u2014 returning zero-cost fallback.`
+      }
+    ];
+    console.warn(`[ai-tools] ${warnings[0].message}`);
+    return this.finish(
+      {
+        cost: 0,
+        resolvedModelId: modelInput,
+        routedViaOpenRouter: resolveRoutedViaOpenRouter(
+          input.provider,
+          resolved,
+          modelInput,
+          this.resolverOptions?.routingEnv
+        ),
+        isAuthoritative: false,
+        pricingSnapshot: emptyPricing(),
+        source: "estimate-fallback",
+        unknownModel: true,
+        warnings
+      },
+      input
+    );
+  }
+};
+
+export {
+  DEFAULT_OPENROUTER_MARKUP_RATE,
+  toCostExtraction,
+  enrichCostResult,
+  MODEL_FIELD_PRIORITY,
+  extractUsageInput,
+  resolveUsageModel,
+  CostCalculator
+};
+//# sourceMappingURL=chunk-U2YDDUVP.js.map