@omnicross/core 0.1.4 → 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-XK5CIRMQ.js → chunk-SIZQQD6T.js}

@@ -1,3 +1,12 @@
+import {
+  getUpstreamTracePath,
+  redactHeaders,
+  writeUpstreamTrace
+} from "./chunk-SYQF7OIR.js";
+import {
+  getSharedAccountAllowanceStore
+} from "./chunk-MKF46GNZ.js";
+
 // src/pipeline/upstreamFetch.ts
 import { Agent, buildConnector, ProxyAgent } from "undici";
 import { SocksClient } from "socks";
@@ -95,8 +104,69 @@ function resolveUpstreamDispatcher(ctx) {
 }
 function fetchUpstream(url, init, ctx) {
   const dispatcher = resolveUpstreamDispatcher({ ...ctx ?? {}, url });
-  if (!dispatcher) return fetch(url, init);
-  return fetch(url, { ...init, dispatcher });
+  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 doFetchWithAllowanceTap();
+  const startedAt = Date.now();
+  const method = typeof init.method === "string" ? init.method : "GET";
+  const requestHeaders = redactHeaders(
+    init.headers
+  );
+  const requestBody = typeof init.body === "string" ? init.body : null;
+  const providerId = ctx.providerId;
+  const accountId = ctx.accountId;
+  return doFetchWithAllowanceTap().then((res) => {
+    const clone = res.clone();
+    const status = res.status;
+    const statusText = res.statusText;
+    const responseHeaders = redactHeaders(res.headers);
+    void clone.text().then((body) => {
+      writeUpstreamTrace({
+        ts: startedAt,
+        durationMs: Date.now() - startedAt,
+        providerId,
+        accountId,
+        url,
+        method,
+        requestHeaders,
+        requestBody,
+        status,
+        statusText,
+        responseHeaders,
+        responseBody: body,
+        responseBytes: Buffer.byteLength(body, "utf8")
+      });
+    }).catch(() => {
+    });
+    return res;
+  }).catch((err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    writeUpstreamTrace({
+      ts: startedAt,
+      durationMs: Date.now() - startedAt,
+      providerId,
+      accountId,
+      url,
+      method,
+      requestHeaders,
+      requestBody,
+      status: 0,
+      statusText: "",
+      responseHeaders: {},
+      responseBody: `<UPSTREAM FETCH ERROR: ${msg}>`,
+      responseBytes: 0
+    });
+    throw err;
+  });
 }
 function __resetUpstreamProxyForTests() {
   resolver = null;