@poetic-ai/poetic 1.42.0

package/dist/chunk-ASEP3M2W.js

@@ -0,0 +1,968 @@
+import {
+  resolveProviderPricingPath
+} from "./chunk-JSWMRQYG.js";
+import {
+  ModelMetadataResolver
+} from "./chunk-XT2ZQVTC.js";
+import {
+  availableCostAmount,
+  costAmountOrNull,
+  isAvailableCostAmount,
+  unavailableCostAmount
+} from "./chunk-GKN3HMN4.js";
+import {
+  parseJsonWithContext
+} from "./chunk-QVZMFDYG.js";
+import {
+  ProviderRegistry
+} from "./chunk-AT4TNPWW.js";
+
+// src/cost-tracking/universal-cost-calculator.ts
+import { readFileSync } from "fs";
+
+// src/core/providers/model-update/pricing/passthrough-resolver.ts
+var DEFAULT_CONFIG = {
+  maxDepth: 5,
+  strict: false
+};
+var DEFAULT_CURSOR_MAPPINGS = {
+  // Claude models
+  "sonnet-4.6": { provider: "claude", model: "claude-sonnet-4-6" },
+  "sonnet-4-6": { provider: "claude", model: "claude-sonnet-4-6" },
+  "claude-sonnet-4-6": { provider: "claude", model: "claude-sonnet-4-6" },
+  "sonnet-4.5": { provider: "claude", model: "claude-sonnet-4-5" },
+  "sonnet-4-5": { provider: "claude", model: "claude-sonnet-4-5" },
+  "claude-sonnet-4-5": { provider: "claude", model: "claude-sonnet-4-5" },
+  "opus-4.6": { provider: "claude", model: "claude-opus-4-6" },
+  "opus-4-6": { provider: "claude", model: "claude-opus-4-6" },
+  "claude-opus-4-6": { provider: "claude", model: "claude-opus-4-6" },
+  "haiku-4.5": { provider: "claude", model: "claude-haiku-4-5" },
+  "haiku-4-5": { provider: "claude", model: "claude-haiku-4-5" },
+  "claude-haiku-4-5": { provider: "claude", model: "claude-haiku-4-5" },
+  "claude-haiku-4-5-20251001": { provider: "claude", model: "claude-haiku-4-5" },
+  "opus-4.5": { provider: "claude", model: "claude-opus-4-5" },
+  "opus-4-5": { provider: "claude", model: "claude-opus-4-5" },
+  "claude-opus-4-5": { provider: "claude", model: "claude-opus-4-5" },
+  "claude-3.5-sonnet": { provider: "claude", model: "claude-3-5-sonnet" },
+  "claude-3-5-sonnet": { provider: "claude", model: "claude-3-5-sonnet" },
+  // OpenAI models
+  "gpt-5": { provider: "codex", model: "gpt-5" },
+  "gpt-5-mini": { provider: "codex", model: "gpt-5-mini" },
+  "gpt-4o": { provider: "codex", model: "gpt-4o" },
+  "gpt-4o-mini": { provider: "codex", model: "gpt-4o-mini" },
+  "gpt-4-turbo": { provider: "codex", model: "gpt-4-turbo" },
+  o1: { provider: "codex", model: "o1" },
+  "o1-mini": { provider: "codex", model: "o1-mini" },
+  "o1-pro": { provider: "codex", model: "o1-pro" },
+  o3: { provider: "codex", model: "o3" },
+  "o3-mini": { provider: "codex", model: "o3-mini" },
+  // Gemini models
+  "gemini-2.5-pro": { provider: "gemini", model: "gemini-2.5-pro" },
+  "gemini-2.5-flash": { provider: "gemini", model: "gemini-2.5-flash" },
+  "gemini-2.0-flash": { provider: "gemini", model: "gemini-2.0-flash" },
+  "gemini-1.5-pro": { provider: "gemini", model: "gemini-1.5-pro" },
+  "gemini-1.5-flash": { provider: "gemini", model: "gemini-1.5-flash" }
+};
+var PassthroughResolver = class {
+  config;
+  customMappings = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  /**
+   * Register custom pass-through mappings for a provider.
+   */
+  registerMappings(providerId, mappings) {
+    this.customMappings.set(providerId.toLowerCase(), mappings);
+  }
+  /**
+   * Resolve pricing for a model, following pass-through chains.
+   */
+  resolvePricing(providerId, modelId, depth = 0, visited = /* @__PURE__ */ new Set()) {
+    const key = `${providerId}:${modelId}`;
+    if (visited.has(key)) {
+      return {
+        status: "unknown",
+        modelId,
+        reason: `Cycle detected in pass-through chain: ${Array.from(visited).join(" -> ")} -> ${key}`
+      };
+    }
+    if (depth >= this.config.maxDepth) {
+      return {
+        status: "unknown",
+        modelId,
+        reason: `Max pass-through depth (${this.config.maxDepth}) exceeded`
+      };
+    }
+    visited.add(key);
+    const pricing = this.getDirectPricing(providerId, modelId);
+    if (pricing) {
+      return {
+        status: "resolved",
+        provider: providerId,
+        model: modelId,
+        pricing: pricing.pricing,
+        source: pricing.source
+      };
+    }
+    const passthrough = this.getPassthroughTarget(providerId, modelId);
+    if (passthrough) {
+      return this.resolvePricing(passthrough.provider, passthrough.model, depth + 1, visited);
+    }
+    return {
+      status: "unknown",
+      modelId,
+      reason: `No pricing found for ${providerId}:${modelId}`
+    };
+  }
+  /**
+   * Get pass-through target for a model, if configured.
+   */
+  getPassthroughTarget(providerId, modelId) {
+    const normalizedProvider = providerId.toLowerCase();
+    const normalizedModel = modelId.toLowerCase();
+    const customMap = this.customMappings.get(normalizedProvider);
+    const customTarget = customMap?.[normalizedModel];
+    if (customTarget) {
+      return customTarget;
+    }
+    try {
+      const providerConfig = ProviderRegistry.getProviderConfig(normalizedProvider);
+      const pricingConfig = providerConfig?.pricing;
+      if (pricingConfig && "_meta" in pricingConfig) {
+        const meta = pricingConfig._meta;
+        const yamlTarget = meta?.passthrough_map?.[normalizedModel];
+        if (yamlTarget) {
+          return yamlTarget;
+        }
+        const providerTarget = this.resolveMetadataPassthroughTarget(meta, normalizedModel);
+        if (providerTarget) {
+          return providerTarget;
+        }
+      }
+      if (pricingConfig && "passthrough_map" in pricingConfig) {
+        const map = pricingConfig.passthrough_map;
+        const directTarget = map[normalizedModel];
+        if (directTarget) {
+          return directTarget;
+        }
+      }
+    } catch {
+    }
+    if (normalizedProvider === "cursor") {
+      return DEFAULT_CURSOR_MAPPINGS[normalizedModel] ?? null;
+    }
+    return null;
+  }
+  resolveMetadataPassthroughTarget(meta, normalizedModel) {
+    if (!meta.passthrough_provider) {
+      return null;
+    }
+    const strippedModel = stripConfiguredRoutePrefixes(
+      normalizedModel,
+      meta.passthrough_strip_prefixes
+    );
+    return {
+      provider: meta.passthrough_provider,
+      model: strippedModel
+    };
+  }
+  /**
+   * Get direct pricing for a model from the shared metadata resolver.
+   */
+  getDirectPricing(providerId, modelId) {
+    try {
+      const resolvedPricing = ModelMetadataResolver.getPricing(providerId, modelId);
+      if (!resolvedPricing) {
+        return null;
+      }
+      const { modelPricing: pricing } = resolvedPricing;
+      const inputPerMillion = pricing.input_per_1m_tokens !== void 0 ? pricing.input_per_1m_tokens : pricing.input_per_1k_tokens !== void 0 ? pricing.input_per_1k_tokens * 1e3 : void 0;
+      const outputPerMillion = pricing.output_per_1m_tokens !== void 0 ? pricing.output_per_1m_tokens : pricing.output_per_1k_tokens !== void 0 ? pricing.output_per_1k_tokens * 1e3 : void 0;
+      if (inputPerMillion === void 0 || outputPerMillion === void 0) {
+        return null;
+      }
+      return {
+        pricing: {
+          input_per_1m_tokens: inputPerMillion.toFixed(2),
+          output_per_1m_tokens: outputPerMillion.toFixed(2),
+          cache_read_per_1m_tokens: pricing.cache_read_per_1m_tokens?.toFixed(2),
+          cache_write_per_1m_tokens: pricing.cache_write_per_1m_tokens?.toFixed(2),
+          context_window: pricing.context_window,
+          features: pricing.features,
+          notes: pricing.notes
+        },
+        source: toPricingSource(pricing._meta?.source)
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Check if a provider uses pass-through pricing.
+   */
+  isPassthroughProvider(providerId) {
+    const normalizedProvider = providerId.toLowerCase();
+    if (this.customMappings.has(normalizedProvider)) {
+      return true;
+    }
+    try {
+      const providerConfig = ProviderRegistry.getProviderConfig(normalizedProvider);
+      const pricingConfig = providerConfig?.pricing;
+      if (pricingConfig && "_meta" in pricingConfig) {
+        const meta = pricingConfig._meta;
+        return meta?.pricing_source === "passthrough";
+      }
+    } catch {
+    }
+    return normalizedProvider === "cursor";
+  }
+  /**
+   * Get all pass-through mappings for a provider.
+   */
+  getMappings(providerId) {
+    const normalizedProvider = providerId.toLowerCase();
+    const mappings = {};
+    const customMap = this.customMappings.get(normalizedProvider);
+    if (customMap) {
+      Object.assign(mappings, customMap);
+    }
+    try {
+      const providerConfig = ProviderRegistry.getProviderConfig(normalizedProvider);
+      const pricingConfig = providerConfig?.pricing;
+      if (pricingConfig && "_meta" in pricingConfig) {
+        const meta = pricingConfig._meta;
+        if (meta?.passthrough_map) {
+          Object.assign(mappings, meta.passthrough_map);
+        }
+      }
+      if (pricingConfig && "passthrough_map" in pricingConfig) {
+        const map = pricingConfig.passthrough_map;
+        Object.assign(mappings, map);
+      }
+    } catch {
+    }
+    if (normalizedProvider === "cursor") {
+      return { ...DEFAULT_CURSOR_MAPPINGS, ...mappings };
+    }
+    return mappings;
+  }
+};
+function stripConfiguredRoutePrefixes(modelId, prefixes) {
+  if (!prefixes || prefixes.length === 0) {
+    return modelId;
+  }
+  const removablePrefixes = new Set(prefixes.map((prefix) => prefix.toLowerCase().trim()));
+  const segments = modelId.split("/").filter(Boolean);
+  while (segments.length > 2 && removablePrefixes.has(segments[0]?.toLowerCase() ?? "")) {
+    segments.shift();
+  }
+  return segments.join("/") || modelId;
+}
+function toPricingSource(value) {
+  switch (value) {
+    case "openrouter":
+    case "litellm":
+    case "tokencost":
+    case "manual":
+    case "passthrough":
+      return value;
+    default:
+      return "manual";
+  }
+}
+var passthroughResolver = new PassthroughResolver();
+function resolvePassthroughPricing(providerId, modelId) {
+  return passthroughResolver.resolvePricing(providerId, modelId);
+}
+
+// src/cost-tracking/universal-cost-calculator.ts
+function resolveAvailableTotalCostUsd(breakdown) {
+  if (!isAvailableCostAmount(breakdown.totalCostAmount)) {
+    return null;
+  }
+  return costAmountOrNull(breakdown.totalCostAmount);
+}
+function isCostBreakdownUnavailable(breakdown) {
+  return breakdown.pricingStatus === "unavailable" || breakdown.totalCostAmount.status !== "available";
+}
+var TOKENS_PER_MILLION = 1e6;
+var TOKENS_PER_THOUSAND = 1e3;
+var PER_1K_TO_PER_1M = TOKENS_PER_MILLION / TOKENS_PER_THOUSAND;
+var MAX_PLAUSIBLE_PER_MILLION_PRICE = 2e3;
+function per1kToPerMillion(per1kValue, field) {
+  if (!Number.isFinite(per1kValue) || per1kValue < 0) {
+    throw new Error(
+      `Invalid per-1k cost for '${field}': expected a finite non-negative number, got ${per1kValue}.`
+    );
+  }
+  const perMillion = per1kValue * PER_1K_TO_PER_1M;
+  if (perMillion > MAX_PLAUSIBLE_PER_MILLION_PRICE) {
+    throw new Error(
+      `Cost unit mismatch for '${field}': converting ${per1kValue} as a per-1,000-token price yields ${perMillion} per 1,000,000 tokens, which exceeds the plausibility ceiling of ${MAX_PLAUSIBLE_PER_MILLION_PRICE}. This is the signature of a 1000x unit-mixing error (an already-per-1M value placed in a per-1k field). Refusing to apply a ${PER_1K_TO_PER_1M}x conversion. Fix the provider pricing config so '${field}' is genuinely per-1,000-tokens.`
+    );
+  }
+  return perMillion;
+}
+var UniversalCostCalculator = class {
+  pricingVersion = "unknown";
+  logger;
+  dynamicPricingPath;
+  dynamicModelIndex = /* @__PURE__ */ new Map();
+  dynamicToolPricingIndex = /* @__PURE__ */ new Map();
+  _dynamicPricingManifest = null;
+  yamlPricingLoaded = false;
+  yamlPricingAvailable = /* @__PURE__ */ new Set();
+  // Track which providers have YAML pricing
+  constructor(logger, pricingPath) {
+    this.logger = logger;
+    this.dynamicPricingPath = pricingPath && pricingPath.trim().length > 0 ? pricingPath : resolveProviderPricingPath();
+  }
+  normalizeModelForProvider(provider, model) {
+    if (!model) return model;
+    const normalizedProvider = (provider || "").toLowerCase().trim();
+    const trimmedModel = model.trim();
+    const resolvedModel = ModelMetadataResolver.resolveModel(normalizedProvider, trimmedModel, {
+      allowFallback: true
+    });
+    if (resolvedModel && resolvedModel.matchType !== "fuzzy") {
+      return resolvedModel.modelId;
+    }
+    return trimmedModel;
+  }
+  resolvePricingProviderId(provider) {
+    const normalized = (provider || "").toLowerCase().trim();
+    if (!normalized) return provider;
+    if (this.yamlPricingAvailable.has(normalized)) {
+      return normalized;
+    }
+    try {
+      const registry = ProviderRegistry.load();
+      for (const [providerId, config] of Object.entries(registry.providers)) {
+        if ((providerId || "").toLowerCase() === normalized) {
+          return providerId;
+        }
+        if ((config.vendor || "").toLowerCase() === normalized) {
+          return providerId;
+        }
+      }
+    } catch {
+    }
+    return provider;
+  }
+  /**
+   * Load and validate pricing configuration
+   * Version 2.0+: Loads from YAML (ProviderRegistry) and optional dynamic manifest.
+   */
+  async loadPricingData() {
+    try {
+      const registry = ProviderRegistry.load();
+      this.pricingVersion = registry.version || "unknown";
+      this.yamlPricingLoaded = true;
+      this.yamlPricingAvailable.clear();
+      const allProviderIds = ProviderRegistry.getAllProviderIds();
+      for (const providerId of allProviderIds) {
+        const pricing = ProviderRegistry.getProviderPricing(providerId);
+        if (pricing) {
+          this.yamlPricingAvailable.add(providerId);
+        }
+      }
+      this.logger.logCostEvent("yaml_pricing_loaded", {
+        source: "ProviderRegistry",
+        providers: Array.from(this.yamlPricingAvailable),
+        count: this.yamlPricingAvailable.size
+      });
+    } catch (error) {
+      this.yamlPricingLoaded = false;
+      this.logger.logCostEvent("yaml_pricing_error", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw new Error(
+        `Failed to load YAML pricing data: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    this.loadDynamicPricingManifest();
+    this.logger.logCostEvent("pricing_loaded", {
+      version: this.pricingVersion,
+      providers: this.getAvailableProviders(),
+      yamlAvailable: this.yamlPricingLoaded,
+      yamlProviders: Array.from(this.yamlPricingAvailable)
+    });
+  }
+  loadDynamicPricingManifest() {
+    try {
+      const raw = readFileSync(this.dynamicPricingPath, "utf-8");
+      const parsed = parseJsonWithContext(raw, "Dynamic pricing manifest");
+      this._dynamicPricingManifest = parsed;
+      this.rebuildDynamicPricingIndexes(parsed);
+      this.logger.logCostEvent("dynamic_pricing_loaded", {
+        path: this.dynamicPricingPath,
+        generatedAt: parsed.generatedAt,
+        providers: parsed.providers.length
+      });
+    } catch (error) {
+      const maybeErr = error;
+      if (maybeErr.code === "ENOENT") {
+        this._dynamicPricingManifest = null;
+        this.dynamicModelIndex.clear();
+        this.dynamicToolPricingIndex.clear();
+        return;
+      }
+      this._dynamicPricingManifest = null;
+      this.dynamicModelIndex.clear();
+      this.dynamicToolPricingIndex.clear();
+      this.logger.logCostEvent("dynamic_pricing_error", {
+        error: error instanceof Error ? error.message : String(error),
+        path: this.dynamicPricingPath
+      });
+    }
+  }
+  rebuildDynamicPricingIndexes(manifest) {
+    this.dynamicModelIndex.clear();
+    this.dynamicToolPricingIndex.clear();
+    for (const provider of manifest.providers) {
+      const modelMap = /* @__PURE__ */ new Map();
+      for (const model of provider.models) {
+        modelMap.set(model.modelId, model);
+      }
+      this.dynamicModelIndex.set(provider.providerId, modelMap);
+      this.dynamicToolPricingIndex.set(provider.providerId, provider.tools);
+    }
+  }
+  applyDynamicPricing(provider, model, pricing) {
+    const providerModels = this.dynamicModelIndex.get(provider);
+    if (!providerModels) {
+      return;
+    }
+    const dynamicModel = providerModels.get(model);
+    if (!dynamicModel) {
+      return;
+    }
+    if (typeof dynamicModel.promptPer1k === "number") {
+      pricing.inputTokens = per1kToPerMillion(dynamicModel.promptPer1k, "promptPer1k");
+    }
+    if (typeof dynamicModel.completionPer1k === "number") {
+      pricing.outputTokens = per1kToPerMillion(dynamicModel.completionPer1k, "completionPer1k");
+    }
+    if (typeof dynamicModel.cacheReadPer1k === "number") {
+      pricing.cacheRead = per1kToPerMillion(dynamicModel.cacheReadPer1k, "cacheReadPer1k");
+    }
+    if (typeof dynamicModel.cacheWritePer1k === "number") {
+      pricing.cacheWrite = per1kToPerMillion(dynamicModel.cacheWritePer1k, "cacheWritePer1k");
+    }
+    if (dynamicModel.currency) {
+      pricing.currency = dynamicModel.currency;
+    }
+    if (dynamicModel.unit) {
+      pricing.unit = dynamicModel.unit;
+    }
+    if (dynamicModel.billingMode) {
+      pricing.billingMode = dynamicModel.billingMode;
+    }
+    pricing.features = { ...pricing.features, ...dynamicModel.features };
+    pricing.billingSource = dynamicModel.billingSource ?? pricing.billingSource;
+    pricing.pricingSource = dynamicModel.pricingSource ?? "dynamic";
+    pricing.pricingConfidence = dynamicModel.pricingConfidence ?? "medium";
+    pricing.pricingProvider = provider;
+    pricing.pricingModel = model;
+  }
+  getModelPricingWithFallback(provider, model) {
+    try {
+      return this.getModelPricing(provider, model);
+    } catch (error) {
+      const providerModels = this.dynamicModelIndex.get(provider);
+      const dynamicModel = providerModels?.get(model);
+      if (dynamicModel) {
+        return {
+          inputTokens: per1kToPerMillion(dynamicModel.promptPer1k ?? 0, "promptPer1k"),
+          outputTokens: per1kToPerMillion(dynamicModel.completionPer1k ?? 0, "completionPer1k"),
+          cacheRead: typeof dynamicModel.cacheReadPer1k === "number" ? per1kToPerMillion(dynamicModel.cacheReadPer1k, "cacheReadPer1k") : void 0,
+          cacheWrite: typeof dynamicModel.cacheWritePer1k === "number" ? per1kToPerMillion(dynamicModel.cacheWritePer1k, "cacheWritePer1k") : void 0,
+          currency: dynamicModel.currency ?? "USD",
+          unit: dynamicModel.unit ?? "per_1M_tokens",
+          contextWindow: void 0,
+          features: dynamicModel.features ?? {},
+          billingMode: dynamicModel.billingMode ?? "metered",
+          billingSource: dynamicModel.billingSource,
+          pricingSource: dynamicModel.pricingSource ?? "dynamic",
+          pricingConfidence: dynamicModel.pricingConfidence ?? "medium",
+          pricingProvider: provider,
+          pricingModel: model
+        };
+      }
+      const passthrough = this.getPassthroughModelPricing(provider, model);
+      if (passthrough) {
+        return passthrough;
+      }
+      this.logger.logCostEvent("model_pricing_unavailable", {
+        provider,
+        model,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  }
+  getPassthroughModelPricing(provider, model) {
+    const resolved = resolvePassthroughPricing(provider, model);
+    if (resolved.status !== "resolved") {
+      this.logger.logCostEvent("passthrough_pricing_unavailable", {
+        provider,
+        model,
+        reason: resolved.reason
+      });
+      return null;
+    }
+    return {
+      inputTokens: Number(resolved.pricing.input_per_1m_tokens),
+      outputTokens: Number(resolved.pricing.output_per_1m_tokens),
+      cacheRead: resolved.pricing.cache_read_per_1m_tokens !== void 0 ? Number(resolved.pricing.cache_read_per_1m_tokens) : void 0,
+      cacheWrite: resolved.pricing.cache_write_per_1m_tokens !== void 0 ? Number(resolved.pricing.cache_write_per_1m_tokens) : void 0,
+      currency: this.resolvePricingCurrency(resolved.provider),
+      unit: "per_1m_tokens",
+      contextWindow: resolved.pricing.context_window,
+      features: resolved.pricing.features ?? {},
+      billingMode: this.resolveCostBillingMode(resolved.provider),
+      pricingSource: `passthrough:${resolved.source}`,
+      pricingConfidence: "medium",
+      pricingNotes: resolved.pricing.notes,
+      pricingProvider: resolved.provider,
+      pricingModel: resolved.model
+    };
+  }
+  resolvePricingCurrency(provider) {
+    try {
+      return ProviderRegistry.getProviderPricing(provider)?.currency ?? "USD";
+    } catch {
+      return "USD";
+    }
+  }
+  resolveCostBillingMode(provider) {
+    try {
+      const billingMode = ProviderRegistry.getProviderPricing(provider)?.billing_mode;
+      return billingMode === "metered" ? "metered" : "flat_rate";
+    } catch {
+      return "metered";
+    }
+  }
+  unavailableCostBreakdown(provider, model, usage, pricingError, originalModelId) {
+    return {
+      provider,
+      model,
+      originalModelId: originalModelId ?? model,
+      canonicalModelId: model,
+      // Component fields stay numeric zeros for structural shape only; they are
+      // not a claim that cost is known-zero. Read totalCostAmount for truth.
+      inputCost: 0,
+      outputCost: 0,
+      cacheCost: 0,
+      toolCosts: 0,
+      infrastructureCost: 0,
+      totalCost: 0,
+      // deprecated compatibility only; not known zero
+      totalCostAmount: unavailableCostAmount("usd", "pricing", pricingError),
+      currency: "USD",
+      usage,
+      pricingVersion: this.pricingVersion,
+      billingMode: "metered",
+      pricingSource: "unavailable",
+      pricingConfidence: "low",
+      pricingStatus: "unavailable",
+      pricingError
+    };
+  }
+  /**
+   * Calculate cost breakdown for provider usage
+   */
+  calculateCost(provider, model, usage) {
+    if (!this.yamlPricingLoaded || this.yamlPricingAvailable.size === 0) {
+      throw new Error("Pricing data not loaded. Call loadPricingData() first.");
+    }
+    const resolvedProvider = this.resolvePricingProviderId(provider);
+    const normalizedModel = this.normalizeModelForProvider(resolvedProvider, model);
+    const tools = usage.tools ?? [];
+    const pricing = this.getModelPricingWithFallback(resolvedProvider, normalizedModel);
+    if (!pricing) {
+      return this.unavailableCostBreakdown(
+        resolvedProvider,
+        normalizedModel,
+        { ...usage, tools },
+        `Model ${normalizedModel} not found for provider ${resolvedProvider}`,
+        model
+      );
+    }
+    this.applyDynamicPricing(resolvedProvider, normalizedModel, pricing);
+    const toolPricing = this.getToolPricing(resolvedProvider, tools);
+    const infrastructurePricing = this.getInfrastructurePricing(resolvedProvider);
+    let inputCost = 0;
+    let outputCost = 0;
+    let cacheCost = 0;
+    if (pricing.billingMode === "metered") {
+      inputCost = usage.inputTokens / 1e6 * pricing.inputTokens;
+      outputCost = usage.outputTokens / 1e6 * pricing.outputTokens;
+      if (pricing.cacheRead && usage.cacheReadTokens) {
+        cacheCost += usage.cacheReadTokens / 1e6 * pricing.cacheRead;
+      }
+      if (pricing.cacheWrite && usage.cacheWriteTokens) {
+        cacheCost += usage.cacheWriteTokens / 1e6 * pricing.cacheWrite;
+      }
+    }
+    const toolCosts = this.calculateToolCosts(toolPricing, tools);
+    let infrastructureCost = 0;
+    if (usage.executionTimeMinutes && infrastructurePricing) {
+      infrastructureCost = usage.executionTimeMinutes * infrastructurePricing.costPerMinute;
+    }
+    const totalCost = inputCost + outputCost + cacheCost + toolCosts + infrastructureCost;
+    const pricingSource = pricing.pricingSource ?? "yaml";
+    return {
+      provider: resolvedProvider,
+      model: normalizedModel,
+      originalModelId: model,
+      canonicalModelId: pricing.pricingModel ?? normalizedModel,
+      inputCost,
+      outputCost,
+      cacheCost,
+      toolCosts,
+      infrastructureCost,
+      totalCost,
+      // deprecated compatibility mirror of available totalCostAmount
+      totalCostAmount: availableCostAmount(totalCost, "usd", pricingSource),
+      currency: pricing.currency,
+      usage,
+      pricingVersion: this.pricingVersion,
+      billingMode: pricing.billingMode,
+      billingSource: pricing.billingSource,
+      pricingSource,
+      pricingConfidence: pricing.pricingConfidence ?? "high",
+      pricingStatus: "ok"
+    };
+  }
+  /**
+   * Predict cost before execution
+   */
+  predictCost(provider, model, estimatedTokens) {
+    const usage = {
+      inputTokens: estimatedTokens.input,
+      outputTokens: estimatedTokens.output,
+      tools: (estimatedTokens.tools || []).map((tool) => ({
+        name: tool.name,
+        requests: tool.estimatedRequests
+      }))
+    };
+    return this.calculateCost(provider, model, usage);
+  }
+  /**
+   * Get available providers from pricing data (YAML + XML)
+   */
+  getAvailableProviders() {
+    this.ensurePricingLoadedSync();
+    const providers = new Set(this.yamlPricingAvailable);
+    if (this._dynamicPricingManifest) {
+      for (const provider of this._dynamicPricingManifest.providers) {
+        providers.add(provider.providerId);
+      }
+    }
+    return Array.from(providers);
+  }
+  /**
+   * Get available models for a provider (YAML + XML)
+   */
+  getAvailableModels(provider) {
+    this.ensurePricingLoadedSync();
+    const resolvedProvider = this.resolvePricingProviderId(provider);
+    const models = /* @__PURE__ */ new Set();
+    if (this.yamlPricingLoaded && this.yamlPricingAvailable.has(resolvedProvider)) {
+      try {
+        const providerPricing = ProviderRegistry.getProviderPricing(resolvedProvider);
+        if (providerPricing?.models) {
+          for (const modelId of Object.keys(providerPricing.models)) {
+            models.add(modelId);
+          }
+        }
+      } catch (error) {
+        this.logger.logCostEvent("yaml_models_query_error", {
+          provider,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    if (this._dynamicPricingManifest) {
+      const resolvedLower = resolvedProvider.toLowerCase();
+      const providerEntry = this._dynamicPricingManifest.providers.find(
+        (p) => p.providerId === resolvedProvider || p.providerId.toLowerCase() === resolvedLower
+      );
+      if (providerEntry) {
+        for (const model of providerEntry.models) {
+          models.add(model.modelId);
+        }
+      }
+    }
+    return Array.from(models);
+  }
+  getProviderPricingAvailability(provider) {
+    this.ensurePricingLoadedSync();
+    const resolvedProvider = this.resolvePricingProviderId(provider);
+    try {
+      const config = ProviderRegistry.getProviderConfig(resolvedProvider);
+      const pricing = ProviderRegistry.getProviderPricing(resolvedProvider);
+      const catalogModels = config.models?.available ?? [];
+      const pricingModels = pricing?.models ?? {};
+      return {
+        providerId: resolvedProvider,
+        billingMode: this.resolveCostBillingMode(resolvedProvider),
+        hasModelCatalog: catalogModels.length > 0,
+        hasTokenPricing: Object.keys(pricingModels).length > 0
+      };
+    } catch (error) {
+      this.logger.logCostEvent("provider_pricing_profile_unavailable", {
+        provider,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return {
+        providerId: resolvedProvider,
+        billingMode: "metered",
+        hasModelCatalog: false,
+        hasTokenPricing: false
+      };
+    }
+  }
+  /**
+   * Check if a feature is supported
+   */
+  isFeatureSupported(provider, model, feature) {
+    const resolvedProvider = this.resolvePricingProviderId(provider);
+    const normalizedModel = this.normalizeModelForProvider(resolvedProvider, model);
+    const pricing = this.getModelPricingWithFallback(resolvedProvider, normalizedModel);
+    if (!pricing) {
+      return false;
+    }
+    this.applyDynamicPricing(resolvedProvider, normalizedModel, pricing);
+    return pricing.features[feature] || false;
+  }
+  /**
+   * Get the dynamic pricing manifest (for debugging/introspection)
+   */
+  getDynamicPricingManifest() {
+    return this._dynamicPricingManifest;
+  }
+  /**
+   * Get model pricing from YAML (ProviderRegistry)
+   * Returns null if not available in YAML
+   */
+  getModelPricingFromYaml(provider, model) {
+    if (!this.yamlPricingLoaded || !this.yamlPricingAvailable.has(provider)) {
+      return null;
+    }
+    try {
+      const resolvedPricing = ModelMetadataResolver.getPricing(provider, model);
+      if (!resolvedPricing) {
+        return null;
+      }
+      const yamlPricing = resolvedPricing.modelPricing;
+      const providerPricing = resolvedPricing.providerPricing;
+      const inputTokens = yamlPricing.input_per_1m_tokens !== void 0 ? yamlPricing.input_per_1m_tokens : yamlPricing.input_per_1k_tokens !== void 0 ? per1kToPerMillion(yamlPricing.input_per_1k_tokens, "input_per_1k_tokens") : 0;
+      const outputTokens = yamlPricing.output_per_1m_tokens !== void 0 ? yamlPricing.output_per_1m_tokens : yamlPricing.output_per_1k_tokens !== void 0 ? per1kToPerMillion(yamlPricing.output_per_1k_tokens, "output_per_1k_tokens") : 0;
+      const cacheRead = yamlPricing.cache_read_per_1m_tokens !== void 0 ? yamlPricing.cache_read_per_1m_tokens : void 0;
+      const cacheWrite = yamlPricing.cache_write_per_1m_tokens !== void 0 ? yamlPricing.cache_write_per_1m_tokens : void 0;
+      const currency = providerPricing?.currency || "USD";
+      const unit = yamlPricing.input_per_1m_tokens !== void 0 || yamlPricing.output_per_1m_tokens !== void 0 ? "per_1m_tokens" : "per_1k_tokens";
+      return {
+        inputTokens,
+        outputTokens,
+        cacheRead,
+        cacheWrite,
+        currency,
+        unit,
+        contextWindow: yamlPricing.context_window,
+        features: yamlPricing.features || {},
+        billingMode: this.resolveCostBillingMode(resolvedPricing.resolvedModel.provider),
+        billingSource: readStringMeta(yamlPricing._meta, "billing_source"),
+        pricingSource: readStringMeta(yamlPricing._meta, "pricing_source") ?? "yaml",
+        pricingConfidence: readPricingConfidence(yamlPricing._meta) ?? "high",
+        pricingNotes: yamlPricing.notes,
+        pricingProvider: resolvedPricing.resolvedModel.provider,
+        pricingModel: resolvedPricing.resolvedModel.modelId
+      };
+    } catch (error) {
+      this.logger.logCostEvent("yaml_model_pricing_error", {
+        provider,
+        model,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  }
+  getModelPricing(provider, model) {
+    const yamlPricing = this.getModelPricingFromYaml(provider, model);
+    if (yamlPricing) {
+      this.logger.logCostEvent("pricing_source", {
+        provider,
+        model,
+        source: yamlPricing.pricingSource ?? "yaml"
+      });
+      return yamlPricing;
+    }
+    throw new Error(`Model ${model} not found for provider ${provider}`);
+  }
+  /**
+   * Get tool pricing from YAML (ProviderRegistry)
+   * Returns empty object if not available in YAML
+   */
+  getToolPricingFromYaml(provider, tools) {
+    const pricing = {};
+    if (!this.yamlPricingLoaded || !this.yamlPricingAvailable.has(provider)) {
+      return pricing;
+    }
+    try {
+      const providerPricing = ProviderRegistry.getProviderPricing(provider);
+      if (!providerPricing || !providerPricing.tools) {
+        return pricing;
+      }
+      const yamlTools = providerPricing.tools;
+      for (const tool of tools) {
+        let yamlTool = yamlTools[tool.name];
+        if (!yamlTool) {
+          const camelCaseName = tool.name.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+          yamlTool = yamlTools[camelCaseName];
+        }
+        if (yamlTool) {
+          pricing[tool.name] = {
+            costPerRequest: yamlTool.cost_per_request,
+            costPerRead: yamlTool.cost_per_read_1m_tokens,
+            costPerWrite: yamlTool.cost_per_write_1m_tokens,
+            unit: yamlTool.unit || "request",
+            notes: yamlTool.notes,
+            availableIn: yamlTool.available_in?.join(",")
+          };
+        }
+      }
+    } catch (error) {
+      this.logger.logCostEvent("yaml_tool_pricing_error", {
+        provider,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    return pricing;
+  }
+  getToolPricing(provider, tools) {
+    const yamlPricing = this.getToolPricingFromYaml(provider, tools);
+    if (Object.keys(yamlPricing).length > 0) {
+      this.logger.logCostEvent("tool_pricing_source", {
+        provider,
+        toolCount: Object.keys(yamlPricing).length,
+        source: "yaml"
+      });
+    }
+    const pricing = { ...yamlPricing };
+    const dynamicTools = this.dynamicToolPricingIndex.get(provider);
+    for (const tool of tools) {
+      if (pricing[tool.name]) {
+        continue;
+      }
+      const dynamic = dynamicTools?.[tool.name];
+      if (dynamic) {
+        pricing[tool.name] = {
+          costPerRequest: dynamic.costPerRequest,
+          costPerRead: dynamic.costPerRead,
+          costPerWrite: dynamic.costPerWrite,
+          unit: dynamic.unit ?? "request",
+          notes: dynamic.notes,
+          availableIn: void 0
+        };
+      }
+    }
+    return pricing;
+  }
+  getInfrastructurePricing(provider) {
+    if (this.yamlPricingLoaded && this.yamlPricingAvailable.has(provider)) {
+      try {
+        const providerPricing = ProviderRegistry.getProviderPricing(provider);
+        if (providerPricing?.infrastructure) {
+          const infraCost = providerPricing.infrastructure.cloud_execution_per_minute ?? providerPricing.infrastructure.premium_execution_per_minute;
+          if (infraCost !== void 0) {
+            return { costPerMinute: infraCost };
+          }
+        }
+      } catch (error) {
+        this.logger.logCostEvent("yaml_infrastructure_pricing_error", {
+          provider,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return null;
+  }
+  calculateToolCosts(toolPricing, tools) {
+    let totalCost = 0;
+    for (const tool of tools) {
+      const pricing = toolPricing[tool.name];
+      if (!pricing) continue;
+      if (pricing.costPerRequest) {
+        totalCost += tool.requests * pricing.costPerRequest;
+      }
+      if (tool.tokens) {
+        const tokenUnits = tool.tokens / 1e6;
+        const hasReadPricing = typeof pricing.costPerRead === "number";
+        const hasWritePricing = typeof pricing.costPerWrite === "number";
+        if (hasReadPricing && hasWritePricing) {
+          totalCost += tokenUnits * Math.max(pricing.costPerWrite ?? 0, pricing.costPerRead ?? 0);
+        } else if (hasReadPricing) {
+          totalCost += tokenUnits * (pricing.costPerRead ?? 0);
+        } else if (hasWritePricing) {
+          totalCost += tokenUnits * (pricing.costPerWrite ?? 0);
+        }
+      }
+    }
+    return totalCost;
+  }
+  /**
+   * Synchronously load pricing data (for test usage)
+   */
+  ensurePricingLoadedSync() {
+    if (this.yamlPricingLoaded) {
+      return;
+    }
+    try {
+      const registry = ProviderRegistry.load();
+      this.pricingVersion = registry.version || this.pricingVersion;
+      this.yamlPricingLoaded = true;
+      const allProviderIds = ProviderRegistry.getAllProviderIds();
+      for (const providerId of allProviderIds) {
+        const pricing = ProviderRegistry.getProviderPricing(providerId);
+        if (pricing) {
+          this.yamlPricingAvailable.add(providerId);
+        }
+      }
+      if (!this._dynamicPricingManifest) {
+        this.loadDynamicPricingManifest();
+      }
+      this.logger.logCostEvent("yaml_pricing_loaded_sync", {
+        source: "ProviderRegistry",
+        providers: Array.from(this.yamlPricingAvailable),
+        count: this.yamlPricingAvailable.size
+      });
+    } catch (error) {
+      this.logger.logCostEvent("yaml_pricing_sync_error", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw new Error(`Failed to load pricing data synchronously: ${error}`);
+    }
+  }
+};
+function readStringMeta(meta, key) {
+  const value = meta?.[key];
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readPricingConfidence(meta) {
+  const value = meta?.pricing_confidence ?? meta?.match_confidence;
+  return value === "high" || value === "medium" || value === "low" ? value : void 0;
+}
+
+export {
+  PassthroughResolver,
+  resolveAvailableTotalCostUsd,
+  isCostBreakdownUnavailable,
+  MAX_PLAUSIBLE_PER_MILLION_PRICE,
+  per1kToPerMillion,
+  UniversalCostCalculator
+};
+//# sourceMappingURL=chunk-ASEP3M2W.js.map