@omnicross/core 0.1.5 → 0.1.7

package/dist/chunk-MYYR3HZL.js

@@ -0,0 +1,44 @@
+import {
+  AnthropicTransformer
+} from "./chunk-PEGTIPB3.js";
+import {
+  GeminiTransformer
+} from "./chunk-LVUCAWMK.js";
+import {
+  OpenAIResponseTransformer
+} from "./chunk-32O35CIF.js";
+import {
+  OpenAITransformer
+} from "./chunk-LB6EBS6Y.js";
+import {
+  GeminiCodeAssistTransformer
+} from "./chunk-N5T4M4GU.js";
+
+// src/transformer/transformers/index.ts
+var BuiltinTransformers = {
+  OpenAITransformer,
+  GeminiTransformer,
+  GeminiCodeAssistTransformer,
+  AnthropicTransformer,
+  OpenAIResponseTransformer
+};
+function getBuiltinTransformers() {
+  return BuiltinTransformers;
+}
+var BUILTIN_TRANSFORMER_NAMES = [
+  "openai",
+  "gemini",
+  "gemini-code-assist",
+  "anthropic",
+  "openai-response"
+];
+async function registerBuiltinTransformers(service) {
+  await service.initialize(getBuiltinTransformers());
+}
+
+export {
+  BuiltinTransformers,
+  getBuiltinTransformers,
+  BUILTIN_TRANSFORMER_NAMES,
+  registerBuiltinTransformers
+};

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";

package/dist/{chunk-5ENKBSWO.js → chunk-N7OOJI5V.js}

@@ -3,10 +3,12 @@ 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"
 ];
+var ACCOUNT_HEALTH_DIAGNOSTIC_LIMIT = 200;
 function readHeader(headers, name) {
   if (typeof headers.get === "function") {
     return headers.get(name);
@@ -37,13 +39,14 @@ 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 {
   records = /* @__PURE__ */ new Map();
   listeners = /* @__PURE__ */ new Set();
   anomalyListeners = /* @__PURE__ */ new Set();
+  diagnostics = [];
   now;
   overloadEnabled;
   overloadTtlMs;
@@ -71,8 +74,8 @@ var SubscriptionAccountHealth = class {
   }
   /**
    * Whether an account may be scheduled RIGHT NOW. `blocked` → false; any timer
-   * still in the future → false. Expired timers are lazily deleted on read (CRS
-   * lazy-clear parity) so an elapsed cooldown restores the account WITHOUT a
+   * still in the future → false. Expired timers are lazily deleted on read so
+   * an elapsed cooldown restores the account WITHOUT a
    * timer — but the recovery SIGNAL is the sweeper's job (`sweepRecoveries`), so
    * this read never emits (correctness is independent of the tick).
    */
@@ -86,7 +89,7 @@ var SubscriptionAccountHealth = class {
     return !active;
   }
   /**
-   * The single marking entry point (design D3). Faithful to CRS status semantics:
+   * The single marking entry point (design D3):
    *  - 429 + authoritative reset → `rateLimitEndAt`; a non-claude 429 may use
    *    `retryAfterSeconds`; a bare 429 (no resolvable reset) is NOT marked;
    *  - 529 → `overloadUntil` (gated by `overloadEnabled`);
@@ -141,9 +144,54 @@ var SubscriptionAccountHealth = class {
     }
     if (isRecordEmpty(record)) this.records.delete(key);
     else this.records.set(key, record);
-    if (recovered) this.emit({ providerId, accountId, at: now, kind: "rateLimitRecovery" });
+    if (recovered) {
+      const recovery = {
+        providerId,
+        accountId,
+        at: now,
+        kind: "rateLimitRecovery"
+      };
+      this.recordDiagnostic({ kind: "health-recovery", providerId, accountId, at: now });
+      this.emit(recovery);
+    }
     if (anomalyState && !wasUnhealthyBefore) {
-      this.emitAnomaly({ providerId, accountId, at: now, state: anomalyState });
+      const anomaly = { providerId, accountId, at: now, state: anomalyState };
+      this.recordDiagnostic({ kind: "health-anomaly", ...anomaly });
+      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. */
@@ -152,6 +200,7 @@ var SubscriptionAccountHealth = class {
     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;
   }
   /**
@@ -188,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);
@@ -196,7 +245,15 @@ var SubscriptionAccountHealth = class {
         this.records.delete(key);
       }
     }
-    for (const event of recovered) this.emit(event);
+    for (const event of recovered) {
+      this.recordDiagnostic({
+        kind: "health-recovery",
+        providerId: event.providerId,
+        accountId: event.accountId,
+        at: event.at
+      });
+      this.emit(event);
+    }
     return recovered;
   }
   /** Admin-facing coarse status + cooldown-until for one account (secret-free). */
@@ -204,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 };
     }
@@ -215,6 +275,14 @@ var SubscriptionAccountHealth = class {
     }
     return { state: "healthy" };
   }
