@omnicross/core 0.1.5 → 0.1.7

package/dist/{chunk-UHGVBFU3.js → chunk-EBLFCNPY.js}

@@ -89,18 +89,6 @@ function validateEndpointModelConfig(config) {
     (kind) => !isNonBlankRef(map[kind])
   );
 }
-function validateServerModelConfig(config) {
-  const errors = [];
-  for (const endpoint of Object.keys(ENDPOINT_MODEL_KINDS)) {
-    const ep = config.endpoints.find((e) => e.endpoint === endpoint);
-    const declared = modelKindsForEndpoint(endpoint);
-    const missingKinds = ep ? validateEndpointModelConfig(ep) : [...declared];
-    if (missingKinds.length > 0 && missingKinds.length < declared.length) {
-      errors.push({ endpoint, missingKinds });
-    }
-  }
-  return errors;
-}
 
 // src/outbound-api/modelPrefixDispatch.ts
 function classifyModelPrefix(model) {
@@ -149,6 +137,34 @@ function endpointSupportsSubscription(endpoint) {
 }
 
 // src/outbound-api/routeResolver.ts
+function bindDelegatedSubscriptionProfile(profile, config) {
+  const preferredAccountId = config.boundAccountId;
+  const preferredAccountGroup = config.boundAccountGroup;
+  const boundAccountFallbackPolicy = config.boundAccountFallbackPolicy;
+  if (!preferredAccountId && !preferredAccountGroup) return profile;
+  const strategy = profile.authStrategy;
+  return {
+    ...profile,
+    authStrategy: {
+      kind: strategy.kind,
+      providerId: strategy.providerId,
+      applyHeaders(headers, hints) {
+        return strategy.applyHeaders(headers, {
+          ...hints,
+          preferredAccountId,
+          preferredAccountGroup,
+          boundAccountFallbackPolicy
+        });
+      },
+      onUnauthorized(sessionKey) {
+        return strategy.onUnauthorized(sessionKey);
+      },
+      describeStatus() {
+        return strategy.describeStatus();
+      }
+    }
+  };
+}
 function parseModelRef(ref) {
   if (!ref) return null;
   const idx = ref.indexOf(",");
@@ -267,6 +283,8 @@ async function resolveRoute(args) {
       apiKey: resolveApiKey(provider.api_key),
       isOfficialProvider,
       passThrough: false,
+      preferredKeyId: config.boundKeyId,
+      boundKeyFallbackPolicy: config.boundKeyFallbackPolicy,
       attribution: { sessionId, apiKeyId: args.apiKeyId ?? null }
     };
   }
@@ -277,6 +295,8 @@ async function resolveRoute(args) {
     ingressFormat,
     authMode: "byo",
     providerId,
+    preferredKeyId: config.boundKeyId,
+    boundKeyFallbackPolicy: config.boundKeyFallbackPolicy,
     // Passthrough gate: the client's ORIGINAL requested id (kind-mapped only).
     requestedModel,
     // Usage attribution: the verified named-key id (undefined for internal traffic).
@@ -321,7 +341,10 @@ async function resolveSubscriptionRoute(args) {
     apiKey: "",
     isOfficialProvider: false,
     passThrough: false,
-    subscriptionProfile: profile,
+    subscriptionProfile: bindDelegatedSubscriptionProfile(profile, config),
+    preferredAccountId: config.boundAccountId,
+    preferredAccountGroup: config.boundAccountGroup,
+    boundAccountFallbackPolicy: config.boundAccountFallbackPolicy,
     attribution: { sessionId, apiKeyId: apiKeyId ?? null }
   };
   const subscriptionConfig = providerId === "opencodego" ? await registry?.getOpenCodeGoConfig?.() : void 0;
@@ -353,6 +376,8 @@ async function resolveSubscriptionRoute(args) {
     subscriptionConfig,
     // Per-request preferred account (provider/subscription duality); undefined ⇒ pool.
     preferredAccountId: config.boundAccountId,
+    preferredAccountGroup: config.boundAccountGroup,
+    boundAccountFallbackPolicy: config.boundAccountFallbackPolicy,
     anthropicSdkHints: hints
   };
   return { ok: true, route, usedRole: effectiveRole };
@@ -373,7 +398,6 @@ export {
   modelKindsForEndpoint,
   detectModelKind,
   validateEndpointModelConfig,
-  validateServerModelConfig,
   classifyModelPrefix,
   resolvePrefixTarget,
   SUBSCRIPTION_PROVIDER_IDS,

package/dist/chunk-FU7EAR73.js

@@ -0,0 +1,62 @@
+// src/transformer/transformers/utils/usage-mapping.ts
+function num(obj, key) {
+  const v = obj?.[key];
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+function detailCachedTokens(obj, detailKey) {
+  const detail = obj?.[detailKey];
+  return num(detail, "cached_tokens");
+}
+function anthropicUsageToChatUsage(usage) {
+  if (!usage) return void 0;
+  const input = num(usage, "input_tokens");
+  const output = num(usage, "output_tokens");
+  const cacheRead = num(usage, "cache_read_input_tokens");
+  const cacheCreation = num(usage, "cache_creation_input_tokens");
+  const promptTokens = input + cacheRead + cacheCreation;
+  const out = {
+    prompt_tokens: promptTokens,
+    completion_tokens: output,
+    total_tokens: promptTokens + output
+  };
+  if (cacheRead > 0) {
+    out.prompt_tokens_details = { cached_tokens: cacheRead };
+  }
+  return out;
+}
+function chatUsageToResponsesUsage(usage) {
+  if (!usage) return void 0;
+  const prompt = num(usage, "prompt_tokens");
+  const completion = num(usage, "completion_tokens");
+  const out = {
+    input_tokens: prompt,
+    output_tokens: completion,
+    total_tokens: num(usage, "total_tokens") || prompt + completion
+  };
+  const cacheRead = detailCachedTokens(usage, "prompt_tokens_details");
+  if (cacheRead > 0) {
+    out.input_tokens_details = { cached_tokens: cacheRead };
+  }
+  return out;
+}
+function responsesUsageToChatUsage(usage) {
+  if (!usage) return void 0;
+  const input = num(usage, "input_tokens");
+  const output = num(usage, "output_tokens");
+  const out = {
+    prompt_tokens: input,
+    completion_tokens: output,
+    total_tokens: num(usage, "total_tokens") || input + output
+  };
+  const cacheRead = detailCachedTokens(usage, "input_tokens_details");
+  if (cacheRead > 0) {
+    out.prompt_tokens_details = { cached_tokens: cacheRead };
+  }
+  return out;
+}
+
+export {
+  anthropicUsageToChatUsage,
+  chatUsageToResponsesUsage,
+  responsesUsageToChatUsage
+};

package/dist/chunk-FXR6N3SR.js

@@ -0,0 +1,323 @@
+// src/usage/pricing-engine.ts
+import {
+  DEFAULT_LITELLM_PRICING_URL,
+  DEFAULT_OPENROUTER_PRICING_URL
+} from "@omnicross/contracts/pricing-types";
+var PricingEngine = class {
+  constructor(store, logger, options = {}) {
+    this.store = store;
+    this.logger = logger;
+    this.options = options;
+  }
+  store;
+  logger;
+  options;
+  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.
+   */
+  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.
+   */
+  fuzzyEntries = [];
+  cacheLoaded = false;
+  /** Coalesce manual and background refreshes to prevent a catalog stampede. */
+  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 = 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 = entry.cacheReadPricePer1m ?? ip;
+    const cwp = 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 = this.options.sourceUrl ?? DEFAULT_LITELLM_PRICING_URL;
+    const openRouterSourceUrl = this.options.openRouterSourceUrl ?? DEFAULT_OPENROUTER_PRICING_URL;
+    const fetchImpl = this.options.fetchImpl ?? fetch;
+    const timeoutMs = 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;
+  }
+};
+var keyOf = (providerId, modelId) => `${providerId}::${modelId}`;
+var normalizeModelId = (modelId) => (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 = entry.litellm_provider ?? "";
+    const providerId = 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 model?.id === "string" ? model.id.trim() : "";
+    const input = parseUnitPrice(model?.pricing?.prompt);
+    const output = parseUnitPrice(model?.pricing?.completion);
+    if (!modelId || input === null || output === null) continue;
+    const cacheRead = parseUnitPrice(model.pricing?.input_cache_read);
+    const cacheWrite = parseUnitPrice(model.pricing?.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);
+  timer.unref?.();
+  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
+  };
+}
+
+export {
+  PricingEngine
+};

package/dist/{chunk-SUEGJ75D.cjs → chunk-GDIXXKF2.cjs}

@@ -59,8 +59,42 @@ function hasThinkingEnabled(request) {
   }
   return false;
 }
+function flattenToolResultContent(content) {
+  if (typeof content === "string") return content;
+  if (content == null) return "";
+  if (!Array.isArray(content)) return JSON.stringify(content);
+  const parts = [];
+  for (const block of content) {
+    if (typeof block === "string") {
+      parts.push(block);
+      continue;
+    }
+    if (!block || typeof block !== "object") continue;
+    const typed = block;
+    if (typed.type === "image" || typed.type === "image_url") {
+      parts.push("[image omitted]");
+    } else if (typeof typed.text === "string") {
+      parts.push(typed.text);
+    }
+  }
+  return parts.filter((text) => text !== "").join("\n");
+}
 
 // src/api-converter/anthropic-to-openai.ts
+function anthropicUsageToChatUsage(usage) {
+  const input = usage.input_tokens || 0;
+  const output = usage.output_tokens || 0;
+  const cacheRead = usage.cache_read_input_tokens || 0;
+  const cacheCreation = usage.cache_creation_input_tokens || 0;
+  const promptTokens = input + cacheRead + cacheCreation;
+  const out = {
+    prompt_tokens: promptTokens,
+    completion_tokens: output,
+    total_tokens: promptTokens + output
+  };
+  if (cacheRead > 0) out.prompt_tokens_details = { cached_tokens: cacheRead };
+  return out;
+}
 function convertAnthropicToOpenAI(response) {
   const content = [];
   const toolCalls = [];
@@ -98,11 +132,7 @@ function convertAnthropicToOpenAI(response) {
         finish_reason: finishReason
       }
     ],
-    usage: {
-      prompt_tokens: response.usage.input_tokens,
-      completion_tokens: response.usage.output_tokens,
-      total_tokens: response.usage.input_tokens + response.usage.output_tokens
-    }
+    usage: anthropicUsageToChatUsage(response.usage)
   };
   if (reasoningContent) {
     result.reasoning_content = reasoningContent;
@@ -158,7 +188,7 @@ function convertAnthropicRequestToOpenAI(request) {
           });
         } else if (part.type === "tool_result") {
           toolResultId = part.tool_use_id;
-          toolResultContent = typeof part.content === "string" ? part.content : JSON.stringify(part.content);
+          toolResultContent = flattenToolResultContent(part.content);
         }
       }
       if (toolResultId && toolResultContent !== void 0) {
@@ -332,11 +362,12 @@ async function* convertAnthropicStreamToOpenAI(anthropicStream) {
                 delta: {},
                 finish_reason: finishReason
               }],
-              usage: event.usage ? {
-                prompt_tokens: event.usage.input_tokens || 0,
-                completion_tokens: event.usage.output_tokens || 0,
-                total_tokens: (event.usage.input_tokens || 0) + (event.usage.output_tokens || 0)
-              } : void 0
+              usage: event.usage ? anthropicUsageToChatUsage({
+                input_tokens: event.usage.input_tokens || 0,
+                output_tokens: event.usage.output_tokens || 0,
+                cache_read_input_tokens: event.usage.cache_read_input_tokens,
+                cache_creation_input_tokens: event.usage.cache_creation_input_tokens
+              }) : void 0
             })}
 
 `;
@@ -368,7 +399,10 @@ function convertOpenAIToAnthropic(request, config) {
       const toolResult = {
         type: "tool_result",
         tool_use_id: msg.tool_call_id,
-        content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+        // An OpenAI tool message is normally a plain string, but a parts array
+        // must be flattened to text rather than stringified into a literal
+        // `[{"type":"text",…}]` envelope the model then has to read.
+        content: flattenToolResultContent(msg.content)
       };
       const lastMsg = messages[messages.length - 1];
       if (lastMsg && lastMsg.role === "user" && Array.isArray(lastMsg.content)) {