@omnicross/core 0.1.5 → 0.1.7

package/dist/ApiConverter.cjs

@@ -9,7 +9,7 @@
 
 
 
-var _chunkSUEGJ75Dcjs = require('./chunk-SUEGJ75D.cjs');
+var _chunkGDIXXKF2cjs = require('./chunk-GDIXXKF2.cjs');
 
 
 
@@ -21,4 +21,4 @@ var _chunkSUEGJ75Dcjs = require('./chunk-SUEGJ75D.cjs');
 
 
 
-exports.convertAnthropicRequestToOpenAI = _chunkSUEGJ75Dcjs.convertAnthropicRequestToOpenAI; exports.convertAnthropicStreamToOpenAI = _chunkSUEGJ75Dcjs.convertAnthropicStreamToOpenAI; exports.convertAnthropicToOpenAI = _chunkSUEGJ75Dcjs.convertAnthropicToOpenAI; exports.convertAnthropicToOpenAIWithThinking = _chunkSUEGJ75Dcjs.convertAnthropicToOpenAIWithThinking; exports.convertOpenAIResponseToAnthropic = _chunkSUEGJ75Dcjs.convertOpenAIResponseToAnthropic; exports.convertOpenAIStreamToAnthropic = _chunkSUEGJ75Dcjs.convertOpenAIStreamToAnthropic; exports.convertOpenAIToAnthropic = _chunkSUEGJ75Dcjs.convertOpenAIToAnthropic; exports.convertOpenAIToAnthropicWithThinking = _chunkSUEGJ75Dcjs.convertOpenAIToAnthropicWithThinking; exports.hasImageContent = _chunkSUEGJ75Dcjs.hasImageContent; exports.hasThinkingEnabled = _chunkSUEGJ75Dcjs.hasThinkingEnabled;
+exports.convertAnthropicRequestToOpenAI = _chunkGDIXXKF2cjs.convertAnthropicRequestToOpenAI; exports.convertAnthropicStreamToOpenAI = _chunkGDIXXKF2cjs.convertAnthropicStreamToOpenAI; exports.convertAnthropicToOpenAI = _chunkGDIXXKF2cjs.convertAnthropicToOpenAI; exports.convertAnthropicToOpenAIWithThinking = _chunkGDIXXKF2cjs.convertAnthropicToOpenAIWithThinking; exports.convertOpenAIResponseToAnthropic = _chunkGDIXXKF2cjs.convertOpenAIResponseToAnthropic; exports.convertOpenAIStreamToAnthropic = _chunkGDIXXKF2cjs.convertOpenAIStreamToAnthropic; exports.convertOpenAIToAnthropic = _chunkGDIXXKF2cjs.convertOpenAIToAnthropic; exports.convertOpenAIToAnthropicWithThinking = _chunkGDIXXKF2cjs.convertOpenAIToAnthropicWithThinking; exports.hasImageContent = _chunkGDIXXKF2cjs.hasImageContent; exports.hasThinkingEnabled = _chunkGDIXXKF2cjs.hasThinkingEnabled;

package/dist/ApiConverter.js