+  /** Return newest-first, bounded, secret-free health edge diagnostics. */
+  getDiagnostics(filter = {}) {
+    const requested = typeof filter.limit === "number" && Number.isFinite(filter.limit) ? Math.trunc(filter.limit) : ACCOUNT_HEALTH_DIAGNOSTIC_LIMIT;
+    const limit = Math.min(ACCOUNT_HEALTH_DIAGNOSTIC_LIMIT, Math.max(1, requested));
+    return this.diagnostics.filter(
+      (event) => (!filter.providerId || event.providerId === filter.providerId) && (!filter.accountId || event.accountId === filter.accountId)
+    ).slice(-limit).reverse().map((event) => ({ ...event }));
+  }
   /**
    * Register a recovery listener (the OQ3 seam #5 webhooks + #8 health-cron
    * consume). Returns an unsubscribe function. Two edges fire it:
@@ -257,6 +325,12 @@ var SubscriptionAccountHealth = class {
       }
     }
   }
+  recordDiagnostic(event) {
+    this.diagnostics.push({ ...event });
+    if (this.diagnostics.length > ACCOUNT_HEALTH_DIAGNOSTIC_LIMIT) {
+      this.diagnostics.splice(0, this.diagnostics.length - ACCOUNT_HEALTH_DIAGNOSTIC_LIMIT);
+    }
+  }
   /**
    * Delete every EXPIRED timer field on the record in place; return whether any
    * timer is STILL active (in the future). `blocked` is not a timer and is left
@@ -276,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) {
@@ -303,6 +381,8 @@ export {
   OVERLOAD_ENABLED_DEFAULT,
   AUTH_ERROR_TTL_MS,
   SERVER_ERROR_TTL_MS,
+  MAX_QUOTA_COOLDOWN_MS,
+  ACCOUNT_HEALTH_DIAGNOSTIC_LIMIT,
   resolveResetSeconds,
   SubscriptionAccountHealth,
   getSharedAccountHealth,

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-OF3BECU2.cjs

@@ -0,0 +1,69 @@
+"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/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 (_optionalChain([only, 'optionalAccess', _ => _.type]) === "text" && typeof only.text === "string") return only.text;
+  }
+  return cleaned;
+}
+var OpenAITransformer = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this); }
+  static __initStatic() {this.TransformerName = "openai"}
+  __init() {this.name = "openai"}
+  __init2() {this.endPoint = "/v1/chat/completions"}
+  
+  /**
+   * 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 = _optionalChain([message, 'access', _2 => _2.thinking, 'optionalAccess', _3 => _3.content]);
+        if (typeof thinkingContent === "string" && thinkingContent.length > 0) {
+          encoded.reasoning_content = thinkingContent;
+        }
+        return encoded;
+      });
+    }
+    const effort = _optionalChain([request, 'access', _4 => _4.reasoning, 'optionalAccess', _5 => _5.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;
+  }
+}, _class.__initStatic(), _class);
+
+
+
+exports.OpenAITransformer = OpenAITransformer;

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-DDMRUL76.cjs → chunk-OKMJLEXX.cjs}

@@ -3,7 +3,7 @@
 
 
 
-var _chunkJWVTXXPXcjs = require('./chunk-JWVTXXPX.cjs');
+var _chunkKBM2W6UYcjs = require('./chunk-KBM2W6UY.cjs');
 
 // src/transformer/transformers/GeminiCodeAssistTransformer.ts
 var DEFAULT_CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com";
@@ -117,7 +117,7 @@ var GeminiCodeAssistTransformer = (_class = class {constructor() { _class.protot
    * openaiResponsesIngress). `undefined` is the valid fresh free-tier value.
    */
   async transformRequestIn(request, provider, _context) {
-    const inner = _chunkJWVTXXPXcjs.buildRequestBody.call(void 0, request);
+    const inner = _chunkKBM2W6UYcjs.buildRequestBody.call(void 0, request);
     const envelope = {
       model: request.model,
       project: provider.geminiProject,
@@ -147,7 +147,7 @@ var GeminiCodeAssistTransformer = (_class = class {constructor() { _class.protot
     if (inner && typeof inner === "object" && !("model" in inner) && "model" in r) {
       inner.model = r.model;
     }
-    return _chunkJWVTXXPXcjs.transformRequestOut.call(void 0, inner);
+    return _chunkKBM2W6UYcjs.transformRequestOut.call(void 0, inner);
   }
   /**
    * Code Assist response → OpenAI-compatible. PEEL the `.response` envelope from
@@ -155,7 +155,7 @@ var GeminiCodeAssistTransformer = (_class = class {constructor() { _class.protot
    */
   async transformResponseOut(response, _context) {
     const unwrapped = await unwrapCodeAssistResponse(response);
-    return _chunkJWVTXXPXcjs.transformResponseOut.call(void 0, unwrapped, this.name, this.logger);
+    return _chunkKBM2W6UYcjs.transformResponseOut.call(void 0, unwrapped, this.name, this.logger);
   }
   /**
    * OpenAI-compatible response → Code Assist (endpoint-encode parity). Re-wraps
@@ -164,7 +164,7 @@ var GeminiCodeAssistTransformer = (_class = class {constructor() { _class.protot
    * `transformResponseOut`'s peel.
    */
   async transformResponseIn(response, _context) {
-    const geminiResponse = await _chunkJWVTXXPXcjs.transformResponseIn.call(void 0, response, this.logger);
+    const geminiResponse = await _chunkKBM2W6UYcjs.transformResponseIn.call(void 0, response, this.logger);
     const contentType = _nullishCoalesce(geminiResponse.headers.get("Content-Type"), () => ( ""));
     if (contentType.includes("text/event-stream")) {
       return geminiResponse;

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-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;