@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-EEUESN3T.js

@@ -0,0 +1,575 @@
+import {
+  isTelemetryPersistenceEnabled
+} from "./chunk-SDPIFNLD.js";
+import {
+  TelemetryPathResolver
+} from "./chunk-C3KCMAJP.js";
+import {
+  applySqlitePragmas
+} from "./chunk-HEP3ILP4.js";
+import {
+  redactPersistedTelemetryValue
+} from "./chunk-WV3KQDPE.js";
+import {
+  resolveBuildRoot
+} from "./chunk-CHA2HDE5.js";
+import {
+  BUILD_ROUTING_HISTORY_DB,
+  BUILD_TELEMETRY_DIR,
+  getRuntimeEnv,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/telemetry/routing-history-store.ts
+import { existsSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+import Database from "better-sqlite3";
+var SAFE_SQL_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/u;
+var SAFE_COLUMN_DEFINITION = /^(TEXT|INTEGER|REAL|BLOB|NUMERIC)$/iu;
+function validateSqlIdentifier(value, label) {
+  if (!SAFE_SQL_IDENTIFIER.test(value)) {
+    throw new Error(`Invalid SQL ${label}: ${value}`);
+  }
+  return value;
+}
+function validateColumnDefinition(value) {
+  if (!SAFE_COLUMN_DEFINITION.test(value)) {
+    throw new Error(`Invalid SQL column definition: ${value}`);
+  }
+  return value;
+}
+function resolveOutcomeQuality(qualityScore, qualityProvenance) {
+  if (qualityProvenance === "absent") {
+    return { qualityScore: void 0, qualityProvenance: "absent" };
+  }
+  if (qualityProvenance === "unknown") {
+    return typeof qualityScore === "number" && Number.isFinite(qualityScore) ? { qualityScore, qualityProvenance: "unknown" } : { qualityScore: void 0, qualityProvenance: "absent" };
+  }
+  if (typeof qualityScore === "number" && Number.isFinite(qualityScore)) {
+    return { qualityScore, qualityProvenance: "judged" };
+  }
+  return { qualityScore: void 0, qualityProvenance: "absent" };
+}
+var RoutingHistoryStore = class {
+  db = null;
+  dbPath;
+  isMemory;
+  constructor(dbPath = ":memory:") {
+    this.dbPath = dbPath;
+    this.isMemory = dbPath === ":memory:";
+    this.initialize();
+  }
+  /**
+   * Initialize database and schema
+   */
+  initialize() {
+    if (!isTelemetryPersistenceEnabled()) {
+      this.db = null;
+      return;
+    }
+    try {
+      if (!this.isMemory) {
+        const dir = dirname(this.dbPath);
+        if (!existsSync(dir)) {
+          mkdirSync(dir, { recursive: true });
+        }
+      }
+      this.db = new Database(this.dbPath);
+      applySqlitePragmas(this.db, { foreignKeys: true });
+      this.createSchema();
+    } catch (error) {
+      console.warn(
+        "[RoutingHistoryStore] Failed to initialize SQLite, falling back to no-op mode:",
+        error
+      );
+      this.db = null;
+    }
+  }
+  /**
+   * Create database schema
+   */
+  createSchema() {
+    if (!this.db) return;
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS routing_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        type TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        provider TEXT,
+        model TEXT,
+        domain TEXT,
+        payload TEXT NOT NULL,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE TABLE IF NOT EXISTS routing_outcomes (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        routing_id TEXT NOT NULL,
+        provider TEXT NOT NULL,
+        model TEXT,
+        domain TEXT,
+        success INTEGER NOT NULL,
+        quality_score REAL,
+        quality_provenance TEXT,
+        quality_source TEXT,
+        duration_ms REAL,
+        token_cost REAL,
+        timestamp INTEGER NOT NULL,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP
+      );
+    `);
+    this.ensureColumnExists("routing_events", "model", "TEXT");
+    this.ensureColumnExists("routing_outcomes", "model", "TEXT");
+    this.ensureColumnExists("routing_outcomes", "quality_provenance", "TEXT");
+    this.ensureColumnExists("routing_outcomes", "quality_source", "TEXT");
+    this.db.exec(`
+      UPDATE routing_outcomes
+      SET quality_provenance = CASE
+        WHEN quality_score IS NULL THEN 'absent'
+        ELSE 'unknown'
+      END
+      WHERE quality_provenance IS NULL;
+    `);
+    this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_outcomes_routing_id ON routing_outcomes(routing_id);
+      CREATE INDEX IF NOT EXISTS idx_outcomes_provider_model ON routing_outcomes(provider, model);
+      CREATE INDEX IF NOT EXISTS idx_outcomes_provider ON routing_outcomes(provider);
+      CREATE INDEX IF NOT EXISTS idx_outcomes_domain ON routing_outcomes(domain);
+      CREATE INDEX IF NOT EXISTS idx_outcomes_timestamp ON routing_outcomes(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_events_provider_model ON routing_events(provider, model);
+      CREATE INDEX IF NOT EXISTS idx_events_type ON routing_events(type);
+      CREATE INDEX IF NOT EXISTS idx_events_timestamp ON routing_events(timestamp);
+    `);
+  }
+  ensureColumnExists(tableName, columnName, columnDef) {
+    if (!this.db) return;
+    const safeTableName = validateSqlIdentifier(tableName, "table name");
+    const safeColumnName = validateSqlIdentifier(columnName, "column name");
+    const safeColumnDef = validateColumnDefinition(columnDef);
+    try {
+      const rows = this.db.prepare(`PRAGMA table_info(${safeTableName})`).all();
+      const hasColumn = rows.some((row) => row.name === safeColumnName);
+      if (!hasColumn) {
+        this.db.exec(`ALTER TABLE ${safeTableName} ADD COLUMN ${safeColumnName} ${safeColumnDef}`);
+      }
+    } catch (error) {
+      console.warn(
+        `[RoutingHistoryStore] Failed to ensure column ${tableName}.${columnName}:`,
+        error
+      );
+    }
+  }
+  /**
+   * Persist a routing telemetry event
+   */
+  persistEvent(event) {
+    if (!this.db) return;
+    try {
+      const stmt = this.db.prepare(`
+        INSERT INTO routing_events (type, timestamp, provider, model, domain, payload)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `);
+      const timestamp = new Date(event.timestamp).getTime();
+      const provider = "provider" in event ? event.provider : null;
+      const model = "model" in event && typeof event.model === "string" ? event.model : null;
+      const domain = "domain" in event ? event.domain : null;
+      const payload = JSON.stringify(redactPersistedTelemetryValue(event));
+      stmt.run(event.type, timestamp, provider, model, domain, payload);
+    } catch (error) {
+      console.warn("[RoutingHistoryStore] Failed to persist event:", error);
+    }
+  }
+  /**
+   * Record a routing outcome (success/failure with quality score).
+   * Quality is normalized via resolveOutcomeQuality so non-finite values and
+   * explicit `qualityProvenance: 'absent'` never become judged quality samples;
+   * operational success is independent.
+   */
+  recordOutcome(outcome) {
+    if (!this.db) return;
+    try {
+      const { qualityScore, qualityProvenance } = resolveOutcomeQuality(
+        outcome.qualityScore,
+        outcome.qualityProvenance
+      );
+      const existing = this.db.prepare("SELECT id FROM routing_outcomes WHERE routing_id = ? ORDER BY id DESC LIMIT 1").get(outcome.routingId);
+      const values = [
+        outcome.provider,
+        outcome.model ?? null,
+        outcome.domain,
+        outcome.success ? 1 : 0,
+        qualityScore ?? null,
+        qualityProvenance,
+        outcome.qualitySource ?? null,
+        outcome.duration ?? null,
+        outcome.tokenCost ?? null,
+        outcome.timestamp
+      ];
+      if (existing) {
+        this.db.prepare(`
+            UPDATE routing_outcomes
+            SET provider = ?, model = ?, domain = ?, success = ?, quality_score = ?,
+                quality_provenance = ?, quality_source = ?, duration_ms = ?, token_cost = ?,
+                timestamp = ?
+            WHERE id = ?
+          `).run(...values, existing.id);
+      } else {
+        this.db.prepare(`
+            INSERT INTO routing_outcomes (
+              routing_id, provider, model, domain, success, quality_score,
+              quality_provenance, quality_source, duration_ms, token_cost, timestamp
+            )
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          `).run(outcome.routingId, ...values);
+      }
+    } catch (error) {
+      console.warn("[RoutingHistoryStore] Failed to record outcome:", error);
+    }
+  }
+  /**
+   * Get provider success rate (0-1) for a domain within a time window
+   */
+  getProviderSuccessRate(providerId, domain, windowDays = 30, model) {
+    if (!this.db) return 0.5;
+    try {
+      const cutoffTime = Date.now() - windowDays * 24 * 60 * 60 * 1e3;
+      let query = `
+        SELECT AVG(success) as success_rate
+        FROM routing_outcomes
+        WHERE provider = ? AND timestamp >= ?
+          AND id = (SELECT MAX(latest.id) FROM routing_outcomes latest WHERE latest.routing_id = routing_outcomes.routing_id)
+      `;
+      const params = [providerId, cutoffTime];
+      if (model) {
+        query += " AND model = ?";
+        params.push(model);
+      }
+      if (domain) {
+        query += " AND domain = ?";
+        params.push(domain);
+      }
+      const result = this.db.prepare(query).get(...params);
+      return result?.success_rate ?? 0.5;
+    } catch (error) {
+      console.warn("[RoutingHistoryStore] Failed to get success rate:", error);
+      return 0.5;
+    }
+  }
+  /**
+   * Get provider average quality score (0-100) for a domain within a time window.
+   * Returns null when no judged quality samples exist — never a synthetic default
+   * (e.g. 50) that would pretend quality was observed.
+   */
+  getProviderAverageScore(providerId, domain, windowDays = 30, model) {
+    if (!this.db) return null;
+    try {
+      const cutoffTime = Date.now() - windowDays * 24 * 60 * 60 * 1e3;
+      let query = `
+        SELECT AVG(quality_score) as avg_score
+        FROM routing_outcomes
+        WHERE provider = ? AND timestamp >= ?
+          AND quality_provenance = 'judged' AND quality_score IS NOT NULL
+          AND id = (SELECT MAX(latest.id) FROM routing_outcomes latest WHERE latest.routing_id = routing_outcomes.routing_id)
+      `;
+      const params = [providerId, cutoffTime];
+      if (model) {
+        query += " AND model = ?";
+        params.push(model);
+      }
+      if (domain) {
+        query += " AND domain = ?";
+        params.push(domain);
+      }
+      const result = this.db.prepare(query).get(...params);
+      const avg = result?.avg_score;
+      return typeof avg === "number" && Number.isFinite(avg) ? avg : null;
+    } catch (error) {
+      console.warn("[RoutingHistoryStore] Failed to get average score:", error);
+      return null;
+    }
+  }
+  /**
+   * Get operational sample size for a provider/domain combination
+   * (all outcomes, with or without judged quality).
+   */
+  getSampleSize(providerId, domain, windowDays = 30, model) {
+    if (!this.db) return 0;
+    try {
+      const cutoffTime = Date.now() - windowDays * 24 * 60 * 60 * 1e3;
+      let query = `
+        SELECT COUNT(*) as count
+        FROM routing_outcomes
+        WHERE provider = ? AND timestamp >= ?
+          AND id = (SELECT MAX(latest.id) FROM routing_outcomes latest WHERE latest.routing_id = routing_outcomes.routing_id)
+      `;
+      const params = [providerId, cutoffTime];
+      if (model) {
+        query += " AND model = ?";
+        params.push(model);
+      }
+      if (domain) {
+        query += " AND domain = ?";
+        params.push(domain);
+      }
+      const result = this.db.prepare(query).get(...params);
+      return result?.count ?? 0;
+    } catch (error) {
+      console.warn("[RoutingHistoryStore] Failed to get sample size:", error);
+      return 0;
+    }
+  }
+  /**
+   * Get quality-sample size: only outcomes with a real judged quality_score.
+   * Missing quality must not inflate quality confidence, averages, or rankings.
+   */
+  getQualitySampleSize(providerId, domain, windowDays = 30, model) {
+    if (!this.db) return 0;
+    try {
+      const cutoffTime = Date.now() - windowDays * 24 * 60 * 60 * 1e3;
+      let query = `
+        SELECT COUNT(*) as count
+        FROM routing_outcomes
+        WHERE provider = ? AND timestamp >= ?
+          AND quality_provenance = 'judged' AND quality_score IS NOT NULL
+          AND id = (SELECT MAX(latest.id) FROM routing_outcomes latest WHERE latest.routing_id = routing_outcomes.routing_id)
+      `;
+      const params = [providerId, cutoffTime];
+      if (model) {
+        query += " AND model = ?";
+        params.push(model);
+      }
+      if (domain) {
+        query += " AND domain = ?";
+        params.push(domain);
+      }
+      const result = this.db.prepare(query).get(...params);
+      return result?.count ?? 0;
+    } catch (error) {
+      console.warn("[RoutingHistoryStore] Failed to get quality sample size:", error);
+      return 0;
+    }
+  }
+  /**
+   * Get domain provider rankings sorted by performance
+   */
+  getDomainProviderRankings(domain, windowDays = 30) {
+    if (!this.db) return [];
+    try {
+      const cutoffTime = Date.now() - windowDays * 24 * 60 * 60 * 1e3;
+      const query = `
+        SELECT
+          provider,
+          AVG(quality_score) as score,
+          COUNT(*) as count
+        FROM routing_outcomes
+        WHERE domain = ? AND timestamp >= ?
+          AND quality_provenance = 'judged' AND quality_score IS NOT NULL
+          AND id = (SELECT MAX(latest.id) FROM routing_outcomes latest WHERE latest.routing_id = routing_outcomes.routing_id)
+        GROUP BY provider
+        ORDER BY score DESC
+      `;
+      const results = this.db.prepare(query).all(domain, cutoffTime);
+      return results;
+    } catch (error) {
+      console.warn("[RoutingHistoryStore] Failed to get provider rankings:", error);
+      return [];
+    }
+  }
+  /**
+   * Prune old records (older than N days)
+   * Returns number of records deleted
+   */
+  pruneOlderThan(days) {
+    if (!this.db) return 0;
+    try {
+      const cutoffTime = Date.now() - days * 24 * 60 * 60 * 1e3;
+      const eventsDeleted = this.db.prepare("DELETE FROM routing_events WHERE timestamp < ?").run(cutoffTime);
+      const outcomesDeleted = this.db.prepare("DELETE FROM routing_outcomes WHERE timestamp < ?").run(cutoffTime);
+      return (eventsDeleted.changes ?? 0) + (outcomesDeleted.changes ?? 0);
+    } catch (error) {
+      console.warn("[RoutingHistoryStore] Failed to prune old records:", error);
+      return 0;
+    }
+  }
+  /**
+   * Get store statistics
+   */
+  getStats() {
+    if (!this.db) {
+      return {
+        totalEvents: 0,
+        oldestEvent: null,
+        providers: []
+      };
+    }
+    try {
+      const totalEvents = this.db.prepare("SELECT COUNT(*) as count FROM routing_events").get().count;
+      const oldestEventResult = this.db.prepare("SELECT MIN(timestamp) as oldest FROM routing_events").get();
+      const oldestEvent = oldestEventResult.oldest ? new Date(oldestEventResult.oldest) : null;
+      const providerResults = this.db.prepare(`
+          SELECT DISTINCT provider
+          FROM routing_outcomes
+          WHERE id = (
+            SELECT MAX(latest.id)
+            FROM routing_outcomes latest
+            WHERE latest.routing_id = routing_outcomes.routing_id
+          )
+        `).all();
+      const providers = providerResults.map((r) => r.provider);
+      return {
+        totalEvents,
+        oldestEvent,
+        providers
+      };
+    } catch (error) {
+      console.warn("[RoutingHistoryStore] Failed to get stats:", error);
+      return {
+        totalEvents: 0,
+        oldestEvent: null,
+        providers: []
+      };
+    }
+  }
+  /**
+   * Close database connection
+   */
+  close() {
+    if (this.db) {
+      try {
+        this.db.close();
+      } catch (error) {
+        console.warn("[RoutingHistoryStore] Failed to close database:", error);
+      }
+      this.db = null;
+    }
+  }
+};
+var globalRoutingHistoryStores = /* @__PURE__ */ new Map();
+function getGlobalRoutingHistoryStore() {
+  const configuredPath = readEnv(BUILD_ROUTING_HISTORY_DB).value;
+  const dbPath = configuredPath ? configuredPath : (() => {
+    const buildDir = getRuntimeEnv(BUILD_TELEMETRY_DIR.name) ?? join(resolveBuildRoot(process.cwd()), ".build-project");
+    const resolver = TelemetryPathResolver.getInstance();
+    return join(resolver.resolveDbDir(buildDir), "routing-history.db");
+  })();
+  const existing = globalRoutingHistoryStores.get(dbPath);
+  if (existing) {
+    return existing;
+  }
+  const store = new RoutingHistoryStore(dbPath);
+  globalRoutingHistoryStores.set(dbPath, store);
+  return store;
+}
+var ROUTING_SAMPLE_FLOOR = 2;
+var ROUTING_FULL_CONFIDENCE_SAMPLES = 20;
+function computeHistoricalAdjustment(providerId, domain, store, windowDays = 30, model) {
+  if (model) {
+    return computeHistoricalAdjustmentWithModelFallback(
+      providerId,
+      domain,
+      store,
+      windowDays,
+      model
+    );
+  }
+  return computeAdjustmentFromSamples(providerId, domain, store, windowDays, void 0);
+}
+function computeAdjustmentFromSamples(providerId, domain, store, windowDays, model) {
+  const sampleSize = store.getSampleSize(providerId, domain, windowDays, model);
+  const qualitySampleSize = store.getQualitySampleSize(providerId, domain, windowDays, model);
+  if (sampleSize < ROUTING_SAMPLE_FLOOR) {
+    return {
+      adjustment: 0,
+      confidence: 0,
+      sampleSize,
+      reason: "insufficient data"
+    };
+  }
+  const successRate = store.getProviderSuccessRate(providerId, domain, windowDays, model);
+  const qualityScore = store.getProviderAverageScore(providerId, domain, windowDays, model);
+  const hasQualitySamples = qualityScore != null && qualitySampleSize > 0;
+  const successConfidence = Math.min(1, sampleSize / ROUTING_FULL_CONFIDENCE_SAMPLES);
+  const qualityConfidence = hasQualitySamples ? Math.min(1, qualitySampleSize / ROUTING_FULL_CONFIDENCE_SAMPLES) : 0;
+  const confidence = hasQualitySamples ? successConfidence * 0.7 + qualityConfidence * 0.3 : successConfidence;
+  const successAdjustment = (successRate - 0.5) * 30;
+  const qualityAdjustment = hasQualitySamples ? (qualityScore - 50) / 50 * 15 : 0;
+  const scaledAdjustment = hasQualitySamples ? successAdjustment * 0.7 * successConfidence + qualityAdjustment * 0.3 * qualityConfidence : successAdjustment * successConfidence;
+  const adjustment = Math.max(-15, Math.min(15, scaledAdjustment));
+  const reasons = [];
+  if (successRate < 0.4) {
+    reasons.push("low success rate");
+  } else if (successRate > 0.6) {
+    reasons.push("high success rate");
+  }
+  if (hasQualitySamples) {
+    if (qualityScore < 40) {
+      reasons.push("low quality");
+    } else if (qualityScore > 60) {
+      reasons.push("high quality");
+    }
+  }
+  if (sampleSize < ROUTING_FULL_CONFIDENCE_SAMPLES) {
+    reasons.push("limited samples");
+  }
+  const reason = reasons.length > 0 ? reasons.join(", ") : hasQualitySamples ? `success=${(successRate * 100).toFixed(0)}%, quality=${qualityScore.toFixed(0)}` : `success=${(successRate * 100).toFixed(0)}% (no quality samples)`;
+  return { adjustment, confidence, sampleSize, reason };
+}
+function computeHistoricalAdjustmentWithModelFallback(providerId, domain, store, windowDays, model) {
+  const modelCount = store.getSampleSize(providerId, domain, windowDays, model);
+  const providerCount = store.getSampleSize(providerId, domain, windowDays, void 0);
+  const modelAboveFloor = modelCount >= ROUTING_SAMPLE_FLOOR;
+  const providerAboveFloor = providerCount >= ROUTING_SAMPLE_FLOOR;
+  if (!modelAboveFloor && !providerAboveFloor) {
+    return {
+      adjustment: 0,
+      confidence: 0,
+      sampleSize: modelCount,
+      reason: "insufficient data"
+    };
+  }
+  if (modelAboveFloor && !providerAboveFloor) {
+    return computeAdjustmentFromSamples(providerId, domain, store, windowDays, model);
+  }
+  if (!modelAboveFloor && providerAboveFloor) {
+    const base = computeAdjustmentFromSamples(providerId, domain, store, windowDays, void 0);
+    return {
+      ...base,
+      sampleSize: modelCount,
+      reason: `${base.reason} (provider fallback, n=${providerCount})`
+    };
+  }
+  const modelResult = computeAdjustmentFromSamples(providerId, domain, store, windowDays, model);
+  const providerResult = computeAdjustmentFromSamples(
+    providerId,
+    domain,
+    store,
+    windowDays,
+    void 0
+  );
+  const modelWeight = Math.min(0.8, modelCount / providerCount);
+  const providerWeight = 1 - modelWeight;
+  const blendedAdjustment = Math.max(
+    -15,
+    Math.min(15, modelResult.adjustment * modelWeight + providerResult.adjustment * providerWeight)
+  );
+  const blendedConfidence = Math.min(
+    1,
+    modelResult.confidence * modelWeight + providerResult.confidence * providerWeight
+  );
+  return {
+    adjustment: blendedAdjustment,
+    confidence: blendedConfidence,
+    sampleSize: modelCount,
+    reason: `${modelResult.reason} (model+provider blend, mw=${modelWeight.toFixed(2)})`
+  };
+}
+
+export {
+  resolveOutcomeQuality,
+  RoutingHistoryStore,
+  getGlobalRoutingHistoryStore,
+  ROUTING_SAMPLE_FLOOR,
+  ROUTING_FULL_CONFIDENCE_SAMPLES,
+  computeHistoricalAdjustment
+};
+//# sourceMappingURL=chunk-EEUESN3T.js.map

package/dist/chunk-EJ4LUU5Y.js

@@ -0,0 +1,73 @@
+import {
+  familyFlagshipModel,
+  isFamilyAlias
+} from "./chunk-FAZBRHGG.js";
+import {
+  ProviderRegistry
+} from "./chunk-QJ6OEH4K.js";
+
+// src/core/pricing/catalog-cost-estimate.ts
+var CHARS_PER_TOKEN_ESTIMATE = 4;
+var NEUTRAL_INPUT_USD_PER_1M_TOKENS = 2.5;
+var NEUTRAL_OUTPUT_USD_PER_1M_TOKENS = 10;
+var NEUTRAL_TOKEN_RATES = {
+  inputUsdPer1mTokens: NEUTRAL_INPUT_USD_PER_1M_TOKENS,
+  outputUsdPer1mTokens: NEUTRAL_OUTPUT_USD_PER_1M_TOKENS,
+  fromCatalog: false
+};
+function pricedRate(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function ratesFromModelPricing(pricing) {
+  if (!pricing) return void 0;
+  const perMillion = (perMillionValue, perThousandValue) => {
+    const direct = pricedRate(perMillionValue);
+    if (direct !== void 0) return direct;
+    const perThousand = pricedRate(perThousandValue);
+    return perThousand === void 0 ? void 0 : perThousand * 1e3;
+  };
+  const baseRatePerThousand = pricedRate(pricing.base_rate_per_1k_tokens);
+  const baseRate = baseRatePerThousand === void 0 ? void 0 : baseRatePerThousand * 1e3;
+  const input = perMillion(pricing.input_per_1m_tokens, pricing.input_per_1k_tokens) ?? baseRate ?? void 0;
+  const output = perMillion(pricing.output_per_1m_tokens, pricing.output_per_1k_tokens) ?? baseRate ?? void 0;
+  if (input === void 0 || output === void 0) return void 0;
+  return { inputUsdPer1mTokens: input, outputUsdPer1mTokens: output, fromCatalog: true };
+}
+function pricingModelId(providerId, model) {
+  if (!model) return void 0;
+  if (!isFamilyAlias(providerId, model)) return model;
+  return familyFlagshipModel(providerId, model)?.id;
+}
+function resolveTokenRates(providerId, model) {
+  if (!providerId) return NEUTRAL_TOKEN_RATES;
+  try {
+    const candidates = [
+      model,
+      ProviderRegistry.getDefaultModel(providerId),
+      ProviderRegistry.getModelForRole(providerId, "fast")
+    ];
+    for (const candidate of candidates) {
+      const priceable = pricingModelId(providerId, candidate);
+      if (!priceable) continue;
+      const rates = ratesFromModelPricing(ProviderRegistry.getModelPricing(providerId, priceable));
+      if (rates) return rates;
+    }
+  } catch {
+    return NEUTRAL_TOKEN_RATES;
+  }
+  return NEUTRAL_TOKEN_RATES;
+}
+function estimateCatalogTokenCostUsd(providerId, usage, options = {}) {
+  const rates = resolveTokenRates(providerId, options.model);
+  return Math.max(0, usage.inputTokens) / 1e6 * rates.inputUsdPer1mTokens + Math.max(0, usage.outputTokens) / 1e6 * rates.outputUsdPer1mTokens;
+}
+function estimatePromptTokens(prompt) {
+  if (!prompt) return 0;
+  return Math.ceil(prompt.length / CHARS_PER_TOKEN_ESTIMATE);
+}
+
+export {
+  estimateCatalogTokenCostUsd,
+  estimatePromptTokens
+};
+//# sourceMappingURL=chunk-EJ4LUU5Y.js.map