@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-ONYPLIVE.js

@@ -0,0 +1,753 @@
+import {
+  resolveProviderPricingPath
+} from "./chunk-PVJBTI7P.js";
+import {
+  availableCostAmount,
+  billingSourceFromRow,
+  computeListPrice,
+  costAmountOrNull,
+  isAvailableCostAmount,
+  listPriceUsageFromRecord,
+  longContextFromRow,
+  pricingConfidenceFromRow,
+  pricingSourceFromRow,
+  rateCardFromModelPricing,
+  rateCardFromPricingRow,
+  resolvePassthroughPricing,
+  speedTiersFromRow,
+  unavailableCostAmount
+} from "./chunk-Q64IR2Z2.js";
+import {
+  ModelMetadataResolver
+} from "./chunk-YVCMDVBB.js";
+import {
+  parseJsonWithContext
+} from "./chunk-P6SSWAKY.js";
+import {
+  ProviderRegistry
+} from "./chunk-QJ6OEH4K.js";
+
+// src/cost-tracking/universal-cost-calculator.ts
+import { readFileSync } from "fs";
+
+// src/cost-tracking/unavailable-cost-breakdown.ts
+function buildUnavailableCostBreakdown(input) {
+  const { provider, model, usage, pricingVersion, pricingError, originalModelId } = input;
+  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,
+    billingMode: "metered",
+    pricingSource: "unavailable",
+    pricingConfidence: "low",
+    pricingStatus: "unavailable",
+    pricingError
+  };
+}
+
+// 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,
+      cacheWriteLong: resolved.pricing.cache_write_1h_per_1m_tokens !== void 0 ? Number(resolved.pricing.cache_write_1h_per_1m_tokens) : void 0,
+      currency: this.resolvePricingCurrency(resolved.provider),
+      unit: "per_1m_tokens",
+      declaresTokenRates: true,
+      contextWindow: resolved.pricing.context_window,
+      features: resolved.pricing.features ?? {},
+      billingMode: this.resolveCostBillingMode(resolved.provider),
+      // The maker reference stays the source; the route that reached it is recorded apart.
+      pricingSource: resolved.source,
+      resolutionRoute: `passthrough:${resolved.provider}/${resolved.model}`,
+      pricingConfidence: "medium",
+      // Long-context and speed tiers survive the passthrough hop.
+      longContextPricing: longContextFromRow(resolved.pricing.long_context_pricing),
+      speedTiers: speedTiersFromRow(resolved.pricing),
+      pricingNotes: resolved.pricing.notes,
+      routedSpeedTier: resolved.pricing.routed_speed_tier,
+      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";
+    }
+  }
+  /**
+   * 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 buildUnavailableCostBreakdown({
+        provider: resolvedProvider,
+        model: normalizedModel,
+        usage: { ...usage, tools },
+        pricingVersion: this.pricingVersion,
+        pricingError: `Model ${normalizedModel} not found for provider ${resolvedProvider}`,
+        originalModelId: model
+      });
+    }
+    if (pricing.unpricedReason) {
+      return buildUnavailableCostBreakdown({
+        provider: resolvedProvider,
+        model: normalizedModel,
+        usage: { ...usage, tools },
+        pricingVersion: this.pricingVersion,
+        pricingError: `Model ${normalizedModel} is unpriced: ${pricing.unpricedReason}`,
+        originalModelId: 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;
+    let listPrice;
+    if (pricing.billingMode === "metered" || pricing.declaresTokenRates) {
+      const cacheReadTokens = usage.cacheReadTokens ?? 0;
+      if (usage.cacheReadTokensIncludedInInput && cacheReadTokens > usage.inputTokens) {
+        throw new Error(
+          `Invalid inclusive cache usage: cacheReadTokens (${cacheReadTokens}) exceeds inputTokens (${usage.inputTokens}).`
+        );
+      }
+      listPrice = computeListPrice(
+        rateCardFromModelPricing(pricing),
+        listPriceUsageFromRecord(usage),
+        usage.speedTier,
+        { speedBreakdown: usage.speedBreakdown, routed: pricing.routedSpeedTier }
+      );
+      inputCost = listPrice.inputUsd;
+      outputCost = listPrice.outputUsd;
+      cacheCost = listPrice.cacheUsd;
+    }
+    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,
+      ...pricing.resolutionRoute ? { resolutionRoute: pricing.resolutionRoute } : {},
+      pricingConfidence: pricing.pricingConfidence ?? "high",
+      pricingStatus: "ok",
+      ...listPrice ? { speedTier: listPrice.speedTier, longContextPremium: listPrice.longContextPremium } : {}
+    };
+  }
+  /**
+   * Predict cost before execution
+   */
+  predictCost(provider, model, estimatedTokens) {
+    const usage = {
+      inputTokens: estimatedTokens.input,
+      outputTokens: estimatedTokens.output,
+      ...estimatedTokens.cacheRead === void 0 ? {} : { cacheReadTokens: estimatedTokens.cacheRead },
+      ...estimatedTokens.cacheWrite === void 0 ? {} : { cacheWriteTokens: estimatedTokens.cacheWrite },
+      // A prediction prices one request, so long-context thresholds apply.
+      granularity: "request",
+      ...estimatedTokens.speedTier ? { speedTier: estimatedTokens.speedTier } : {},
+      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 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: yamlPricing.cache_read_per_1m_tokens,
+        cacheWrite: yamlPricing.cache_write_per_1m_tokens,
+        cacheWriteLong: yamlPricing.cache_write_1h_per_1m_tokens,
+        currency,
+        unit,
+        contextWindow: yamlPricing.context_window,
+        declaresTokenRates: rateCardFromPricingRow(yamlPricing) !== void 0,
+        features: yamlPricing.features || {},
+        billingMode: billingSourceFromRow(yamlPricing) === "api_list_price" ? "metered" : this.resolveCostBillingMode(resolvedPricing.resolvedModel.provider),
+        billingSource: billingSourceFromRow(yamlPricing),
+        pricingSource: pricingSourceFromRow(yamlPricing) ?? "yaml",
+        pricingConfidence: pricingConfidenceFromRow(yamlPricing) ?? "high",
+        pricingNotes: yamlPricing.notes,
+        ...yamlPricing.unpriced_reason ? { unpricedReason: yamlPricing.unpriced_reason } : {},
+        pricingProvider: resolvedPricing.resolvedModel.provider,
+        pricingModel: resolvedPricing.resolvedModel.modelId,
+        ...yamlPricing.long_context_pricing ? { longContextPricing: longContextFromRow(yamlPricing.long_context_pricing) } : {},
+        ...yamlPricing.speed_tiers ? { speedTiers: speedTiersFromRow(yamlPricing) } : {}
+      };
+    } 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.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}`);
+    }
+  }
+};
+
+export {
+  resolveAvailableTotalCostUsd,
+  isCostBreakdownUnavailable,
+  MAX_PLAUSIBLE_PER_MILLION_PRICE,
+  per1kToPerMillion,
+  UniversalCostCalculator
+};
+//# sourceMappingURL=chunk-ONYPLIVE.js.map