@omnicross/core 0.1.5 → 0.1.6

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

package/dist/{chunk-MFZ5437A.js → chunk-N5T4M4GU.js}

@@ -3,7 +3,7 @@ import {
   transformRequestOut,
   transformResponseIn,
   transformResponseOut
-} from "./chunk-6QZGDLL4.js";
+} from "./chunk-TOVPMMHM.js";
 
 // src/transformer/transformers/GeminiCodeAssistTransformer.ts
 var DEFAULT_CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com";