@omnicross/core 0.1.6 → 0.1.7

package/dist/{chunk-UX7VWA46.js → chunk-FXR6N3SR.js}

@@ -21,6 +21,15 @@ var PricingEngine = class {
    * 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;
@@ -31,9 +40,11 @@ var PricingEngine = class {
     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;
   }
@@ -53,10 +64,36 @@ var PricingEngine = class {
    *   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();
-    return this.cache.get(keyOf(providerId, modelId)) ?? this.cache.get(keyOf("*", modelId)) ?? this.cacheByModel.get(modelId) ?? null;
+    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 =====
   /**
@@ -187,6 +224,7 @@ var PricingEngine = class {
   }
 };
 var keyOf = (providerId, modelId) => `${providerId}::${modelId}`;
+var normalizeModelId = (modelId) => (modelId ?? "").toLowerCase().replace(/[^a-z0-9]/g, "");
 var PROVIDER_ALIASES = {
   vertex_ai: "gemini",
   google: "gemini",

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

@@ -81,6 +81,20 @@ function flattenToolResultContent(content) {
 }
 
 // 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 = [];
@@ -118,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;
@@ -352,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
             })}
 
 `;

package/dist/{chunk-WB6PH56J.js → chunk-GFIZ6LQI.js}

@@ -1,4 +1,5 @@
 // src/provider-proxy/matchText.ts
+import { createHash } from "crypto";
 var MATCH_TEXT_PER_MESSAGE_CAP = 8192;
 var MATCH_TEXT_RECENT_MESSAGES = 6;
 function flattenMatchText(value) {
@@ -55,39 +56,42 @@ var SESSION_ID_CAP = 1024;
 function deriveGatewaySessionKey(body, headers = {}, options = {}) {
   const sessionHeader = firstHeaderValue(headers, ["session-id", "session_id", "x-session-id"]);
   if (sessionHeader) {
-    return { key: fnv1a(sessionHeader), source: "session-header" };
+    return { key: stableSessionDigest(sessionHeader), source: "session-header" };
   }
   const threadHeader = firstHeaderValue(headers, ["thread-id", "thread_id", "x-thread-id"]);
   if (threadHeader) {
-    return { key: fnv1a(threadHeader), source: "thread-header" };
+    return { key: stableSessionDigest(threadHeader), source: "thread-header" };
   }
   const bodySessionId = scalarSessionValue(body.session_id);
   if (bodySessionId) {
-    return { key: fnv1a(bodySessionId), source: "body-session-id" };
+    return { key: stableSessionDigest(bodySessionId), source: "body-session-id" };
   }
   const bodyThreadId = scalarSessionValue(body.thread_id ?? body.threadId);
   if (bodyThreadId) {
-    return { key: fnv1a(bodyThreadId), source: "body-thread-id" };
+    return { key: stableSessionDigest(bodyThreadId), source: "body-thread-id" };
   }
   const conversationId = scalarSessionValue(body.conversation_id);
   if (conversationId) {
-    return { key: fnv1a(conversationId), source: "body-session-id" };
+    return { key: stableSessionDigest(conversationId), source: "body-session-id" };
   }
   const promptCacheKey = scalarSessionValue(body.prompt_cache_key);
   if (promptCacheKey) {
-    return { key: fnv1a(promptCacheKey), source: "prompt-cache-key" };
+    return { key: stableSessionDigest(promptCacheKey), source: "prompt-cache-key" };
   }
   const fingerprint = deriveResponsesContentFingerprint(body);
   if (fingerprint) {
-    return { key: fnv1a(fingerprint), source: "content-fingerprint" };
+    return { key: stableSessionDigest(fingerprint), source: "content-fingerprint" };
   }
   const endpoint = options.endpoint?.trim() || "responses";
   const fallback = options.fallbackKey?.trim() || "anonymous";
   return {
-    key: fnv1a(`${endpoint}\0${fallback}`),
+    key: stableSessionDigest(`${endpoint}\0${fallback}`),
     source: "api-key-fallback"
   };
 }
+function stableSessionDigest(value) {
+  return createHash("sha256").update(value, "utf8").digest("hex").slice(0, 32);
+}
 function firstHeaderValue(headers, names) {
   const byLower = /* @__PURE__ */ new Map();
   for (const [name, value] of Object.entries(headers)) {

package/dist/chunk-GL6XM527.js

@@ -0,0 +1,61 @@
+// src/pipeline/AccountRouteActivity.ts
+var ACCOUNT_ROUTE_ACTIVITY_LIMIT = 300;
+function boundedLimit(value) {
+  if (!Number.isFinite(value)) return 100;
+  return Math.max(1, Math.min(ACCOUNT_ROUTE_ACTIVITY_LIMIT, Math.trunc(value)));
+}
+var AccountRouteActivityStore = class {
+  records = [];
+  sequence = 0;
+  record(input) {
+    const ts = input.ts ?? Date.now();
+    const sessionKey = input.sessionKey?.trim() || void 0;
+    const previous = sessionKey ? this.records.find((record2) => record2.providerId === input.providerId && record2.endpoint === input.endpoint && record2.sessionKey === sessionKey) : void 0;
+    const affinity = !sessionKey ? "untracked" : !previous ? "new" : previous.accountId === input.accountId ? "sticky" : "switched";
+    const record = {
+      ...input,
+      id: `${ts.toString(36)}-${(this.sequence++).toString(36)}`,
+      ts,
+      sessionKey,
+      affinity,
+      ...affinity === "switched" && previous ? { previousAccountId: previous.accountId } : {}
+    };
+    this.records.unshift(record);
+    if (this.records.length > ACCOUNT_ROUTE_ACTIVITY_LIMIT) {
+      this.records.length = ACCOUNT_ROUTE_ACTIVITY_LIMIT;
+    }
+    return { ...record };
+  }
+  list(query = {}) {
+    const providerId = query.providerId?.trim();
+    const accountId = query.accountId?.trim();
+    const sessionKey = query.sessionKey?.trim();
+    return this.records.filter((record) => !providerId || record.providerId === providerId).filter((record) => !accountId || record.accountId === accountId).filter((record) => !sessionKey || record.sessionKey === sessionKey).slice(0, boundedLimit(query.limit)).map((record) => ({ ...record }));
+  }
+  clear() {
+    this.records.length = 0;
+    this.sequence = 0;
+  }
+  /**
+   * Backfill a field on an already-recorded entry. Used to annotate a record
+   * AFTER the upstream body streams — e.g. a `200` whose SSE body carries a
+   * `response.failed` overload event is only detectable mid-relay, long after
+   * `record()` stamped the 200 status. `patch` is intentionally narrow: only
+   * post-hoc-observable fields belong here, never the routing-decision fields.
+   * No-op when the id has already aged out of the bounded ring.
+   */
+  amend(id, patch) {
+    const record = this.records.find((r) => r.id === id);
+    if (record) Object.assign(record, patch);
+  }
+};
+var sharedAccountRouteActivity = new AccountRouteActivityStore();
+function getSharedAccountRouteActivity() {
+  return sharedAccountRouteActivity;
+}
+
+export {
+  ACCOUNT_ROUTE_ACTIVITY_LIMIT,
+  AccountRouteActivityStore,
+  getSharedAccountRouteActivity
+};

package/dist/{chunk-EJLH6NFT.cjs → chunk-J3QQ6JS5.cjs}

@@ -1,4 +1,5 @@
 "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; }// src/provider-proxy/matchText.ts
+var _crypto = require('crypto');
 var MATCH_TEXT_PER_MESSAGE_CAP = 8192;
 var MATCH_TEXT_RECENT_MESSAGES = 6;
 function flattenMatchText(value) {
@@ -55,39 +56,42 @@ var SESSION_ID_CAP = 1024;
 function deriveGatewaySessionKey(body, headers = {}, options = {}) {
   const sessionHeader = firstHeaderValue(headers, ["session-id", "session_id", "x-session-id"]);
   if (sessionHeader) {
-    return { key: fnv1a(sessionHeader), source: "session-header" };
+    return { key: stableSessionDigest(sessionHeader), source: "session-header" };
   }
   const threadHeader = firstHeaderValue(headers, ["thread-id", "thread_id", "x-thread-id"]);
   if (threadHeader) {
-    return { key: fnv1a(threadHeader), source: "thread-header" };
+    return { key: stableSessionDigest(threadHeader), source: "thread-header" };
   }
   const bodySessionId = scalarSessionValue(body.session_id);
   if (bodySessionId) {
-    return { key: fnv1a(bodySessionId), source: "body-session-id" };
+    return { key: stableSessionDigest(bodySessionId), source: "body-session-id" };
   }
   const bodyThreadId = scalarSessionValue(_nullishCoalesce(body.thread_id, () => ( body.threadId)));
   if (bodyThreadId) {
-    return { key: fnv1a(bodyThreadId), source: "body-thread-id" };
+    return { key: stableSessionDigest(bodyThreadId), source: "body-thread-id" };
   }
   const conversationId = scalarSessionValue(body.conversation_id);
   if (conversationId) {
-    return { key: fnv1a(conversationId), source: "body-session-id" };
+    return { key: stableSessionDigest(conversationId), source: "body-session-id" };
   }
   const promptCacheKey = scalarSessionValue(body.prompt_cache_key);
   if (promptCacheKey) {
-    return { key: fnv1a(promptCacheKey), source: "prompt-cache-key" };
+    return { key: stableSessionDigest(promptCacheKey), source: "prompt-cache-key" };
   }
   const fingerprint = deriveResponsesContentFingerprint(body);
   if (fingerprint) {
-    return { key: fnv1a(fingerprint), source: "content-fingerprint" };
+    return { key: stableSessionDigest(fingerprint), source: "content-fingerprint" };
   }
   const endpoint = _optionalChain([options, 'access', _ => _.endpoint, 'optionalAccess', _2 => _2.trim, 'call', _3 => _3()]) || "responses";
   const fallback = _optionalChain([options, 'access', _4 => _4.fallbackKey, 'optionalAccess', _5 => _5.trim, 'call', _6 => _6()]) || "anonymous";
   return {
-    key: fnv1a(`${endpoint}\0${fallback}`),
+    key: stableSessionDigest(`${endpoint}\0${fallback}`),
     source: "api-key-fallback"
   };
 }
+function stableSessionDigest(value) {
+  return _crypto.createHash.call(void 0, "sha256").update(value, "utf8").digest("hex").slice(0, 32);
+}
 function firstHeaderValue(headers, names) {
   const byLower = /* @__PURE__ */ new Map();
   for (const [name, value] of Object.entries(headers)) {

package/dist/{chunk-VRFBB5DB.js → chunk-MYYR3HZL.js}

@@ -1,15 +1,15 @@
+import {
+  AnthropicTransformer
+} from "./chunk-PEGTIPB3.js";
 import {
   GeminiTransformer
 } from "./chunk-LVUCAWMK.js";
 import {
   OpenAIResponseTransformer
-} from "./chunk-OEWZUX4G.js";
+} from "./chunk-32O35CIF.js";
 import {
   OpenAITransformer
 } from "./chunk-LB6EBS6Y.js";
-import {
-  AnthropicTransformer
-} from "./chunk-6CL5HTPQ.js";
 import {
   GeminiCodeAssistTransformer
 } from "./chunk-N5T4M4GU.js";

package/dist/{chunk-YJVHCHQX.js → chunk-N7OOJI5V.js}

@@ -3,6 +3,7 @@ var OVERLOAD_TTL_MS = 10 * 6e4;
 var OVERLOAD_ENABLED_DEFAULT = true;
 var AUTH_ERROR_TTL_MS = 30 * 6e4;
 var SERVER_ERROR_TTL_MS = 5 * 6e4;
+var MAX_QUOTA_COOLDOWN_MS = 7 * 24 * 60 * 6e4;
 var BAN_BODY_MARKERS = [
   "this organization has been disabled",
   "oauth authentication is currently not allowed"
@@ -38,7 +39,7 @@ function isBanBody(bodyText) {
   return BAN_BODY_MARKERS.some((marker) => lower.includes(marker));
 }
 function isRecordEmpty(record) {
-  return record.rateLimitEndAt === void 0 && record.overloadUntil === void 0 && record.tempUnavailableUntil === void 0 && !record.blocked;
+  return record.rateLimitEndAt === void 0 && record.overloadUntil === void 0 && record.tempUnavailableUntil === void 0 && record.quotaExhaustedUntil === void 0 && !record.blocked;
 }
 var KEY_SEP = "\0";
 var SubscriptionAccountHealth = class {
@@ -159,12 +160,47 @@ var SubscriptionAccountHealth = class {
       this.emitAnomaly(anomaly);
     }
   }
+  /**
+   * Mark an account quota/usage-exhausted until `untilEpochMs` (the Codex weekly
+   * usage-limit wall). Unlike the status-driven timers set by
+   * {@link recordUpstreamOutcome}, this mark is NOT cleared by a 2xx: in-flight
+   * sessions on the same account keep succeeding after the window is exhausted,
+   * so a traffic-driven clear would re-strand every NEW session onto this
+   * account. It excludes the account from NEW-session selection until the
+   * deadline elapses (existing sessions are unaffected — they already hold their
+   * token). Self-heals lazily on read and via {@link sweepRecoveries}.
+   * `untilEpochMs` is clamped to {@link MAX_QUOTA_COOLDOWN_MS}; an already-elapsed
+   * deadline is a no-op. Emits a `quota_exhausted` anomaly on the healthy→
+   * unhealthy edge.
+   */
+  markQuotaExhausted(providerId, accountId, untilEpochMs, now = this.now()) {
+    if (!Number.isFinite(untilEpochMs)) return;
+    const clamped = Math.min(untilEpochMs, now + MAX_QUOTA_COOLDOWN_MS);
+    if (clamped <= now) return;
+    const key = this.key(providerId, accountId);
+    const preExisting = this.records.get(key);
+    const record = preExisting ?? {};
+    const wasUnhealthyBefore = preExisting ? this.isUnhealthyAt(preExisting, now) : false;
+    record.quotaExhaustedUntil = clamped;
+    this.records.set(key, record);
+    if (!wasUnhealthyBefore) {
+      const anomaly = {
+        providerId,
+        accountId,
+        at: now,
+        state: "quota_exhausted"
+      };
+      this.recordDiagnostic({ kind: "health-anomaly", ...anomaly });
+      this.emitAnomaly(anomaly);
+    }
+  }
   /** Whether a record is unhealthy at `now`: blocked, or any timer still future. */
   isUnhealthyAt(record, now) {
     if (record.blocked) return true;
     if (record.rateLimitEndAt !== void 0 && now < record.rateLimitEndAt) return true;
     if (record.overloadUntil !== void 0 && now < record.overloadUntil) return true;
     if (record.tempUnavailableUntil !== void 0 && now < record.tempUnavailableUntil) return true;
+    if (record.quotaExhaustedUntil !== void 0 && now < record.quotaExhaustedUntil) return true;
     return false;
   }
   /**
@@ -201,7 +237,7 @@ var SubscriptionAccountHealth = class {
     const recovered = [];
     for (const [key, record] of this.records) {
       if (record.blocked) continue;
-      const hadTimer = record.rateLimitEndAt !== void 0 || record.overloadUntil !== void 0 || record.tempUnavailableUntil !== void 0;
+      const hadTimer = record.rateLimitEndAt !== void 0 || record.overloadUntil !== void 0 || record.tempUnavailableUntil !== void 0 || record.quotaExhaustedUntil !== void 0;
       const active = this.clearExpired(record, now);
       if (hadTimer && !active && isRecordEmpty(record)) {
         const [pid, aid] = this.parseKey(key);
@@ -225,6 +261,9 @@ var SubscriptionAccountHealth = class {
     const record = this.records.get(this.key(providerId, accountId));
     if (!record) return { state: "healthy" };
     if (record.blocked) return { state: "blocked" };
+    if (record.quotaExhaustedUntil !== void 0 && now < record.quotaExhaustedUntil) {
+      return { state: "quota_exhausted", cooldownUntil: record.quotaExhaustedUntil };
+    }
     if (record.rateLimitEndAt !== void 0 && now < record.rateLimitEndAt) {
       return { state: "rate_limited", cooldownUntil: record.rateLimitEndAt };
     }
@@ -311,6 +350,10 @@ var SubscriptionAccountHealth = class {
       if (now >= record.tempUnavailableUntil) delete record.tempUnavailableUntil;
       else active = true;
     }
+    if (record.quotaExhaustedUntil !== void 0) {
+      if (now >= record.quotaExhaustedUntil) delete record.quotaExhaustedUntil;
+      else active = true;
+    }
     return active;
   }
   key(providerId, accountId) {
@@ -338,6 +381,7 @@ export {
   OVERLOAD_ENABLED_DEFAULT,
   AUTH_ERROR_TTL_MS,
   SERVER_ERROR_TTL_MS,
+  MAX_QUOTA_COOLDOWN_MS,
   ACCOUNT_HEALTH_DIAGNOSTIC_LIMIT,
   resolveResetSeconds,
   SubscriptionAccountHealth,

package/dist/chunk-NKVZ6Z3Y.cjs

@@ -0,0 +1,61 @@
+"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/pipeline/AccountRouteActivity.ts
+var ACCOUNT_ROUTE_ACTIVITY_LIMIT = 300;
+function boundedLimit(value) {
+  if (!Number.isFinite(value)) return 100;
+  return Math.max(1, Math.min(ACCOUNT_ROUTE_ACTIVITY_LIMIT, Math.trunc(value)));
+}
+var AccountRouteActivityStore = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this); }
+  __init() {this.records = []}
+  __init2() {this.sequence = 0}
+  record(input) {
+    const ts = _nullishCoalesce(input.ts, () => ( Date.now()));
+    const sessionKey = _optionalChain([input, 'access', _ => _.sessionKey, 'optionalAccess', _2 => _2.trim, 'call', _3 => _3()]) || void 0;
+    const previous = sessionKey ? this.records.find((record2) => record2.providerId === input.providerId && record2.endpoint === input.endpoint && record2.sessionKey === sessionKey) : void 0;
+    const affinity = !sessionKey ? "untracked" : !previous ? "new" : previous.accountId === input.accountId ? "sticky" : "switched";
+    const record = {
+      ...input,
+      id: `${ts.toString(36)}-${(this.sequence++).toString(36)}`,
+      ts,
+      sessionKey,
+      affinity,
+      ...affinity === "switched" && previous ? { previousAccountId: previous.accountId } : {}
+    };
+    this.records.unshift(record);
+    if (this.records.length > ACCOUNT_ROUTE_ACTIVITY_LIMIT) {
+      this.records.length = ACCOUNT_ROUTE_ACTIVITY_LIMIT;
+    }
+    return { ...record };
+  }
+  list(query = {}) {
+    const providerId = _optionalChain([query, 'access', _4 => _4.providerId, 'optionalAccess', _5 => _5.trim, 'call', _6 => _6()]);
+    const accountId = _optionalChain([query, 'access', _7 => _7.accountId, 'optionalAccess', _8 => _8.trim, 'call', _9 => _9()]);
+    const sessionKey = _optionalChain([query, 'access', _10 => _10.sessionKey, 'optionalAccess', _11 => _11.trim, 'call', _12 => _12()]);
+    return this.records.filter((record) => !providerId || record.providerId === providerId).filter((record) => !accountId || record.accountId === accountId).filter((record) => !sessionKey || record.sessionKey === sessionKey).slice(0, boundedLimit(query.limit)).map((record) => ({ ...record }));
+  }
+  clear() {
+    this.records.length = 0;
+    this.sequence = 0;
+  }
+  /**
+   * Backfill a field on an already-recorded entry. Used to annotate a record
+   * AFTER the upstream body streams — e.g. a `200` whose SSE body carries a
+   * `response.failed` overload event is only detectable mid-relay, long after
+   * `record()` stamped the 200 status. `patch` is intentionally narrow: only
+   * post-hoc-observable fields belong here, never the routing-decision fields.
+   * No-op when the id has already aged out of the bounded ring.
+   */
+  amend(id, patch) {
+    const record = this.records.find((r) => r.id === id);
+    if (record) Object.assign(record, patch);
+  }
+}, _class);
+var sharedAccountRouteActivity = new AccountRouteActivityStore();
+function getSharedAccountRouteActivity() {
+  return sharedAccountRouteActivity;
+}
+
+
+
+
+
+exports.ACCOUNT_ROUTE_ACTIVITY_LIMIT = ACCOUNT_ROUTE_ACTIVITY_LIMIT; exports.AccountRouteActivityStore = AccountRouteActivityStore; exports.getSharedAccountRouteActivity = getSharedAccountRouteActivity;

package/dist/{chunk-SNYBEXLB.cjs → chunk-OJGQKHN5.cjs}

@@ -78,7 +78,9 @@ var UsageRecorder = class {
       costSavedByCacheUsd,
       rawUsage: input.rawUsage != null ? safeStringify(input.rawUsage) : null,
       runId: _nullishCoalesce(input.runId, () => ( null)),
-      eventId: _nullishCoalesce(input.eventId, () => ( null))
+      eventId: _nullishCoalesce(input.eventId, () => ( null)),
+      ...input.cacheKeySource !== void 0 ? { cacheKeySource: input.cacheKeySource } : {},
+      ...input.cacheKeyInjected !== void 0 ? { cacheKeyInjected: input.cacheKeyInjected } : {}
     };
     try {
       return await this.store.insert(row);

package/dist/chunk-OTZC4TNH.cjs

@@ -0,0 +1,79 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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/pipeline/ServerOverloadCounter.ts
+var OVERLOAD_RECENT_LIMIT = 64;
+var OVERLOAD_ENTRY_TTL_MS = 24 * 60 * 6e4;
+function entryKey(providerId, accountId, endpoint) {
+  return `${providerId}\0${accountId}\0${endpoint}`;
+}
+var ServerOverloadCounterStore = (_class = class {constructor() { _class.prototype.__init.call(this); }
+  __init() {this.entries = /* @__PURE__ */ new Map()}
+  /**
+   * Record one overload event. Creates the entry on first sight, then bumps
+   * `count`, `lastTs`, and prepends the event to the bounded `recent` ring.
+   */
+  recordOverload(input, now = Date.now()) {
+    const key = entryKey(input.providerId, input.accountId, input.endpoint);
+    const existing = this.entries.get(key);
+    if (existing) {
+      existing.count += 1;
+      existing.lastTs = now;
+      existing.recent.unshift(now);
+      if (existing.recent.length > OVERLOAD_RECENT_LIMIT) {
+        existing.recent.length = OVERLOAD_RECENT_LIMIT;
+      }
+      return { ...existing, recent: [...existing.recent] };
+    }
+    const entry = {
+      providerId: input.providerId,
+      accountId: input.accountId,
+      endpoint: input.endpoint,
+      count: 1,
+      firstTs: now,
+      lastTs: now,
+      recent: [now]
+    };
+    this.entries.set(key, entry);
+    return { ...entry, recent: [...entry.recent] };
+  }
+  /**
+   * Snapshot all (optionally filtered) entries, pruning stale ones first. Returns
+   * copies — callers (admin API → JSON) never see the live mutable entries.
+   */
+  list(query = {}, now = Date.now()) {
+    const providerId = _optionalChain([query, 'access', _ => _.providerId, 'optionalAccess', _2 => _2.trim, 'call', _3 => _3()]);
+    const accountId = _optionalChain([query, 'access', _4 => _4.accountId, 'optionalAccess', _5 => _5.trim, 'call', _6 => _6()]);
+    const out = [];
+    for (const [key, entry] of this.entries) {
+      if (now - entry.lastTs > OVERLOAD_ENTRY_TTL_MS) {
+        this.entries.delete(key);
+        continue;
+      }
+      if (providerId && entry.providerId !== providerId) continue;
+      if (accountId && entry.accountId !== accountId) continue;
+      out.push({ ...entry, recent: [...entry.recent] });
+    }
+    return out;
+  }
+  clear() {
+    this.entries.clear();
+  }
+}, _class);
+var sharedStore = null;
+function getSharedOverloadCounter() {
+  if (!sharedStore) sharedStore = new ServerOverloadCounterStore();
+  return sharedStore;
+}
+function setSharedOverloadCounter(instance) {
+  sharedStore = instance;
+}
+function __resetSharedOverloadCounterForTests() {
+  sharedStore = null;
+}
+
+
+
+
+
+
+
+
+exports.OVERLOAD_RECENT_LIMIT = OVERLOAD_RECENT_LIMIT; exports.OVERLOAD_ENTRY_TTL_MS = OVERLOAD_ENTRY_TTL_MS; exports.ServerOverloadCounterStore = ServerOverloadCounterStore; exports.getSharedOverloadCounter = getSharedOverloadCounter; exports.setSharedOverloadCounter = setSharedOverloadCounter; exports.__resetSharedOverloadCounterForTests = __resetSharedOverloadCounterForTests;

package/dist/{chunk-6VUQPOV3.cjs → chunk-OVQBNVSV.cjs}

@@ -1,4 +1,9 @@
-"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/transformer/transformers/OpenAIResponseTransformer.ts
+"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 _chunk5RSZYQJHcjs = require('./chunk-5RSZYQJH.cjs');
+
+// src/transformer/transformers/OpenAIResponseTransformer.ts
 var OpenAIResponseTransformer = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this); }
   static __initStatic() {this.TransformerName = "openai-response"}
   __init() {this.name = "openai-response"}
@@ -433,11 +438,7 @@ function convertResponseApiJsonToOpenAI(data) {
         finish_reason: toolCalls.length > 0 ? "tool_calls" : "stop"
       }
     ],
-    usage: usage ? {
-      prompt_tokens: usage.input_tokens || 0,
-      completion_tokens: usage.output_tokens || 0,
-      total_tokens: (usage.input_tokens || 0) + (usage.output_tokens || 0)
-    } : void 0
+    usage: _chunk5RSZYQJHcjs.responsesUsageToChatUsage.call(void 0, usage)
   };
 }
 function convertOpenAIJsonToResponseApi(data, codexTools) {
@@ -475,11 +476,7 @@ function convertOpenAIJsonToResponseApi(data, codexTools) {
     status: "completed",
     model: data.model || "unknown",
     output,
-    usage: usage ? {
-      input_tokens: usage.prompt_tokens || 0,
-      output_tokens: usage.completion_tokens || 0,
-      total_tokens: usage.total_tokens || (usage.prompt_tokens || 0) + (usage.completion_tokens || 0)
-    } : void 0
+    usage: _chunk5RSZYQJHcjs.chatUsageToResponsesUsage.call(void 0, usage)
   };
 }
 function convertResponseApiStreamToOpenAI(responseApiStream) {
@@ -589,11 +586,7 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
                 case "response.completed": {
                   const resp = event.response;
                   const respUsage = _optionalChain([resp, 'optionalAccess', _32 => _32.usage]);
-                  const usage = respUsage ? {
-                    prompt_tokens: respUsage.input_tokens || 0,
-                    completion_tokens: respUsage.output_tokens || 0,
-                    total_tokens: (respUsage.input_tokens || 0) + (respUsage.output_tokens || 0)
-                  } : void 0;
+                  const usage = _chunk5RSZYQJHcjs.responsesUsageToChatUsage.call(void 0, respUsage);
                   emitChunk([{ index: 0, delta: {}, finish_reason: hasToolCalls ? "tool_calls" : "stop" }], usage);
                   safeEnqueue("data: [DONE]\n\n");
                   break;
@@ -801,11 +794,7 @@ function convertOpenAIStreamToResponseApi(openaiStream, codexTools) {
                     status: "completed",
                     model,
                     output,
-                    usage: chunk.usage ? {
-                      input_tokens: chunk.usage.prompt_tokens || 0,
-                      output_tokens: chunk.usage.completion_tokens || 0,
-                      total_tokens: chunk.usage.total_tokens || 0
-                    } : void 0
+                    usage: _chunk5RSZYQJHcjs.chatUsageToResponsesUsage.call(void 0, chunk.usage)
                   }
                 });
               }