@@ -9,7 +9,7 @@ import {
   convertOpenAIToAnthropicWithThinking,
   hasImageContent,
   hasThinkingEnabled
-} from "./chunk-5ZQBEOMD.js";
+} from "./chunk-5NJLQ6T6.js";
 export {
   convertAnthropicRequestToOpenAI,
   convertAnthropicStreamToOpenAI,

package/dist/{CompletionService-DdWaAxq0.d.ts → CompletionService-C3BX0Ovy.d.ts}

@@ -174,9 +174,10 @@ declare class CompletionService {
      * Resolve effective max_tokens value with priority:
      * 1. Session settings (if provided)
      * 2. Global model parameters (if enabled)
-     * 3. Model's maxTokens from provider config
-     * 4. Discovered models cache (from API)
-     * 5. undefined - let API use its default
+     * 3. undefined - let API use its default
+     *
+     * Provider and discovery maxTokens values are capability metadata, not
+     * implicit per-request output limits.
      */
     resolveEffectiveMaxTokens(providerId: string, modelId: string, sessionMaxTokens?: number): Promise<number | undefined>;
     /**

package/dist/{CompletionService-D3a47vdU.d.cts → CompletionService-kNA17cfI.d.cts}

@@ -174,9 +174,10 @@ declare class CompletionService {
      * Resolve effective max_tokens value with priority:
      * 1. Session settings (if provided)
      * 2. Global model parameters (if enabled)
-     * 3. Model's maxTokens from provider config
-     * 4. Discovered models cache (from API)
-     * 5. undefined - let API use its default
+     * 3. undefined - let API use its default
+     *
+     * Provider and discovery maxTokens values are capability metadata, not
+     * implicit per-request output limits.
      */
     resolveEffectiveMaxTokens(providerId: string, modelId: string, sessionMaxTokens?: number): Promise<number | undefined>;
     /**

package/dist/auth/GeminiCodeAssistProjectResolver.cjs

@@ -1,12 +1,14 @@
 "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 _class;
 
 
-var _chunkDDMRUL76cjs = require('../chunk-DDMRUL76.cjs');
-require('../chunk-JWVTXXPX.cjs');
+var _chunkOKMJLEXXcjs = require('../chunk-OKMJLEXX.cjs');
+require('../chunk-KBM2W6UY.cjs');
 
 
-var _chunkPG7PS2NNcjs = require('../chunk-PG7PS2NN.cjs');
-require('../chunk-3Z5BQZFM.cjs');
+var _chunkRJUONLUQcjs = require('../chunk-RJUONLUQ.cjs');
+require('../chunk-235MXAGX.cjs');
+require('../chunk-HVBBDBS3.cjs');
+require('../chunk-NKVZ6Z3Y.cjs');
 
 // src/auth/GeminiCodeAssistProjectResolver.ts
 var FREE_TIER_ID = "free-tier";
@@ -26,7 +28,7 @@ var GeminiCodeAssistHandshakeError = class extends Error {
 var GeminiCodeAssistProjectResolver = (_class = class {
   // upstream-proxy: the Code Assist handshake is upstream egress → honor the
   // gemini proxy by default (still injectable for tests).
-  constructor(fetchImpl = (url, init) => _chunkPG7PS2NNcjs.fetchUpstream.call(void 0, url, init, { providerId: "gemini" })) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+  constructor(fetchImpl = (url, init) => _chunkRJUONLUQcjs.fetchUpstream.call(void 0, url, init, { providerId: "gemini" })) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
     this.fetchImpl = fetchImpl;
   }
   
@@ -60,7 +62,7 @@ var GeminiCodeAssistProjectResolver = (_class = class {
     return run;
   }
   codeAssistUrl(method) {
-    return `${_chunkDDMRUL76cjs.resolveCodeAssistEndpoint.call(void 0, )}/${_chunkDDMRUL76cjs.resolveCodeAssistApiVersion.call(void 0, )}:${method}`;
+    return `${_chunkOKMJLEXXcjs.resolveCodeAssistEndpoint.call(void 0, )}/${_chunkOKMJLEXXcjs.resolveCodeAssistApiVersion.call(void 0, )}:${method}`;
   }
   /** Seed project id from env; reject a purely-numeric value (project NUMBER). */
   seedProjectId() {

package/dist/auth/GeminiCodeAssistProjectResolver.js

@@ -1,12 +1,14 @@
 import {
   resolveCodeAssistApiVersion,
   resolveCodeAssistEndpoint
-} from "../chunk-MFZ5437A.js";
-import "../chunk-6QZGDLL4.js";
+} from "../chunk-N5T4M4GU.js";
+import "../chunk-TOVPMMHM.js";
 import {
   fetchUpstream
-} from "../chunk-D3TDKWRP.js";
-import "../chunk-SYQF7OIR.js";
+} from "../chunk-RJ5ZGNI3.js";
+import "../chunk-3WD4HTR2.js";
+import "../chunk-MKF46GNZ.js";
+import "../chunk-GL6XM527.js";
 
 // src/auth/GeminiCodeAssistProjectResolver.ts
 var FREE_TIER_ID = "free-tier";

package/dist/{chunk-3Z5BQZFM.cjs → chunk-235MXAGX.cjs}

@@ -2,6 +2,7 @@
 var _promises = require('fs/promises');
 var _path = require('path');
 var tracePath = null;
+var REDACTED_BODY = "***REDACTED (credential exchange)***";
 var SECRET_HEADER_NAMES = /* @__PURE__ */ new Set([
   "authorization",
   "api-key",
@@ -49,4 +50,5 @@ function __resetUpstreamTraceForTests() {
 
 
 
-exports.setUpstreamTracePath = setUpstreamTracePath; exports.getUpstreamTracePath = getUpstreamTracePath; exports.redactHeaders = redactHeaders; exports.writeUpstreamTrace = writeUpstreamTrace; exports.__resetUpstreamTraceForTests = __resetUpstreamTraceForTests;
+
+exports.REDACTED_BODY = REDACTED_BODY; exports.setUpstreamTracePath = setUpstreamTracePath; exports.getUpstreamTracePath = getUpstreamTracePath; exports.redactHeaders = redactHeaders; exports.writeUpstreamTrace = writeUpstreamTrace; exports.__resetUpstreamTraceForTests = __resetUpstreamTraceForTests;

package/dist/{chunk-HRRYG2AX.js → chunk-23S5OPIO.js}

@@ -1,6 +1,12 @@
 import {
   serializeError
 } from "./chunk-AVYJ4YBN.js";
+import {
+  isAccountAllowanceExhaustedError
+} from "./chunk-OPRS4IQZ.js";
+import {
+  isBoundAccountSelectionError
+} from "./chunk-2JYRIADS.js";
 
 // src/pipeline/SubscriptionAuthSource.ts
 function stripAuthHeaders(headers) {
@@ -34,9 +40,12 @@ var SubscriptionAuthSource = class {
         resolvedModel: hints.model,
         sessionKey: hints.sessionKey,
         reportSelection: hints.reportSelection,
-        preferredAccountId: hints.preferredAccountId
+        preferredAccountId: hints.preferredAccountId,
+        preferredAccountGroup: hints.preferredAccountGroup,
+        boundAccountFallbackPolicy: hints.boundAccountFallbackPolicy
       });
     } catch (err) {
+      if (isAccountAllowanceExhaustedError(err) || isBoundAccountSelectionError(err)) throw err;
       console.warn("[SubscriptionAuthSource] authStrategy.applyHeaders threw:", serializeError(err));
     }
   }

package/dist/chunk-25GXJCEZ.cjs

@@ -0,0 +1,40 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); var _class;// src/pipeline/BoundAccountSelectionError.ts
+var FAILURE_MESSAGES = {
+  unavailable: "Bound subscription account is unavailable",
+  "not-found": "Bound subscription account was not found",
+  disabled: "Bound subscription account is disabled",
+  unhealthy: "Bound subscription account is unhealthy",
+  "model-incompatible": "Bound subscription account cannot serve the requested model",
+  "allowance-paused": "Bound subscription account is paused by the allowance policy",
+  "empty-token": "Bound subscription account has no usable token"
+};
+function boundAccountSelectionMessage(reason) {
+  return FAILURE_MESSAGES[reason];
+}
+var BoundAccountSelectionError = (_class = class extends Error {
+  constructor(providerId, reason, resumeAt) {
+    super(boundAccountSelectionMessage(reason));_class.prototype.__init.call(this);;
+    this.providerId = providerId;
+    this.reason = reason;
+    this.resumeAt = resumeAt;
+    this.name = "BoundAccountSelectionError";
+    this.status = reason === "allowance-paused" ? 429 : 503;
+  }
+  
+  
+  
+  __init() {this.code = "bound_account_unavailable"}
+  
+}, _class);
+function isBoundAccountSelectionError(error) {
+  if (error instanceof BoundAccountSelectionError) return true;
+  if (!error || typeof error !== "object") return false;
+  const value = error;
+  return value.code === "bound_account_unavailable" && (value.status === 429 || value.status === 503) && typeof value.reason === "string" && Object.prototype.hasOwnProperty.call(FAILURE_MESSAGES, value.reason);
+}
+
+
+
+
+
+exports.boundAccountSelectionMessage = boundAccountSelectionMessage; exports.BoundAccountSelectionError = BoundAccountSelectionError; exports.isBoundAccountSelectionError = isBoundAccountSelectionError;

package/dist/chunk-2E42SAW3.cjs

@@ -0,0 +1,323 @@
+"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 _class;// src/usage/pricing-engine.ts
+
+
+
+var _pricingtypes = require('@omnicross/contracts/pricing-types');
+var PricingEngine = (_class = class {
+  constructor(store, logger, options = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);
+    this.store = store;
+    this.logger = logger;
+    this.options = options;
+  }
+  
+  
+  
+  __init() {this.cache = /* @__PURE__ */ new Map()}
+  /**
+   * Secondary index keyed by modelId alone. Used as a fallback when no exact
+   * (providerId, modelId) match exists — usage may be recorded under a
+   * runtime provider alias while pricing rows use the canonical provider id,
+   * so matching by model name lets the price still resolve. First
+   * non-wildcard entry per model wins.
+   */
+  __init2() {this.cacheByModel = /* @__PURE__ */ new Map()}
+  /**
+   * Last-resort fuzzy index: `[normalizedModelId, entry]` pairs over the same
+   * non-wildcard, non-openrouter rows as `cacheByModel`. Used when even the
+   * model-name fallback misses — e.g. usage recorded under a bare model id
+   * (`glm-5.2`) while the catalog only knows prefixed slugs
+   * (`cloudflare/@cf/zai-org/glm-5.2`). This is an ESTIMATE: the matched row
+   * may be an aggregate-route price rather than the direct-vendor rate.
+   */
+  __init3() {this.fuzzyEntries = []}
+  __init4() {this.cacheLoaded = false}
+  /** Coalesce manual and background refreshes to prevent a catalog stampede. */
+  __init5() {this.refreshInFlight = null}
+  // ===== Cache management =====
+  /** Lazy-load and cache the full pricing table. */
+  async ensureCache() {
+    if (this.cacheLoaded) return;
+    const rows = await this.store.getAll();
+    this.cache = new Map(rows.map((r) => [keyOf(r.providerId, r.modelId), r]));
+    this.cacheByModel = /* @__PURE__ */ new Map();
+    this.fuzzyEntries = [];
+    for (const r of rows) {
+      if (r.providerId === "*" || r.providerId === "openrouter" || r.source === "openrouter") continue;
+      if (!this.cacheByModel.has(r.modelId)) this.cacheByModel.set(r.modelId, r);
+      this.fuzzyEntries.push([normalizeModelId(r.modelId), r]);
+    }
+    this.cacheLoaded = true;
+  }
+  /** Force a cache refresh — call after any write. */
+  async invalidateCache() {
+    this.cacheLoaded = false;
+    await this.ensureCache();
+  }
+  // ===== Read API =====
+  async getAll() {
+    await this.ensureCache();
+    return Array.from(this.cache.values());
+  }
+  /**
+   * Look up a price for (provider, model). Resolution order:
+   *   1. exact (providerId, modelId)
+   *   2. wildcard provider ('*', modelId)
+   *   3. model name alone (any provider) — tolerates a runtime-alias vs
+   *      canonical provider-id mismatch for the same model.
+   *   4. normalized fuzzy match (last resort) — matches a bare id like
+   *      `glm-5.2` against prefixed catalog slugs like
+   *      `cloudflare/@cf/zai-org/glm-5.2`. ESTIMATE only: the matched row may
+   *      be an aggregate-route price, not the direct-vendor rate.
+   */
+  async getEntry(providerId, modelId) {
+    await this.ensureCache();
+    const exact = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(this.cache.get(keyOf(providerId, modelId)), () => ( this.cache.get(keyOf("*", modelId)))), () => ( this.cacheByModel.get(modelId))), () => ( null));
+    if (exact) return exact;
+    return this.fuzzyMatch(modelId);
+  }
+  /**
+   * Normalized substring match over the catalog's non-openrouter rows. Lowercases
+   * and strips all non-alphanumerics, then matches bidirectionally, preferring
+   * the shortest catalog key (tightest match) to reduce over-matching version
+   * variants. Returns null when nothing matches.
+   */
+  fuzzyMatch(modelId) {
+    const normQuery = normalizeModelId(modelId);
+    if (!normQuery) return null;
+    let best = null;
+    let bestLen = Infinity;
+    for (const [key, entry] of this.fuzzyEntries) {
+      if (!key || !key.includes(normQuery) && !normQuery.includes(key)) continue;
+      if (key.length < bestLen) {
+        best = entry;
+        bestLen = key.length;
+      }
+    }
+    return best;
+  }
+  // ===== Cost calculation =====
+  /**
+   * Compute the cost (and cache savings) for a single response.
+   *
+   * Cost formula (USD):
+   *   cost = (input  * inputPrice
+   *         + output * outputPrice
+   *         + cacheRead  * (cacheReadPrice  ?? inputPrice)
+   *         + cacheWrite * (cacheWritePrice ?? inputPrice)
+   *        ) / 1e6
+   *
+   * Cache savings:
+   *   savings = cacheRead * (inputPrice - cacheReadPrice) / 1e6
+   *           — clamped at 0 if cacheReadPrice is null or ≥ inputPrice.
+   */
+  async calculateCost(providerId, modelId, usage) {
+    const entry = await this.getEntry(providerId, modelId);
+    if (!entry) {
+      return { costUsd: 0, costSavedByCacheUsd: 0 };
+    }
+    const ip = entry.inputPricePer1m;
+    const op = entry.outputPricePer1m;
+    const crp = _nullishCoalesce(entry.cacheReadPricePer1m, () => ( ip));
+    const cwp = _nullishCoalesce(entry.cacheWritePricePer1m, () => ( ip));
+    const costUsd = (usage.inputTokens * ip + usage.outputTokens * op + usage.cacheReadTokens * crp + usage.cacheCreationTokens * cwp) / 1e6;
+    const savingsRate = entry.cacheReadPricePer1m == null ? 0 : Math.max(0, ip - crp);
+    const costSavedByCacheUsd = usage.cacheReadTokens * savingsRate / 1e6;
+    return { costUsd, costSavedByCacheUsd };
+  }
+  // ===== Manual upsert (used by inline editors) =====
+  async upsertManual(input) {
+    const updated = await this.store.upsert(
+      input,
+      /* asUserEdit */
+      true
+    );
+    this.cache.set(keyOf(updated.providerId, updated.modelId), updated);
+    if (updated.providerId !== "*" && updated.providerId !== "openrouter" && updated.source !== "openrouter") {
+      this.cacheByModel.set(updated.modelId, updated);
+    }
+    return updated;
+  }
+  // ===== Source refresh =====
+  async fetchLatestFromSource() {
+    if (this.refreshInFlight) return this.refreshInFlight;
+    const refresh = this.refreshSources();
+    this.refreshInFlight = refresh;
+    try {
+      return await refresh;
+    } finally {
+      if (this.refreshInFlight === refresh) this.refreshInFlight = null;
+    }
+  }
+  async refreshSources() {
+    const sourceUrl = _nullishCoalesce(this.options.sourceUrl, () => ( _pricingtypes.DEFAULT_LITELLM_PRICING_URL));
+    const openRouterSourceUrl = _nullishCoalesce(this.options.openRouterSourceUrl, () => ( _pricingtypes.DEFAULT_OPENROUTER_PRICING_URL));
+    const fetchImpl = _nullishCoalesce(this.options.fetchImpl, () => ( fetch));
+    const timeoutMs = _nullishCoalesce(this.options.fetchTimeoutMs, () => ( 1e4));
+    const fetchedAt = Date.now();
+    const [litellm, openrouter] = await Promise.all([
+      fetchCatalog(fetchImpl, sourceUrl, timeoutMs, parseLitellmJson),
+      fetchCatalog(fetchImpl, openRouterSourceUrl, timeoutMs, parseOpenRouterJson)
+    ]);
+    const sources = [
+      sourceResult("litellm", sourceUrl, litellm),
+      sourceResult("openrouter", openRouterSourceUrl, openrouter)
+    ];
+    for (const source of sources) {
+      if (source.status === "failed") {
+        this.logger.warn(`[PricingEngine] ${source.source} pricing-source fetch failed`, {
+          error: source.error
+        });
+      }
+    }
+    if (!litellm.ok && !openrouter.ok) {
+      throw new Error(
+        `Pricing-source fetch failed: LiteLLM (${litellm.error}); OpenRouter (${openrouter.error})`
+      );
+    }
+    const applied = [];
+    const conflicts = [];
+    if (litellm.ok) {
+      const result = await this.store.bulkApplyFromSource(litellm.entries, "litellm");
+      applied.push(...result.applied);
+      conflicts.push(
+        ...result.conflicts.map((c) => ({
+          providerId: c.current.providerId,
+          modelId: c.current.modelId,
+          current: c.current,
+          incoming: c.incoming
+        }))
+      );
+      sources[0].appliedCount = result.applied.length;
+    }
+    if (openrouter.ok) {
+      const current = new Map(
+        (await this.store.getAll()).map((row) => [keyOf(row.providerId, row.modelId), row])
+      );
+      const supplemental = openrouter.entries.filter((incoming) => {
+        const row = current.get(keyOf(incoming.providerId, incoming.modelId));
+        return !row || row.source === "openrouter" || row.source === "builtin";
+      });
+      const result = await this.store.bulkApplyFromSource(supplemental, "openrouter");
+      applied.push(...result.applied);
+      sources[1].appliedCount = result.applied.length;
+    }
+    if (applied.length > 0) await this.invalidateCache();
+    return {
+      applied,
+      conflicts,
+      fetchedAt,
+      sourceUrl,
+      sources
+    };
+  }
+  // ===== Conflict resolution =====
+  async resolveConflicts(decisions, pendingIncoming) {
+    const resolutions = [];
+    for (const d of decisions) {
+      const incoming = pendingIncoming.get(keyOf(d.providerId, d.modelId));
+      if (!incoming) continue;
+      resolutions.push({ incoming, action: d.action });
+    }
+    const result = await this.store.applyResolutions(resolutions);
+    await this.invalidateCache();
+    return result;
+  }
+}, _class);
+var keyOf = (providerId, modelId) => `${providerId}::${modelId}`;
+var normalizeModelId = (modelId) => (_nullishCoalesce(modelId, () => ( ""))).toLowerCase().replace(/[^a-z0-9]/g, "");
+var PROVIDER_ALIASES = {
+  vertex_ai: "gemini",
+  google: "gemini",
+  bedrock: "anthropic",
+  azure: "openai"
+};
+var parseLitellmJson = (json) => {
+  if (!json || typeof json !== "object" || Array.isArray(json)) {
+    throw new Error("invalid LiteLLM catalog shape");
+  }
+  const out = [];
+  for (const [modelId, entry] of Object.entries(json)) {
+    if (modelId === "sample_spec") continue;
+    if (!entry || typeof entry !== "object") continue;
+    if (entry.input_cost_per_token == null || entry.output_cost_per_token == null) {
+      continue;
+    }
+    const rawProvider = _nullishCoalesce(entry.litellm_provider, () => ( ""));
+    const providerId = _nullishCoalesce(PROVIDER_ALIASES[rawProvider], () => ( rawProvider));
+    if (!providerId) continue;
+    out.push({
+      providerId,
+      modelId,
+      inputPricePer1m: entry.input_cost_per_token * 1e6,
+      outputPricePer1m: entry.output_cost_per_token * 1e6,
+      cacheReadPricePer1m: entry.cache_read_input_token_cost != null ? entry.cache_read_input_token_cost * 1e6 : null,
+      cacheWritePricePer1m: entry.cache_creation_input_token_cost != null ? entry.cache_creation_input_token_cost * 1e6 : null
+    });
+  }
+  return out;
+};
+var parseOpenRouterJson = (json) => {
+  if (!json || !Array.isArray(json.data)) {
+    throw new Error("invalid OpenRouter catalog shape");
+  }
+  const out = [];
+  for (const model of json.data) {
+    const modelId = typeof _optionalChain([model, 'optionalAccess', _ => _.id]) === "string" ? model.id.trim() : "";
+    const input = parseUnitPrice(_optionalChain([model, 'optionalAccess', _2 => _2.pricing, 'optionalAccess', _3 => _3.prompt]));
+    const output = parseUnitPrice(_optionalChain([model, 'optionalAccess', _4 => _4.pricing, 'optionalAccess', _5 => _5.completion]));
+    if (!modelId || input === null || output === null) continue;
+    const cacheRead = parseUnitPrice(_optionalChain([model, 'access', _6 => _6.pricing, 'optionalAccess', _7 => _7.input_cache_read]));
+    const cacheWrite = parseUnitPrice(_optionalChain([model, 'access', _8 => _8.pricing, 'optionalAccess', _9 => _9.input_cache_write]));
+    out.push({
+      providerId: "openrouter",
+      modelId,
+      inputPricePer1m: input * 1e6,
+      outputPricePer1m: output * 1e6,
+      cacheReadPricePer1m: cacheRead === null ? null : cacheRead * 1e6,
+      cacheWritePricePer1m: cacheWrite === null ? null : cacheWrite * 1e6
+    });
+  }
+  return out;
+};
+function parseUnitPrice(value) {
+  if (value === "" || value === null || value === void 0) return null;
+  const parsed = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+}
+async function fetchCatalog(fetchImpl, url, timeoutMs, parse) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  _optionalChain([timer, 'access', _10 => _10.unref, 'optionalCall', _11 => _11()]);
+  try {
+    const response = await fetchImpl(url, { signal: controller.signal });
+    if (!response.ok) throw new Error(`status ${response.status}`);
+    const entries = parse(await response.json());
+    if (entries.length === 0) throw new Error("pricing catalog contained no usable entries");
+    return { ok: true, entries };
+  } catch (error) {
+    const message = controller.signal.aborted ? `timeout after ${timeoutMs}ms` : error instanceof Error ? error.message : String(error);
+    return { ok: false, error: message };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function sourceResult(source, sourceUrl, attempt) {
+  return attempt.ok ? {
+    source,
+    sourceUrl,
+    status: "applied",
+    parsedCount: attempt.entries.length,
+    appliedCount: 0
+  } : {
+    source,
+    sourceUrl,
+    status: "failed",
+    parsedCount: 0,
+    appliedCount: 0,
+    error: attempt.error
+  };
+}
+
+
+
+exports.PricingEngine = PricingEngine;

package/dist/chunk-2JYRIADS.js

@@ -0,0 +1,40 @@
+// src/pipeline/BoundAccountSelectionError.ts
+var FAILURE_MESSAGES = {
+  unavailable: "Bound subscription account is unavailable",
+  "not-found": "Bound subscription account was not found",
+  disabled: "Bound subscription account is disabled",
+  unhealthy: "Bound subscription account is unhealthy",
+  "model-incompatible": "Bound subscription account cannot serve the requested model",
+  "allowance-paused": "Bound subscription account is paused by the allowance policy",
+  "empty-token": "Bound subscription account has no usable token"
+};
+function boundAccountSelectionMessage(reason) {
+  return FAILURE_MESSAGES[reason];
+}
+var BoundAccountSelectionError = class extends Error {
+  constructor(providerId, reason, resumeAt) {
+    super(boundAccountSelectionMessage(reason));
+    this.providerId = providerId;
+    this.reason = reason;
+    this.resumeAt = resumeAt;
+    this.name = "BoundAccountSelectionError";
+    this.status = reason === "allowance-paused" ? 429 : 503;
+  }
+  providerId;
+  reason;
+  resumeAt;
+  code = "bound_account_unavailable";
+  status;
+};
+function isBoundAccountSelectionError(error) {
+  if (error instanceof BoundAccountSelectionError) return true;
+  if (!error || typeof error !== "object") return false;
+  const value = error;
+  return value.code === "bound_account_unavailable" && (value.status === 429 || value.status === 503) && typeof value.reason === "string" && Object.prototype.hasOwnProperty.call(FAILURE_MESSAGES, value.reason);
+}
+
+export {
+  boundAccountSelectionMessage,
+  BoundAccountSelectionError,
+  isBoundAccountSelectionError
+};

package/dist/chunk-2Z4XM3H5.cjs

@@ -0,0 +1,44 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkOXHNSZ53cjs = require('./chunk-OXHNSZ53.cjs');
+
+
+var _chunkV4TXMEJScjs = require('./chunk-V4TXMEJS.cjs');
+
+
+var _chunkOVQBNVSVcjs = require('./chunk-OVQBNVSV.cjs');
+
+
+var _chunkOF3BECU2cjs = require('./chunk-OF3BECU2.cjs');
+
+
+var _chunkOKMJLEXXcjs = require('./chunk-OKMJLEXX.cjs');
+
+// src/transformer/transformers/index.ts
+var BuiltinTransformers = {
+  OpenAITransformer: _chunkOF3BECU2cjs.OpenAITransformer,
+  GeminiTransformer: _chunkV4TXMEJScjs.GeminiTransformer,
+  GeminiCodeAssistTransformer: _chunkOKMJLEXXcjs.GeminiCodeAssistTransformer,
+  AnthropicTransformer: _chunkOXHNSZ53cjs.AnthropicTransformer,
+  OpenAIResponseTransformer: _chunkOVQBNVSVcjs.OpenAIResponseTransformer
+};
+function getBuiltinTransformers() {
+  return BuiltinTransformers;
+}
+var BUILTIN_TRANSFORMER_NAMES = [
+  "openai",
+  "gemini",
+  "gemini-code-assist",
+  "anthropic",
+  "openai-response"
+];
+async function registerBuiltinTransformers(service) {
+  await service.initialize(getBuiltinTransformers());
+}
+
+
+
+
+
+
+exports.BuiltinTransformers = BuiltinTransformers; exports.getBuiltinTransformers = getBuiltinTransformers; exports.BUILTIN_TRANSFORMER_NAMES = BUILTIN_TRANSFORMER_NAMES; exports.registerBuiltinTransformers = registerBuiltinTransformers;