@x12i/ai-tools 1.0.4 → 2.0.1

package/dist/chunk-WOHMHXRZ.cjs

@@ -0,0 +1,951 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+var _chunkEDMCKHO6cjs = require('./chunk-EDMCKHO6.cjs');
+
+
+var _chunkPADNCGZBcjs = require('./chunk-PADNCGZB.cjs');
+
+
+var _chunkGS7T56RPcjs = require('./chunk-GS7T56RP.cjs');
+
+// 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 = _nullishCoalesce(_nullishCoalesce(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 _nullishCoalesce(_optionalChain([MODEL_FIELD_PRIORITY, 'access', _ => _.find, 'call', _2 => _2((e) => e.key === key), 'optionalAccess', _3 => _3.score]), () => ( 0));
+}
+function providerKeyScore(key) {
+  return _nullishCoalesce(_optionalChain([PROVIDER_FIELD_PRIORITY, 'access', _4 => _4.find, 'call', _5 => _5((e) => e.key === key), 'optionalAccess', _6 => _6.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 = _nullishCoalesce(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 = _nullishCoalesce(_optionalChain([bestProvider, 'optionalAccess', _7 => _7.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: _optionalChain([requestModel, 'optionalAccess', _8 => _8.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 = _nullishCoalesce(_nullishCoalesce(input.usedModel, () => ( input.modelUsed)), () => ( input.model));
+  if (!_optionalChain([value, 'optionalAccess', _9 => _9.trim, 'call', _10 => _10()])) {
+    throw new Error(
+      "[ai-tools] Cost calculation requires `usedModel`, `modelUsed`, or `model` on usage input."
+    );
+  }
+  return value.trim();
+}
+
+// src/cost/aiProfilesMatch.ts
+var _module = require('module');
+var _path = require('path');
+var _aiprofiles = require('@x12i/ai-profiles');
+
+// src/cost/costModelResolution.ts
+function isOpenRouterProvider(provider) {
+  return _chunkEDMCKHO6cjs.normalizeProvider.call(void 0, provider) === "openrouter";
+}
+function isLocalProvider(provider) {
+  const p = _nullishCoalesce(_chunkEDMCKHO6cjs.normalizeProvider.call(void 0, provider), () => ( _chunkEDMCKHO6cjs.normalizeString.call(void 0, _nullishCoalesce(provider, () => ( "")))));
+  return _chunkEDMCKHO6cjs.LOCAL_PROVIDERS.has(p);
+}
+function isLocalProviderResolution(resolved, inputProvider) {
+  if (!_optionalChain([resolved, 'optionalAccess', _11 => _11.found]) || resolved.record) return false;
+  if (resolved.resolvedVia.includes("local-provider-passthrough")) return true;
+  return isLocalProvider(inputProvider);
+}
+function underlyingProviderFromModel(model, providerHint) {
+  const normalized = _chunkEDMCKHO6cjs.normalizeString.call(void 0, model);
+  if (normalized.includes("/")) {
+    const prefix = normalized.split("/")[0];
+    if (!isOpenRouterProvider(prefix)) return prefix;
+  }
+  if (providerHint && !isOpenRouterProvider(providerHint)) {
+    return _chunkEDMCKHO6cjs.normalizeProvider.call(void 0, providerHint);
+  }
+  return void 0;
+}
+function providerHintForProfiles(model, provider) {
+  if (isOpenRouterProvider(provider)) {
+    return underlyingProviderFromModel(model, provider);
+  }
+  return _chunkEDMCKHO6cjs.normalizeProvider.call(void 0, provider);
+}
+function buildCatalogResolveAttempts(model, provider) {
+  const attempts = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (m, p) => {
+    const key = `${_nullishCoalesce(p, () => ( ""))}\0${_chunkEDMCKHO6cjs.normalizeString.call(void 0, 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 _nullishCoalesce(localPassthrough, () => ( last));
+}
+function resolveRoutedViaOpenRouter(inputProvider, resolved, modelId, routingEnv) {
+  const env = _nullishCoalesce(routingEnv, () => ( _chunkEDMCKHO6cjs.loadOpenRouterRoutingEnv.call(void 0, )));
+  if (isOpenRouterProvider(inputProvider)) return true;
+  if (_optionalChain([resolved, 'optionalAccess', _12 => _12.found])) {
+    return resolved.routedViaOpenRouter;
+  }
+  const vendor = underlyingProviderFromModel(
+    _nullishCoalesce(_nullishCoalesce(modelId, () => ( (_optionalChain([resolved, 'optionalAccess', _13 => _13.found]) ? resolved.modelId : ""))), () => ( "")),
+    inputProvider
+  );
+  if (vendor && _chunkEDMCKHO6cjs.shouldDefaultRouteViaOpenRouter.call(void 0, vendor, env)) {
+    return true;
+  }
+  return false;
+}
+
+// src/cost/aiProfilesMatch.ts
+var require2 = _module.createRequire.call(void 0, _chunkGS7T56RPcjs.importMetaUrl);
+function loadProfilesRegistry() {
+  const entry = _path.dirname.call(void 0, require2.resolve("@x12i/ai-profiles"));
+  const loader = require2(_path.join.call(void 0, entry, "loader/loadAIProfilesRegistry.js"));
+  return loader.loadAIProfilesRegistry({ source: "auto" });
+}
+function profileKey(value) {
+  return value.trim().toLowerCase();
+}
+function canonicalModelId(provider, modelId) {
+  const normalized = _chunkEDMCKHO6cjs.normalizeString.call(void 0, modelId);
+  if (normalized.includes("/")) return normalized;
+  const p = _nullishCoalesce(_chunkEDMCKHO6cjs.normalizeProvider.call(void 0, provider), () => ( _chunkEDMCKHO6cjs.normalizeString.call(void 0, 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 = _nullishCoalesce(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 profile of Object.values(registry.profiles)) {
+    for (const [choiceKey, choice] of Object.entries(profile.choices)) {
+      const entry = choiceEntry(choice, profile.profile, choiceKey);
+      add(choice.modelId, entry);
+      add(canonicalModelId(choice.provider, choice.modelId), entry);
+    }
+  }
+  return byKey;
+}
+function choiceEntry(choice, profile, choiceKey) {
+  const canonical = canonicalModelId(choice.provider, choice.modelId);
+  return {
+    provider: _nullishCoalesce(_chunkEDMCKHO6cjs.normalizeProvider.call(void 0, choice.provider), () => ( choice.provider)),
+    modelId: _chunkEDMCKHO6cjs.normalizeString.call(void 0, choice.modelId),
+    canonicalModelId: canonical,
+    pricing: choice.pricing,
+    profile,
+    choice: choiceKey
+  };
+}
+async function getProfileIndex() {
+  const registry = await loadProfilesRegistry();
+  const cacheKey = `${registry.version}:${_nullishCoalesce(registry.generatedAt, () => ( ""))}:${registry.source}`;
+  if (_optionalChain([cachedIndex, 'optionalAccess', _14 => _14.cacheKey]) === cacheKey) {
+    return cachedIndex.byKey;
+  }
+  const byKey = indexRegistry(registry);
+  cachedIndex = { cacheKey, byKey };
+  return byKey;
+}
+function scoreCandidate(entry, model, providerHint) {
+  const normalized = _chunkEDMCKHO6cjs.normalizeString.call(void 0, 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.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 resolvedToMatch(resolved) {
+  return {
+    provider: _nullishCoalesce(_chunkEDMCKHO6cjs.normalizeProvider.call(void 0, resolved.provider), () => ( resolved.provider)),
+    modelId: _chunkEDMCKHO6cjs.normalizeString.call(void 0, resolved.modelId),
+    canonicalModelId: canonicalModelId(resolved.provider, resolved.modelId),
+    pricing: resolved.pricing,
+    instructionTier: resolved.instructionTier,
+    backend: resolved.backend,
+    matchedVia: resolved.shortcut ? "shortcut" : "profile",
+    profile: resolved.profile,
+    choice: resolved.choice
+  };
+}
+async function fromIndexed(entry) {
+  const resolved = await _aiprofiles.resolveAIProfile.call(void 0, entry.profile, { choice: entry.choice });
+  return {
+    provider: _nullishCoalesce(_chunkEDMCKHO6cjs.normalizeProvider.call(void 0, resolved.provider), () => ( resolved.provider)),
+    modelId: _chunkEDMCKHO6cjs.normalizeString.call(void 0, resolved.modelId),
+    canonicalModelId: canonicalModelId(resolved.provider, resolved.modelId),
+    pricing: _nullishCoalesce(resolved.pricing, () => ( entry.pricing)),
+    instructionTier: resolved.instructionTier,
+    backend: resolved.backend,
+    matchedVia: "model-id",
+    profile: resolved.profile,
+    choice: resolved.choice
+  };
+}
+async function lookupInIndex(index, model, provider) {
+  const providerHint = provider ? _chunkEDMCKHO6cjs.normalizeProvider.call(void 0, provider) : void 0;
+  const keys = [
+    profileKey(model),
+    profileKey(_chunkEDMCKHO6cjs.normalizeString.call(void 0, 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 = _chunkEDMCKHO6cjs.normalizeString.call(void 0, 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 _aiprofiles.resolveAIProfile.call(void 0, model);
+    return resolvedToMatch(resolved);
+  } catch (err) {
+    if (!(err instanceof _aiprofiles.AIProfilesError) || err.code !== "UNKNOWN_PROFILE") {
+      throw err;
+    }
+  }
+  const index = await getProfileIndex();
+  const hint = providerHintForProfiles(model, provider);
+  const direct = await lookupInIndex(index, model, hint);
+  if (direct) return direct;
+  const stripped = _chunkEDMCKHO6cjs.stripModelVersionSuffix.call(void 0, model);
+  if (stripped && stripped !== _chunkEDMCKHO6cjs.normalizeString.call(void 0, model)) {
+    return lookupInIndex(
+      index,
+      stripped,
+      providerHintForProfiles(stripped, provider)
+    );
+  }
+  return null;
+}
+
+// src/cost/profilePricing.ts
+var TOKENS_PER_UNIT = 1e6;
+function usdPerToken(perMillion) {
+  return (_nullishCoalesce(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 _nullishCoalesce(_nullishCoalesce(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 _nullishCoalesce(_nullishCoalesce(pricing.output, () => ( pricing.outputBelow200k)), () => ( pricing.outputAbove200k));
+}
+function aiProfilesPricingToCatalogPricing(pricing, pricedAt, options = {}) {
+  const promptTokens = _nullishCoalesce(options.promptTokens, () => ( 0));
+  const promptUsdPerToken = usdPerToken(pickInputRatePerMillion(pricing, promptTokens));
+  const completionUsdPerToken = usdPerToken(
+    pickOutputRatePerMillion(pricing, promptTokens)
+  );
+  const snapshot = {
+    promptUsdPerToken,
+    completionUsdPerToken,
+    cacheReadUsdPerToken: usdPerToken(_nullishCoalesce(pricing.cachedInput, () => ( pricing.cacheHit))),
+    cacheWriteUsdPerToken: usdPerToken(_nullishCoalesce(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 = (_nullishCoalesce(tokens.cacheWrite, () => ( 0))) * (_nullishCoalesce(pricing.cacheWriteUsdPerToken, () => ( 0))) + (_nullishCoalesce(tokens.cached, () => ( 0))) * (_nullishCoalesce(pricing.cacheReadUsdPerToken, () => ( 0)));
+  const reasoningCost = (_nullishCoalesce(tokens.reasoning, () => ( 0))) * (_nullishCoalesce(pricing.reasoningUsdPerToken, () => ( pricing.promptUsdPerToken)));
+  const audioCost = (_nullishCoalesce(tokens.audio, () => ( 0))) * pricing.promptUsdPerToken;
+  const imageCost = (_nullishCoalesce(tokens.image, () => ( 0))) * (_nullishCoalesce(pricing.imageUsdPerUnit, () => ( 0)));
+  const requestFlat = pricing.requestUsdPerRequest;
+  if (routedViaOpenRouter) {
+    promptCost += tokens.prompt * (_nullishCoalesce(pricing.openRouterMarkupUsdPerInputToken, () => ( 0)));
+    completionCost += tokens.completion * (_nullishCoalesce(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 = `${_nullishCoalesce(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 = _nullishCoalesce(options.includeBreakdown, () => ( true));
+    this.resolverOptions = options.resolverOptions;
+    this.throwOnUnknownModel = _nullishCoalesce(options.throwOnUnknownModel, () => ( false));
+  }
+  
+  
+  
+  
+  
+  /**
+   * 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 = [..._nullishCoalesce(enriched.warnings, () => ( [])), ...warnings];
+    }
+    return enriched;
+  }
+  async calculate(input) {
+    const modelInput = resolveUsageModel(input);
+    const resolverOpts = {
+      ...this.resolverOptions,
+      aliasRegistry: _nullishCoalesce(this.aliasRegistry, () => ( _optionalChain([this, 'access', _15 => _15.resolverOptions, 'optionalAccess', _16 => _16.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 (!_optionalChain([resolved, 'optionalAccess', _17 => _17.found]) || !resolved.record) {
+      if (!isLocalProvider(input.provider)) {
+        profileMatch = await matchModelInAiProfiles(modelInput, input.provider);
+      }
+      if (profileMatch) {
+        resolved = await resolveFromCatalogAttempts(
+          this.catalog,
+          mergeAttempts(
+            buildCatalogResolveAttempts(
+              profileMatch.canonicalModelId,
+              _nullishCoalesce(input.provider, () => ( profileMatch.provider))
+            ),
+            buildCatalogResolveAttempts(
+              profileMatch.canonicalModelId,
+              profileMatch.provider
+            )
+          ),
+          resolverOpts
+        );
+      }
+      if (isLocalProviderResolution(resolved, input.provider)) {
+        return this.localProviderResult(modelInput, input, resolved);
+      }
+      if ((!_optionalChain([resolved, 'optionalAccess', _18 => _18.found]) || !resolved.record) && _optionalChain([profileMatch, 'optionalAccess', _19 => _19.pricing])) {
+        const routedViaOpenRouter2 = resolveRoutedViaOpenRouter(
+          input.provider,
+          resolved,
+          profileMatch.canonicalModelId,
+          _optionalChain([resolverOpts, 'optionalAccess', _20 => _20.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 (!_optionalChain([resolved, 'optionalAccess', _21 => _21.found]) || !resolved.record) {
+      return this.unknownModelResult(modelInput, input, resolved);
+    }
+    const { record, modelId } = resolved;
+    const routedViaOpenRouter = resolveRoutedViaOpenRouter(
+      input.provider,
+      resolved,
+      modelId,
+      _optionalChain([resolverOpts, 'optionalAccess', _22 => _22.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 = _nullishCoalesce(_nullishCoalesce(input.usedModel, () => ( input.modelUsed)), () => ( input.model));
+    if (!received) return [];
+    const normalizedReceived = _chunkEDMCKHO6cjs.normalizeString.call(void 0, received);
+    const normalizedPriced = _chunkEDMCKHO6cjs.normalizeString.call(void 0, pricedModelId);
+    if (normalizedReceived === normalizedPriced) return [];
+    const stripped = _chunkEDMCKHO6cjs.stripModelVersionSuffix.call(void 0, received);
+    const viaResolver = _optionalChain([resolved, 'optionalAccess', _23 => _23.found]) === true && resolved.resolvedVia.some(
+      (s) => s === "version-suffix-strip" || s === "date-suffix-strip"
+    );
+    const pricedViaStrip = stripped !== null && _chunkEDMCKHO6cjs.normalizeString.call(void 0, 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 = [..._nullishCoalesce(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: _optionalChain([resolved, 'optionalAccess', _24 => _24.found]) ? resolved.modelId : modelInput,
+        routedViaOpenRouter: false,
+        isAuthoritative: false,
+        pricingSnapshot: emptyPricing(),
+        source: "local",
+        warnings
+      },
+      input
+    );
+  }
+  unknownModelResult(modelInput, input, resolved) {
+    if (this.throwOnUnknownModel) {
+      throw new (0, _chunkPADNCGZBcjs.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,
+          _optionalChain([this, 'access', _25 => _25.resolverOptions, 'optionalAccess', _26 => _26.routingEnv])
+        ),
+        isAuthoritative: false,
+        pricingSnapshot: emptyPricing(),
+        source: "estimate-fallback",
+        unknownModel: true,
+        warnings
+      },
+      input
+    );
+  }
+};
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_OPENROUTER_MARKUP_RATE = DEFAULT_OPENROUTER_MARKUP_RATE; exports.toCostExtraction = toCostExtraction; exports.enrichCostResult = enrichCostResult; exports.MODEL_FIELD_PRIORITY = MODEL_FIELD_PRIORITY; exports.extractUsageInput = extractUsageInput; exports.resolveUsageModel = resolveUsageModel; exports.CostCalculator = CostCalculator;
+//# sourceMappingURL=chunk-WOHMHXRZ.cjs.map