@omnicross/core 0.1.5 → 0.1.7

package/dist/chunk-J3QQ6JS5.cjs

@@ -0,0 +1,170 @@
+"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) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) {
+    const parts = [];
+    for (const item of value) {
+      const text = flattenMatchText(item);
+      if (text) parts.push(text);
+    }
+    return parts.join("\n");
+  }
+  if (value && typeof value === "object") {
+    const obj = value;
+    if (obj.type === "tool_result" && obj.content !== void 0) {
+      return flattenMatchText(obj.content);
+    }
+    if (typeof obj.text === "string") return obj.text;
+  }
+  return "";
+}
+function collectMatchText(anthropicBody) {
+  const messages = Array.isArray(anthropicBody.messages) ? anthropicBody.messages : [];
+  const slices = [];
+  const sys = flattenMatchText(anthropicBody.system).trim();
+  if (sys) slices.push(sys.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+  const recent = [];
+  for (let i = messages.length - 1; i >= 0 && recent.length < MATCH_TEXT_RECENT_MESSAGES; i--) {
+    const message = messages[i];
+    if (!message || typeof message !== "object") continue;
+    const role = message.role;
+    if (role !== "user" && role !== "system") continue;
+    const text = flattenMatchText(message.content).trim();
+    if (text) recent.push(text.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+  }
+  for (let i = recent.length - 1; i >= 0; i--) slices.push(recent[i]);
+  return slices;
+}
+function deriveSubscriptionSessionKey(anthropicBody) {
+  const system = flattenMatchText(anthropicBody.system).trim().slice(0, MATCH_TEXT_PER_MESSAGE_CAP);
+  const messages = Array.isArray(anthropicBody.messages) ? anthropicBody.messages : [];
+  let firstUser = "";
+  for (const message of messages) {
+    if (message && typeof message === "object" && message.role === "user") {
+      firstUser = flattenMatchText(message.content).trim().slice(0, MATCH_TEXT_PER_MESSAGE_CAP);
+      break;
+    }
+  }
+  const anchor = `${system}\0${firstUser}`;
+  if (!system && !firstUser) return void 0;
+  return fnv1a(anchor);
+}
+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: stableSessionDigest(sessionHeader), source: "session-header" };
+  }
+  const threadHeader = firstHeaderValue(headers, ["thread-id", "thread_id", "x-thread-id"]);
+  if (threadHeader) {
+    return { key: stableSessionDigest(threadHeader), source: "thread-header" };
+  }
+  const bodySessionId = scalarSessionValue(body.session_id);
+  if (bodySessionId) {
+    return { key: stableSessionDigest(bodySessionId), source: "body-session-id" };
+  }
+  const bodyThreadId = scalarSessionValue(_nullishCoalesce(body.thread_id, () => ( body.threadId)));
+  if (bodyThreadId) {
+    return { key: stableSessionDigest(bodyThreadId), source: "body-thread-id" };
+  }
+  const conversationId = scalarSessionValue(body.conversation_id);
+  if (conversationId) {
+    return { key: stableSessionDigest(conversationId), source: "body-session-id" };
+  }
+  const promptCacheKey = scalarSessionValue(body.prompt_cache_key);
+  if (promptCacheKey) {
+    return { key: stableSessionDigest(promptCacheKey), source: "prompt-cache-key" };
+  }
+  const fingerprint = deriveResponsesContentFingerprint(body);
+  if (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: 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)) {
+    if (typeof value === "string" || Array.isArray(value)) {
+      const lower = name.toLowerCase();
+      if (!byLower.has(lower)) byLower.set(lower, value);
+    }
+  }
+  for (const name of names) {
+    const value = byLower.get(name);
+    const values = Array.isArray(value) ? value : [value];
+    for (const item of values) {
+      if (typeof item !== "string") continue;
+      const trimmed = item.trim();
+      if (trimmed) return trimmed.slice(0, SESSION_ID_CAP);
+    }
+  }
+  return void 0;
+}
+function scalarSessionValue(value) {
+  if (typeof value !== "string" && typeof value !== "number") return void 0;
+  const trimmed = String(value).trim();
+  return trimmed ? trimmed.slice(0, SESSION_ID_CAP) : void 0;
+}
+function deriveResponsesContentFingerprint(body) {
+  const stable = [];
+  const instructions = flattenMatchText(body.instructions).trim();
+  if (instructions) stable.push(instructions.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+  const input = body.input;
+  let firstUser = "";
+  const visitItem = (item) => {
+    if (typeof item === "string") {
+      if (!firstUser) firstUser = item.trim().slice(0, MATCH_TEXT_PER_MESSAGE_CAP);
+      return;
+    }
+    if (!item || typeof item !== "object") return;
+    const record = item;
+    const role = typeof record.role === "string" ? record.role.toLowerCase() : "";
+    const content = _nullishCoalesce(_nullishCoalesce(record.content, () => ( record.text)), () => ( record.input));
+    const text = flattenMatchText(content !== void 0 ? content : record).trim();
+    if (!text) return;
+    if (role === "developer" || role === "system") {
+      stable.push(text.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+    } else if (role === "user" || !role) {
+      if (!firstUser) firstUser = text.slice(0, MATCH_TEXT_PER_MESSAGE_CAP);
+    }
+  };
+  if (Array.isArray(input)) {
+    for (const item of input) visitItem(item);
+  } else if (input !== void 0) {
+    visitItem(input);
+  }
+  if (stable.length === 0) {
+    const legacySystem = flattenMatchText(body.system).trim();
+    if (legacySystem) stable.push(legacySystem.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+  }
+  if (stable.length === 0 && !firstUser) return void 0;
+  return `${stable.join("\0")}\0${firstUser}`;
+}
+function fnv1a(str) {
+  let h = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+
+
+
+
+
+
+
+
+exports.MATCH_TEXT_PER_MESSAGE_CAP = MATCH_TEXT_PER_MESSAGE_CAP; exports.MATCH_TEXT_RECENT_MESSAGES = MATCH_TEXT_RECENT_MESSAGES; exports.flattenMatchText = flattenMatchText; exports.collectMatchText = collectMatchText; exports.deriveSubscriptionSessionKey = deriveSubscriptionSessionKey; exports.deriveGatewaySessionKey = deriveGatewaySessionKey;

package/dist/{chunk-JWVTXXPX.cjs → chunk-KBM2W6UY.cjs}

@@ -792,6 +792,9 @@ function buildRequestBody(request) {
     }
   });
   const generationConfig = {};
+  if (request.max_tokens !== void 0) {
+    generationConfig.maxOutputTokens = request.max_tokens;
+  }
   if (_optionalChain([request, 'access', _117 => _117.reasoning, 'optionalAccess', _118 => _118.effort]) && request.reasoning.effort !== "none") {
     generationConfig.thinkingConfig = {
       includeThoughts: true
@@ -843,7 +846,8 @@ function transformRequestOut(request) {
   const contents = request.contents;
   const tools = request.tools;
   const model = request.model;
-  const maxTokens = request.max_tokens;
+  const generationConfig = request.generationConfig;
+  const maxTokens = _nullishCoalesce(_optionalChain([generationConfig, 'optionalAccess', _122 => _122.maxOutputTokens]), () => ( request.max_tokens));
   const temperature = request.temperature;
   const stream = request.stream;
   const toolChoice = request.tool_choice;
@@ -893,14 +897,14 @@ function transformRequestOut(request) {
         } else if ("inlineData" in part || "file_data" in part) {
           const inline = part.inlineData;
           const fileData = part.file_data;
-          if (_optionalChain([inline, 'optionalAccess', _122 => _122.data])) {
+          if (_optionalChain([inline, 'optionalAccess', _123 => _123.data])) {
             const mime = inline.mime_type || "image/png";
             contentParts.push({
               type: "image_url",
               image_url: { url: `data:${mime};base64,${inline.data}` },
               media_type: mime
             });
-          } else if (_optionalChain([fileData, 'optionalAccess', _123 => _123.file_uri])) {
+          } else if (_optionalChain([fileData, 'optionalAccess', _124 => _124.file_uri])) {
             contentParts.push({
               type: "image_url",
               image_url: { url: fileData.file_uri },
@@ -920,7 +924,7 @@ function transformRequestOut(request) {
         const queue = toolCallIdsByName.get(fnName);
         const id = queue && queue.length > 0 ? queue.shift() : `tool_${Math.random().toString(36).substring(2, 15)}`;
         const response = fr.functionResponse.response;
-        const result = _optionalChain([response, 'optionalAccess', _124 => _124.result]);
+        const result = _optionalChain([response, 'optionalAccess', _125 => _125.result]);
         const toolContent = typeof result === "string" ? result : result !== void 0 ? JSON.stringify(result) : response !== void 0 ? JSON.stringify(response) : "";
         unifiedRequest.messages.push({
           role: "tool",

package/dist/chunk-LB6EBS6Y.js

@@ -0,0 +1,69 @@
+// src/transformer/transformers/OpenAITransformer.ts
+var FOREIGN_MESSAGE_KEYS = ["cache_control", "thinking"];
+var FOREIGN_BODY_KEYS = ["meta", "reasoning", "thinking"];
+function normalizeContent(content) {
+  if (!Array.isArray(content)) return content;
+  const cleaned = content.map((block) => {
+    if (block && typeof block === "object" && "cache_control" in block) {
+      const { cache_control: _dropped, ...rest } = block;
+      return rest;
+    }
+    return block;
+  });
+  if (cleaned.length === 1) {
+    const only = cleaned[0];
+    if (only?.type === "text" && typeof only.text === "string") return only.text;
+  }
+  return cleaned;
+}
+var OpenAITransformer = class {
+  static TransformerName = "openai";
+  name = "openai";
+  endPoint = "/v1/chat/completions";
+  logger;
+  /**
+   * Unified → OpenAI Chat Completions.
+   */
+  async transformRequestIn(request, _provider, _context) {
+    const source = request;
+    const out = {};
+    for (const key of Object.keys(source)) {
+      if (FOREIGN_BODY_KEYS.includes(key)) continue;
+      out[key] = source[key];
+    }
+    if (Array.isArray(request.messages)) {
+      out.messages = request.messages.map((message) => {
+        const src = message;
+        const encoded = {};
+        for (const key of Object.keys(src)) {
+          if (FOREIGN_MESSAGE_KEYS.includes(key)) continue;
+          encoded[key] = src[key];
+        }
+        if (message.content !== void 0) {
+          encoded.content = normalizeContent(message.content);
+        }
+        const thinkingContent = message.thinking?.content;
+        if (typeof thinkingContent === "string" && thinkingContent.length > 0) {
+          encoded.reasoning_content = thinkingContent;
+        }
+        return encoded;
+      });
+    }
+    const effort = request.reasoning?.effort;
+    if (typeof effort === "string" && effort !== "none") {
+      out.reasoning_effort = effort;
+    }
+    return out;
+  }
+  /**
+   * OpenAI Chat Completions → Unified. Identity — see the module JSDoc for why
+   * `reasoning_content` is NOT rewritten here.
+   */
+  async transformResponseOut(response, _context) {
+    return response;
+  }
+};
+
+export {
+  OpenAITransformer
+};

package/dist/{chunk-IWQAX3CS.js → chunk-LVUCAWMK.js}

@@ -3,7 +3,7 @@ import {
   transformRequestOut,
   transformResponseIn,
   transformResponseOut
-} from "./chunk-6QZGDLL4.js";
+} from "./chunk-TOVPMMHM.js";
 
 // src/transformer/transformers/GeminiTransformer.ts
 var GeminiTransformer = class {

package/dist/chunk-MKF46GNZ.js

@@ -0,0 +1,350 @@
+// src/pipeline/AccountAllowanceStore.ts
+var DEFAULT_CODEX_ALLOWANCE_FRESH_MS = 15 * 6e4;
+var DEFAULT_ALLOWANCE_MAX_SNAPSHOTS = 256;
+var MAX_WINDOWS_PER_SNAPSHOT = 8;
+var MAX_TEXT_LENGTH = 200;
+function snapshotKey(providerId, accountId) {
+  return `${providerId}\0${accountId}`;
+}
+function cloneWindow(window) {
+  return {
+    id: window.id,
+    label: window.label,
+    scope: window.scope,
+    ...window.modelFamily === void 0 ? {} : { modelFamily: window.modelFamily },
+    usedPercent: window.usedPercent,
+    ...window.windowMinutes === void 0 ? {} : { windowMinutes: window.windowMinutes },
+    ...window.resetsAt === void 0 ? {} : { resetsAt: window.resetsAt },
+    ...window.remainingSeconds === void 0 ? {} : { remainingSeconds: window.remainingSeconds },
+    state: window.state
+  };
+}
+function cloneSnapshot(snapshot) {
+  return {
+    providerId: snapshot.providerId,
+    accountId: snapshot.accountId,
+    source: snapshot.source,
+    observedAt: snapshot.observedAt,
+    ...snapshot.expiresAt === void 0 ? {} : { expiresAt: snapshot.expiresAt },
+    windows: snapshot.windows.map(cloneWindow),
+    ...snapshot.lastErrorCode === void 0 ? {} : { lastErrorCode: snapshot.lastErrorCode },
+    ...snapshot.primaryOverSecondaryLimitPercent === void 0 ? {} : { primaryOverSecondaryLimitPercent: snapshot.primaryOverSecondaryLimitPercent }
+  };
+}
+function finiteNumber(value) {
+  if (value === null || value === void 0 || value === "") return void 0;
+  const parsed = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : void 0;
+}
+function boundedText(value, max = MAX_TEXT_LENGTH) {
+  return typeof value === "string" && value.length > 0 && value.length <= max ? value : void 0;
+}
+function finitePercent(value) {
+  if (value === null) return null;
+  if (value === void 0 || value === "") return void 0;
+  const parsed = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 && parsed <= 100 ? parsed : void 0;
+}
+function finiteNonNegativeInteger(value) {
+  const parsed = finiteNumber(value);
+  return parsed === void 0 ? void 0 : Math.floor(parsed);
+}
+function normalizedInstant(value) {
+  if (typeof value !== "string" || !value.trim()) return void 0;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? new Date(parsed).toISOString() : void 0;
+}
+function isAllowanceProvider(value) {
+  return value === "claude" || value === "codex" || value === "gemini" || value === "opencodego";
+}
+function isWindowState(value) {
+  return value === "fresh" || value === "stale" || value === "unavailable" || value === "unsupported";
+}
+function normalizeAccountAllowanceSnapshot(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const raw = value;
+  const providerId = raw.providerId;
+  const accountId = boundedText(raw.accountId);
+  const source = raw.source;
+  const observedAt = normalizedInstant(raw.observedAt);
+  if (!isAllowanceProvider(providerId) || !accountId || source !== "oauth-usage-api" && source !== "response-headers" || !observedAt || !Array.isArray(raw.windows) || raw.windows.length > MAX_WINDOWS_PER_SNAPSHOT) return null;
+  const windows = [];
+  for (const item of raw.windows) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return null;
+    const window = item;
+    const id = boundedText(window.id);
+    const label = boundedText(window.label);
+    const scope = window.scope;
+    const state = window.state;
+    const usedPercent = finitePercent(window.usedPercent);
+    if (!id || !label || scope !== "all" && scope !== "model-family" || !isWindowState(state) || window.usedPercent !== void 0 && usedPercent === void 0) return null;
+    const modelFamily = boundedText(window.modelFamily, 80);
+    if (scope === "model-family" && !modelFamily) return null;
+    const windowMinutes = window.windowMinutes === void 0 ? void 0 : finiteNonNegativeInteger(window.windowMinutes);
+    const remainingSeconds2 = window.remainingSeconds === void 0 ? void 0 : finiteNonNegativeInteger(window.remainingSeconds);
+    if (window.windowMinutes !== void 0 && windowMinutes === void 0 || window.remainingSeconds !== void 0 && remainingSeconds2 === void 0) return null;
+    const resetsAt = window.resetsAt === void 0 ? void 0 : normalizedInstant(window.resetsAt);
+    if (window.resetsAt !== void 0 && !resetsAt) return null;
+    windows.push({
+      id,
+      label,
+      scope,
+      ...scope === "model-family" ? { modelFamily } : {},
+      usedPercent: usedPercent ?? null,
+      ...windowMinutes === void 0 ? {} : { windowMinutes },
+      ...resetsAt === void 0 ? {} : { resetsAt },
+      ...remainingSeconds2 === void 0 ? {} : { remainingSeconds: remainingSeconds2 },
+      state
+    });
+  }
+  const expiresAt = raw.expiresAt === void 0 ? void 0 : normalizedInstant(raw.expiresAt);
+  if (raw.expiresAt !== void 0 && !expiresAt) return null;
+  const lastErrorCode = raw.lastErrorCode === void 0 ? void 0 : typeof raw.lastErrorCode === "string" && /^[a-z0-9][a-z0-9_.-]{0,63}$/.test(raw.lastErrorCode) ? raw.lastErrorCode : void 0;
+  if (raw.lastErrorCode !== void 0 && lastErrorCode === void 0) return null;
+  let primaryOverSecondaryLimitPercent;
+  if (raw.primaryOverSecondaryLimitPercent !== void 0) {
+    if (raw.primaryOverSecondaryLimitPercent === null) return null;
+    const parsed = finitePercent(raw.primaryOverSecondaryLimitPercent);
+    if (parsed === void 0 || parsed === null) return null;
+    primaryOverSecondaryLimitPercent = parsed;
+  }
+  return {
+    providerId,
+    accountId,
+    source,
+    observedAt,
+    ...expiresAt === void 0 ? {} : { expiresAt },
+    windows,
+    ...lastErrorCode === void 0 ? {} : { lastErrorCode },
+    ...primaryOverSecondaryLimitPercent === void 0 ? {} : { primaryOverSecondaryLimitPercent }
+  };
+}
+function headerValue(headers, name) {
+  const getter = headers.get;
+  if (typeof getter === "function") return getter.call(headers, name);
+  const record = headers;
+  const wanted = name.toLowerCase();
+  for (const [key, value] of Object.entries(record)) {
+    if (key.toLowerCase() !== wanted) continue;
+    return Array.isArray(value) ? value[0] : value;
+  }
+  return void 0;
+}
+function parseWindow(headers, prefix) {
+  const usedPercent = finitePercent(headerValue(headers, `x-codex-${prefix}-used-percent`)) ?? void 0;
+  const resetAfterSeconds = finiteNumber(
+    headerValue(headers, `x-codex-${prefix}-reset-after-seconds`)
+  );
+  const windowMinutes = finiteNumber(headerValue(headers, `x-codex-${prefix}-window-minutes`));
+  if (usedPercent === void 0 && resetAfterSeconds === void 0 && windowMinutes === void 0) {
+    return void 0;
+  }
+  return { usedPercent, resetAfterSeconds, windowMinutes };
+}
+function parseCodexAllowanceHeaders(headers) {
+  const primary = parseWindow(headers, "primary");
+  const secondary = parseWindow(headers, "secondary");
+  const primaryOverSecondaryLimitPercent = finitePercent(
+    headerValue(headers, "x-codex-primary-over-secondary-limit-percent")
+  ) ?? void 0;
+  if (!primary && !secondary && primaryOverSecondaryLimitPercent === void 0) return null;
+  return { primary, secondary, primaryOverSecondaryLimitPercent };
+}
+function durationLabel(minutes) {
+  if (minutes === void 0) return void 0;
+  if (minutes % (7 * 24 * 60) === 0) {
+    const weeks = minutes / (7 * 24 * 60);
+    return `${weeks} week${weeks === 1 ? "" : "s"}`;
+  }
+  if (minutes % (24 * 60) === 0) {
+    const days = minutes / (24 * 60);
+    return `${days} day${days === 1 ? "" : "s"}`;
+  }
+  if (minutes % 60 === 0) {
+    const hours = minutes / 60;
+    return `${hours} hour${hours === 1 ? "" : "s"}`;
+  }
+  return `${minutes} minutes`;
+}
+function codexLabel(id, minutes) {
+  const base = id === "primary" ? "Primary" : "Secondary";
+  const duration = durationLabel(minutes);
+  return duration ? `${base} \xB7 ${duration}` : base;
+}
+function resetAt(observedMs, seconds) {
+  if (seconds === void 0) return void 0;
+  return new Date(observedMs + seconds * 1e3).toISOString();
+}
+function remainingSeconds(resetsAt, now) {
+  if (!resetsAt) return void 0;
+  const resetMs = Date.parse(resetsAt);
+  if (!Number.isFinite(resetMs)) return void 0;
+  return Math.max(0, Math.floor((resetMs - now) / 1e3));
+}
+function mergeCodexWindow(id, observation, existing, observedMs) {
+  const windowMinutes = observation?.windowMinutes ?? existing?.windowMinutes;
+  const nextResetAt = observation?.resetAfterSeconds !== void 0 ? resetAt(observedMs, observation.resetAfterSeconds) : existing?.resetsAt;
+  const hasExistingData = !!existing && (existing.usedPercent !== null || existing.windowMinutes !== void 0 || existing.resetsAt !== void 0);
+  return {
+    id,
+    label: codexLabel(id, windowMinutes),
+    scope: "all",
+    usedPercent: observation?.usedPercent ?? existing?.usedPercent ?? null,
+    windowMinutes,
+    resetsAt: nextResetAt,
+    remainingSeconds: remainingSeconds(nextResetAt, observedMs),
+    state: observation ? "fresh" : hasExistingData ? "stale" : "unavailable"
+  };
+}
+function projectSnapshot(snapshot, now) {
+  const expiredAt = snapshot.expiresAt ? Date.parse(snapshot.expiresAt) : Number.POSITIVE_INFINITY;
+  const expired = Number.isFinite(expiredAt) && expiredAt <= now;
+  return {
+    ...snapshot,
+    windows: snapshot.windows.map((window) => ({
+      ...window,
+      state: expired && window.state === "fresh" ? "stale" : window.state,
+      remainingSeconds: remainingSeconds(window.resetsAt, now)
+    }))
+  };
+}
+var AccountAllowanceStore = class {
+  constructor(now = Date.now, codexFreshMs = DEFAULT_CODEX_ALLOWANCE_FRESH_MS, persistence, maxSnapshots = DEFAULT_ALLOWANCE_MAX_SNAPSHOTS) {
+    this.now = now;
+    this.codexFreshMs = codexFreshMs;
+    this.persistence = persistence;
+    this.maxSnapshots = Number.isFinite(maxSnapshots) && maxSnapshots > 0 ? Math.floor(maxSnapshots) : DEFAULT_ALLOWANCE_MAX_SNAPSHOTS;
+    this.loadPersisted();
+  }
+  now;
+  codexFreshMs;
+  persistence;
+  snapshots = /* @__PURE__ */ new Map();
+  maxSnapshots;
+  set(snapshot) {
+    const normalized = normalizeAccountAllowanceSnapshot(snapshot);
+    if (!normalized) return;
+    this.snapshots.set(
+      snapshotKey(normalized.providerId, normalized.accountId),
+      normalized
+    );
+    while (this.snapshots.size > this.maxSnapshots) {
+      const oldest = this.snapshots.keys().next().value;
+      if (oldest === void 0) break;
+      this.snapshots.delete(oldest);
+    }
+    this.persist();
+  }
+  delete(providerId, accountId) {
+    if (this.snapshots.delete(snapshotKey(providerId, accountId))) this.persist();
+  }
+  /** Remove rows that no longer correspond to a configured account. */
+  pruneToKnownAccounts(accounts) {
+    const known = /* @__PURE__ */ new Set();
+    for (const account of accounts) {
+      if (account.accountId) known.add(snapshotKey(account.providerId, account.accountId));
+    }
+    let removed = 0;
+    for (const key of this.snapshots.keys()) {
+      if (!known.has(key)) {
+        this.snapshots.delete(key);
+        removed += 1;
+      }
+    }
+    if (removed > 0) this.persist();
+    return removed;
+  }
+  get(providerId, accountId, now = this.now()) {
+    const snapshot = this.snapshots.get(snapshotKey(providerId, accountId));
+    return snapshot ? projectSnapshot(cloneSnapshot(snapshot), now) : null;
+  }
+  list(filter = {}, now = this.now()) {
+    const out = [];
+    for (const snapshot of this.snapshots.values()) {
+      if (filter.providerId && snapshot.providerId !== filter.providerId) continue;
+      if (filter.accountId && snapshot.accountId !== filter.accountId) continue;
+      out.push(projectSnapshot(cloneSnapshot(snapshot), now));
+    }
+    return out.sort(
+      (a, b) => a.providerId.localeCompare(b.providerId) || a.accountId.localeCompare(b.accountId)
+    );
+  }
+  /**
+   * Merge one real Codex upstream response into the selected account's snapshot.
+   * A response with no recognized headers is a strict no-op, and a partial header
+   * set preserves previous values while marking untouched windows stale.
+   */
+  recordCodexHeaders(accountId, headers, observedMs = this.now()) {
+    if (!accountId) return null;
+    const observation = parseCodexAllowanceHeaders(headers);
+    if (!observation) return this.get("codex", accountId, observedMs);
+    const previous = this.snapshots.get(snapshotKey("codex", accountId));
+    const previousPrimary = previous?.source === "response-headers" ? previous.windows.find((window) => window.id === "primary") : void 0;
+    const previousSecondary = previous?.source === "response-headers" ? previous.windows.find((window) => window.id === "secondary") : void 0;
+    const observedAt = new Date(observedMs).toISOString();
+    const snapshot = {
+      providerId: "codex",
+      accountId,
+      source: "response-headers",
+      observedAt,
+      expiresAt: new Date(observedMs + this.codexFreshMs).toISOString(),
+      windows: [
+        mergeCodexWindow("primary", observation.primary, previousPrimary, observedMs),
+        mergeCodexWindow("secondary", observation.secondary, previousSecondary, observedMs)
+      ],
+      primaryOverSecondaryLimitPercent: observation.primaryOverSecondaryLimitPercent ?? previous?.primaryOverSecondaryLimitPercent
+    };
+    this.set(snapshot);
+    return this.get("codex", accountId, observedMs);
+  }
+  clear() {
+    if (this.snapshots.size === 0) return;
+    this.snapshots.clear();
+    this.persist();
+  }
+  loadPersisted() {
+    if (!this.persistence) return;
+    let payload;
+    try {
+      payload = this.persistence.load();
+    } catch {
+      return;
+    }
+    if (!Array.isArray(payload)) return;
+    for (const value of payload) {
+      const snapshot = normalizeAccountAllowanceSnapshot(value);
+      if (!snapshot) continue;
+      this.snapshots.set(snapshotKey(snapshot.providerId, snapshot.accountId), snapshot);
+      if (this.snapshots.size >= this.maxSnapshots) break;
+    }
+  }
+  persist() {
+    if (!this.persistence) return;
+    try {
+      this.persistence.save(Array.from(this.snapshots.values(), cloneSnapshot));
+    } catch {
+    }
+  }
+};
+var sharedAllowanceStore = null;
+function getSharedAccountAllowanceStore() {
+  if (!sharedAllowanceStore) sharedAllowanceStore = new AccountAllowanceStore();
+  return sharedAllowanceStore;
+}
+function setSharedAccountAllowanceStore(store) {
+  sharedAllowanceStore = store;
+}
+function __resetSharedAccountAllowanceStoreForTests() {
+  sharedAllowanceStore = null;
+}
+
+export {
+  DEFAULT_CODEX_ALLOWANCE_FRESH_MS,
+  DEFAULT_ALLOWANCE_MAX_SNAPSHOTS,
+  normalizeAccountAllowanceSnapshot,
+  parseCodexAllowanceHeaders,
+  AccountAllowanceStore,
+  getSharedAccountAllowanceStore,
+  setSharedAccountAllowanceStore,
+  __resetSharedAccountAllowanceStoreForTests
+};

package/dist/{chunk-HYN75H6G.cjs → chunk-MUHWHQVM.cjs}

@@ -28,7 +28,7 @@ async function executeProviderCall(ctx) {
   }
   const fetched = await fetchFn(url, headers, finalBody);
   let response = fetched;
-  if (runResponseChain) {
+  if (runResponseChain && fetched.ok) {
     response = await executor.executeResponseChain(
       // Preserve the EXACT first arg each site passed: proxy → requestBody,
       // unified ingresses → their pre-transform request. The caller supplies