@omnicross/core 0.1.5 → 0.1.6

package/dist/chunk-OPRS4IQZ.js

@@ -0,0 +1,153 @@
+import {
+  getSharedAccountAllowanceStore
+} from "./chunk-MKF46GNZ.js";
+
+// src/pipeline/AccountAllowanceScheduling.ts
+var DEFAULT_POLICY = {
+  enabled: false,
+  demoteAtPercent: 80,
+  pauseAtPercent: 98,
+  priorityPenalty: 100
+};
+var HISTORY_LIMIT = 200;
+var AccountAllowanceExhaustedError = class extends Error {
+  constructor(providerId, resumeAt) {
+    super(
+      resumeAt ? `All ${providerId} subscription accounts are paused by the allowance policy until ${resumeAt}` : `All ${providerId} subscription accounts are paused by the allowance policy`
+    );
+    this.providerId = providerId;
+    this.resumeAt = resumeAt;
+    this.name = "AccountAllowanceExhaustedError";
+  }
+  providerId;
+  resumeAt;
+  code = "account_allowance_exhausted";
+  status = 429;
+};
+function isAccountAllowanceExhaustedError(error) {
+  if (error instanceof AccountAllowanceExhaustedError) return true;
+  if (!error || typeof error !== "object") return false;
+  const value = error;
+  return value.code === "account_allowance_exhausted" && value.status === 429;
+}
+function freshWorstWindow(snapshot) {
+  return snapshot.windows.filter((window) => window.state === "fresh" && typeof window.usedPercent === "number").sort((left, right) => (right.usedPercent ?? -1) - (left.usedPercent ?? -1))[0];
+}
+var AccountAllowanceScheduling = class {
+  constructor(store = getSharedAccountAllowanceStore(), now = Date.now) {
+    this.store = store;
+    this.now = now;
+  }
+  store;
+  now;
+  config = { ...DEFAULT_POLICY };
+  history = [];
+  lastRecorded = /* @__PURE__ */ new Map();
+  configure(config) {
+    this.config = config ? { ...config } : { ...DEFAULT_POLICY };
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  evaluate(providerId, accountId, basePriority, now = this.now()) {
+    const decision = this.decide(providerId, accountId, basePriority, now);
+    this.recordApplied(decision);
+    return decision;
+  }
+  /**
+   * Project the current policy result without recording an applied decision.
+   * Admin/read-model callers use this so polling an account list never creates
+   * synthetic demotion/pause history entries.
+   */
+  preview(providerId, accountId, basePriority, now = this.now()) {
+    return this.decide(providerId, accountId, basePriority, now);
+  }
+  decide(providerId, accountId, basePriority, now) {
+    const decidedAt = new Date(now).toISOString();
+    const base = {
+      providerId,
+      accountId,
+      basePriority,
+      effectivePriority: basePriority,
+      schedulable: true,
+      decidedAt
+    };
+    if (!this.config.enabled) return { ...base, action: "ignore", reason: "policy-disabled" };
+    if (providerId !== "claude" && providerId !== "codex") {
+      return { ...base, action: "ignore", reason: "provider-unsupported" };
+    }
+    const snapshot = this.store.get(providerId, accountId, now);
+    if (!snapshot) return { ...base, action: "ignore", reason: "snapshot-missing" };
+    const worst = freshWorstWindow(snapshot);
+    if (!worst || worst.usedPercent === null) {
+      return { ...base, action: "ignore", reason: "snapshot-not-fresh", observedAt: snapshot.observedAt };
+    }
+    const resumeAt = worst.resetsAt ?? snapshot.expiresAt;
+    const resumeMs = resumeAt ? Date.parse(resumeAt) : Number.NaN;
+    const canPauseUntilKnownDeadline = Number.isFinite(resumeMs) && resumeMs > now;
+    let decision;
+    if (worst.usedPercent >= this.config.pauseAtPercent && canPauseUntilKnownDeadline) {
+      decision = {
+        ...base,
+        action: "pause",
+        reason: "pause-threshold",
+        schedulable: false,
+        usedPercent: worst.usedPercent,
+        observedAt: snapshot.observedAt,
+        resumeAt
+      };
+    } else if (worst.usedPercent >= this.config.demoteAtPercent) {
+      decision = {
+        ...base,
+        action: "demote",
+        reason: "demote-threshold",
+        effectivePriority: basePriority + this.config.priorityPenalty,
+        usedPercent: worst.usedPercent,
+        observedAt: snapshot.observedAt,
+        resumeAt: canPauseUntilKnownDeadline ? resumeAt : void 0
+      };
+    } else {
+      decision = {
+        ...base,
+        action: "normal",
+        reason: "below-threshold",
+        usedPercent: worst.usedPercent,
+        observedAt: snapshot.observedAt,
+        resumeAt: canPauseUntilKnownDeadline ? resumeAt : void 0
+      };
+    }
+    return decision;
+  }
+  getHistory() {
+    return this.history.map((decision) => ({ ...decision }));
+  }
+  clearHistory() {
+    this.history.length = 0;
+    this.lastRecorded.clear();
+  }
+  recordApplied(decision) {
+    if (decision.action !== "demote" && decision.action !== "pause") return;
+    const key = `${decision.providerId}\0${decision.accountId}`;
+    const signature = `${decision.action}\0${decision.observedAt ?? ""}\0${decision.usedPercent ?? ""}`;
+    if (this.lastRecorded.get(key) === signature) return;
+    this.lastRecorded.set(key, signature);
+    this.history.push({ ...decision });
+    if (this.history.length > HISTORY_LIMIT) this.history.splice(0, this.history.length - HISTORY_LIMIT);
+  }
+};
+var sharedScheduling = null;
+function getSharedAccountAllowanceScheduling() {
+  if (!sharedScheduling) sharedScheduling = new AccountAllowanceScheduling();
+  return sharedScheduling;
+}
+function __resetSharedAccountAllowanceSchedulingForTests() {
+  sharedScheduling = null;
+}
+
+export {
+  AccountAllowanceExhaustedError,
+  isAccountAllowanceExhaustedError,
+  AccountAllowanceScheduling,
+  getSharedAccountAllowanceScheduling,
+  __resetSharedAccountAllowanceSchedulingForTests
+};

package/dist/{chunk-D3TDKWRP.js → chunk-SIZQQD6T.js}

@@ -3,6 +3,9 @@ import {
   redactHeaders,
   writeUpstreamTrace
 } from "./chunk-SYQF7OIR.js";
+import {
+  getSharedAccountAllowanceStore
+} from "./chunk-MKF46GNZ.js";
 
 // src/pipeline/upstreamFetch.ts
 import { Agent, buildConnector, ProxyAgent } from "undici";
@@ -102,8 +105,17 @@ function resolveUpstreamDispatcher(ctx) {
 function fetchUpstream(url, init, ctx) {
   const dispatcher = resolveUpstreamDispatcher({ ...ctx ?? {}, url });
   const doFetch = dispatcher ? () => fetch(url, { ...init, dispatcher }) : () => fetch(url, init);
+  const doFetchWithAllowanceTap = () => doFetch().then((response) => {
+    if (ctx?.providerId === "codex" && ctx.accountId) {
+      try {
+        getSharedAccountAllowanceStore().recordCodexHeaders(ctx.accountId, response.headers);
+      } catch {
+      }
+    }
+    return response;
+  });
   const tracePath = getUpstreamTracePath();
-  if (!tracePath || !ctx?.providerId) return doFetch();
+  if (!tracePath || !ctx?.providerId) return doFetchWithAllowanceTap();
   const startedAt = Date.now();
   const method = typeof init.method === "string" ? init.method : "GET";
   const requestHeaders = redactHeaders(
@@ -112,7 +124,7 @@ function fetchUpstream(url, init, ctx) {
   const requestBody = typeof init.body === "string" ? init.body : null;
   const providerId = ctx.providerId;
   const accountId = ctx.accountId;
-  return doFetch().then((res) => {
+  return doFetchWithAllowanceTap().then((res) => {
     const clone = res.clone();
     const status = res.status;
     const statusText = res.statusText;