@omnicross/subscriptions 0.1.5 → 0.1.7

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   claude_exports,
   codex_exports,
   gemini_exports
-} from "./chunk-IXGHVMZB.js";
+} from "./chunk-UETFQ5LB.js";
 
 // src/scheduler/SubscriptionAccountSelector.ts
 var SESSION_AFFINITY_TTL_MS = 36e5;
@@ -108,6 +108,15 @@ var SubscriptionAccountSelector = class {
 // src/SubscriptionAccountService.ts
 import { getSharedAccountHealth } from "@omnicross/core/pipeline/SubscriptionAccountHealth";
 
+// src/scheduler/accountSelection.ts
+import {
+  AccountAllowanceExhaustedError,
+  getSharedAccountAllowanceScheduling
+} from "@omnicross/core/pipeline/AccountAllowanceScheduling";
+import {
+  BoundAccountSelectionError
+} from "@omnicross/core/pipeline/BoundAccountSelectionError";
+
 // src/scheduler/accountModelMap.ts
 function canonicalModelId(value) {
   const idx = value.indexOf(",");
@@ -154,19 +163,104 @@ function gateSchedulable(accounts, providerId, health, now, resolvedModel, suppo
   return accounts.map((a) => {
     const healthOk = health ? health.isSchedulable(providerId, a.id, now) : true;
     const modelOk = resolvedModel ? accountSupportsModel(supportedModelsById.get(a.id), resolvedModel) : true;
-    return { ...a, schedulable: healthOk && modelOk };
+    return { ...a, schedulable: a.schedulable !== false && healthOk && modelOk };
   });
 }
 function isPoolGated(accounts, health, resolvedModel) {
   return (health !== void 0 || resolvedModel !== void 0) && accounts.length >= 2;
 }
+function hasUsableToken(token) {
+  return typeof token === "string" && token.trim() !== "";
+}
+async function resolveStrictPreferredToken(selector, tokens, providerId, preferredId, activeGetter, ctx) {
+  let config;
+  try {
+    config = await tokens.getFullConfig();
+  } catch {
+    throw new BoundAccountSelectionError(providerId, "unavailable");
+  }
+  let accounts;
+  let activeAccountId;
+  let supportedModelsById;
+  try {
+    ({ accounts, activeAccountId, supportedModelsById } = readSchedulableAccounts(config, providerId));
+  } catch {
+    throw new BoundAccountSelectionError(providerId, "unavailable");
+  }
+  const preferred = accounts.find((account) => account.id === preferredId);
+  if (!preferred) {
+    throw new BoundAccountSelectionError(providerId, "not-found");
+  }
+  if (preferred.schedulable === false) {
+    throw new BoundAccountSelectionError(providerId, "disabled");
+  }
+  if (ctx.health && !ctx.health.isSchedulable(providerId, preferredId, ctx.now)) {
+    throw new BoundAccountSelectionError(providerId, "unhealthy");
+  }
+  if (ctx.resolvedModel && !accountSupportsModel(supportedModelsById.get(preferredId), ctx.resolvedModel)) {
+    throw new BoundAccountSelectionError(providerId, "model-incompatible");
+  }
+  const allowance = getSharedAccountAllowanceScheduling().evaluate(
+    providerId,
+    preferredId,
+    preferred.priority ?? DEFAULT_ACCOUNT_PRIORITY,
+    ctx.now
+  );
+  if (allowance.action === "pause") {
+    throw new BoundAccountSelectionError(providerId, "allowance-paused", allowance.resumeAt);
+  }
+  let token = null;
+  try {
+    token = tokens.getAccessTokenForAccount ? await tokens.getAccessTokenForAccount(providerId, preferredId) : preferredId === activeAccountId ? await activeGetter() : null;
+  } catch {
+    throw new BoundAccountSelectionError(providerId, "unavailable");
+  }
+  if (!hasUsableToken(token)) {
+    throw new BoundAccountSelectionError(providerId, "empty-token");
+  }
+  const remapped = remapReportForAccount(supportedModelsById.get(preferredId), ctx.resolvedModel);
+  if (selector) maybeTouchLastUsed(selector, tokens, providerId, preferredId);
+  ctx.reportSelection?.(preferredId, preferredId === activeAccountId, remapped);
+  return token;
+}
+function gateByAllowance(accounts, providerId, now) {
+  const scheduling = getSharedAccountAllowanceScheduling();
+  const evaluatedAt = now ?? Date.now();
+  const eligibleBeforePolicy = accounts.filter((account) => account.schedulable !== false);
+  if (eligibleBeforePolicy.length === 0) return accounts;
+  const decisions = /* @__PURE__ */ new Map();
+  const gated = accounts.map((account) => {
+    if (account.schedulable === false) return account;
+    const decision = scheduling.evaluate(
+      providerId,
+      account.id,
+      account.priority ?? DEFAULT_ACCOUNT_PRIORITY,
+      evaluatedAt
+    );
+    decisions.set(account.id, decision);
+    return {
+      ...account,
+      priority: decision.effectivePriority,
+      schedulable: decision.schedulable
+    };
+  });
+  if (gated.some((account) => account.schedulable !== false)) return gated;
+  const paused = eligibleBeforePolicy.map((account) => decisions.get(account.id)).filter((decision) => decision?.action === "pause");
+  if (paused.length !== eligibleBeforePolicy.length) return gated;
+  const resumeAt = paused.map((decision) => decision?.resumeAt).filter((value) => !!value).sort()[0];
+  throw new AccountAllowanceExhaustedError(providerId, resumeAt);
+}
 function readSchedulableAccounts(config, providerId) {
   const raw = config[ACCOUNTS_KEY[providerId]] ?? [];
   const accounts = raw.map((a) => ({
     id: a.id,
+    group: typeof a.group === "string" && a.group.trim() !== "" ? a.group.trim() : providerId,
     priority: a.priority,
     lastUsedAt: a.lastUsedAt,
-    createdAt: a.createdAt
+    createdAt: a.createdAt,
+    // Persisted opt-out is absolute, including a one-account pool. Legacy rows
+    // omit the field and therefore remain enabled.
+    schedulable: a.enabled !== false
   }));
   const supportedModelsById = new Map(
     raw.map((a) => [a.id, a.supportedModels])
@@ -188,13 +282,53 @@ async function resolveSelectedToken(selector, tokens, providerId, sessionKey, ac
   const report = ctx?.reportSelection;
   const now = ctx?.now;
   const resolvedModel = ctx?.resolvedModel;
+  const preferredId = typeof ctx?.preferredAccountId === "string" && ctx.preferredAccountId.trim() !== "" ? ctx.preferredAccountId.trim() : void 0;
+  const preferredGroup = typeof ctx?.preferredAccountGroup === "string" && ctx.preferredAccountGroup.trim() !== "" ? ctx.preferredAccountGroup.trim() : void 0;
+  if (preferredId && ctx && ctx.boundAccountFallbackPolicy !== "pool") {
+    return resolveStrictPreferredToken(selector, tokens, providerId, preferredId, activeGetter, ctx);
+  }
   if (selector && tokens.getAccessTokenForAccount) {
     const config = await tokens.getFullConfig();
     const { accounts, activeAccountId, supportedModelsById } = readSchedulableAccounts(config, providerId);
-    const gated = gateSchedulable(accounts, providerId, health, now, resolvedModel, supportedModelsById);
-    const poolGated = isPoolGated(accounts, health, resolvedModel);
+    const groupAccounts = preferredGroup ? accounts.filter((account) => account.group === preferredGroup) : accounts;
+    if (preferredGroup && groupAccounts.length === 0 && ctx?.boundAccountFallbackPolicy !== "pool") {
+      throw new BoundAccountSelectionError(providerId, "not-found");
+    }
+    let candidates = groupAccounts.length > 0 ? groupAccounts : accounts;
+    let healthAndModelGated = gateSchedulable(
+      candidates,
+      providerId,
+      health,
+      now,
+      resolvedModel,
+      supportedModelsById
+    );
+    let gated = gateByAllowance(healthAndModelGated, providerId, now);
+    let groupHasUsableCredential = gated.some((account) => account.schedulable !== false);
+    if (groupHasUsableCredential && preferredGroup && ctx?.boundAccountFallbackPolicy === "pool" && candidates !== accounts) {
+      groupHasUsableCredential = false;
+      for (const account of gated) {
+        if (account.schedulable === false) continue;
+        if (await tokens.getAccessTokenForAccount(providerId, account.id)) {
+          groupHasUsableCredential = true;
+          break;
+        }
+      }
+    }
+    if (preferredGroup && ctx?.boundAccountFallbackPolicy === "pool" && candidates !== accounts && !groupHasUsableCredential) {
+      candidates = accounts;
+      healthAndModelGated = gateSchedulable(
+        candidates,
+        providerId,
+        health,
+        now,
+        resolvedModel,
+        supportedModelsById
+      );
+      gated = gateByAllowance(healthAndModelGated, providerId, now);
+    }
+    const poolGated = isPoolGated(candidates, health, resolvedModel) || candidates.some((account) => account.schedulable === false) || preferredGroup !== void 0;
     const remapFor = (id) => remapReportForAccount(supportedModelsById.get(id), resolvedModel);
-    const preferredId = ctx?.preferredAccountId;
     if (preferredId) {
       const preferred = gated.find((a) => a.id === preferredId);
       if (preferred && preferred.schedulable !== false) {
@@ -227,7 +361,28 @@ async function resolveSelectedToken(selector, tokens, providerId, sessionKey, ac
         }
       }
     }
-    if (activeAccountId) report?.(activeAccountId, true, remapFor(activeAccountId));
+    if (activeAccountId) {
+      if (preferredGroup && ctx?.boundAccountFallbackPolicy !== "pool" && !candidates.some((account) => account.id === activeAccountId)) {
+        throw new BoundAccountSelectionError(providerId, "unavailable");
+      }
+      const persistedActive = accounts.find((account) => account.id === activeAccountId);
+      if (persistedActive?.schedulable === false) return null;
+      const activeAllowance = getSharedAccountAllowanceScheduling().evaluate(
+        providerId,
+        activeAccountId,
+        persistedActive?.priority ?? DEFAULT_ACCOUNT_PRIORITY,
+        now
+      );
+      if (activeAllowance.action === "pause") {
+        throw new AccountAllowanceExhaustedError(providerId, activeAllowance.resumeAt);
+      }
+      const token = await activeGetter();
+      if (hasUsableToken(token)) {
+        maybeTouchLastUsed(selector, tokens, providerId, activeAccountId);
+        report?.(activeAccountId, true, remapFor(activeAccountId));
+      }
+      return token;
+    }
     return activeGetter();
   }
   return activeGetter();
@@ -278,7 +433,14 @@ var OAuthBearerAuthStrategy = class {
       this.providerId,
       hints?.sessionKey,
       () => this.resolveAccessToken(),
-      { health: this.health, reportSelection: hints?.reportSelection, resolvedModel: hints?.resolvedModel, preferredAccountId: hints?.preferredAccountId }
+      {
+        health: this.health,
+        reportSelection: hints?.reportSelection,
+        resolvedModel: hints?.resolvedModel,
+        preferredAccountId: hints?.preferredAccountId,
+        preferredAccountGroup: hints?.preferredAccountGroup,
+        boundAccountFallbackPolicy: hints?.boundAccountFallbackPolicy
+      }
     );
     if (!token) {
       return;
@@ -355,7 +517,14 @@ var PassThroughAuthStrategy = class {
       "claude",
       hints?.sessionKey,
       () => this.tokens.getValidClaudeAccessToken(),
-      { health: this.health, reportSelection: hints?.reportSelection, resolvedModel: hints?.resolvedModel, preferredAccountId: hints?.preferredAccountId }
+      {
+        health: this.health,
+        reportSelection: hints?.reportSelection,
+        resolvedModel: hints?.resolvedModel,
+        preferredAccountId: hints?.preferredAccountId,
+        preferredAccountGroup: hints?.preferredAccountGroup,
+        boundAccountFallbackPolicy: hints?.boundAccountFallbackPolicy
+      }
     );
     if (!token) return;
     headers["Authorization"] = `Bearer ${token}`;
@@ -433,7 +602,14 @@ var StaticBearerAuthStrategy = class {
       "opencodego",
       hints?.sessionKey,
       () => this.tokens.getValidOpenCodeGoApiKey(),
-      { health: this.health, reportSelection: hints?.reportSelection, resolvedModel: hints?.resolvedModel, preferredAccountId: hints?.preferredAccountId }
+      {
+        health: this.health,
+        reportSelection: hints?.reportSelection,
+        resolvedModel: hints?.resolvedModel,
+        preferredAccountId: hints?.preferredAccountId,
+        preferredAccountGroup: hints?.preferredAccountGroup,
+        boundAccountFallbackPolicy: hints?.boundAccountFallbackPolicy
+      }
     );
     if (!key) {
       return;
@@ -523,31 +699,29 @@ import { buildCodeAssistUrl } from "@omnicross/core/transformer/transformers/Gem
 
 // src/opencodego/CircuitBreaker.ts
 var CircuitBreaker = class {
-  state = "closed";
-  /** CONSECUTIVE failures while closed (reset by any closed success). */
-  failureCount = 0;
-  /** Successes accumulated in the current half-open probe window. */
-  successCount = 0;
-  /** Test calls admitted in the current half-open window (cap = halfOpenMaxCalls). */
-  halfOpenCalls = 0;
-  /** `now()` at the last recorded failure — drives the open→half-open elapsed check. */
-  lastFailureTime = 0;
-  threshold;
-  openMs;
-  halfOpenMaxCalls;
+  snapshot = {
+    mode: "closed",
+    consecutiveFailures: 0,
+    openedAt: 0,
+    probeAdmissions: 0,
+    probeSuccesses: 0
+  };
+  limits;
   now;
   constructor(opts = {}) {
-    this.threshold = opts.threshold ?? 3;
-    this.openMs = opts.openMs ?? 3e4;
-    this.halfOpenMaxCalls = opts.halfOpenMaxCalls ?? 3;
+    this.limits = {
+      threshold: opts.threshold ?? 3,
+      openMs: opts.openMs ?? 3e4,
+      halfOpenMaxCalls: opts.halfOpenMaxCalls ?? 3
+    };
     this.now = opts.now ?? Date.now;
   }
   /** Current state (diagnostics / tests). */
   getState() {
-    return this.state;
+    return this.snapshot.mode;
   }
   /**
-   * Admission gate (`fallback.go:54-72` `AllowRequest`). Returns whether a
+   * Admission gate. Returns whether a
    * request to this model is allowed RIGHT NOW. Side-effecting BY DESIGN:
    *   - `closed`    → always admit.
    *   - `open`      → if `now() - lastFailureTime > openMs`, FLIP to `half-open`,
@@ -558,65 +732,82 @@ var CircuitBreaker = class {
    *                   recorded outcome resolves the state).
    */
   allowRequest() {
-    switch (this.state) {
-      case "closed":
-        return true;
-      case "open":
-        if (this.now() - this.lastFailureTime > this.openMs) {
-          this.state = "half-open";
-          this.successCount = 0;
-          this.halfOpenCalls = 1;
-          return true;
-        }
-        return false;
-      case "half-open":
-        if (this.halfOpenCalls < this.halfOpenMaxCalls) {
-          this.halfOpenCalls += 1;
-          return true;
-        }
-        return false;
-      default:
-        return true;
+    if (this.snapshot.mode === "closed") return true;
+    if (this.snapshot.mode === "open") {
+      const elapsed = this.now() - this.snapshot.openedAt;
+      if (elapsed <= this.limits.openMs) return false;
+      this.snapshot = {
+        ...this.snapshot,
+        mode: "half-open",
+        probeAdmissions: 1,
+        probeSuccesses: 0
+      };
+      return true;
     }
+    if (this.snapshot.probeAdmissions >= this.limits.halfOpenMaxCalls) return false;
+    this.snapshot = {
+      ...this.snapshot,
+      probeAdmissions: this.snapshot.probeAdmissions + 1
+    };
+    return true;
   }
   /**
-   * Record a successful attempt (`fallback.go:75-91` `RecordSuccess`).
+   * Record a successful attempt.
    *   - `half-open` → increment `successCount`; at `halfOpenMaxCalls` successes,
    *     CLOSE the circuit and reset all counters.
    *   - `closed`    → reset the consecutive `failureCount` (a single good call
    *     clears the streak).
    */
   recordSuccess() {
-    if (this.state === "half-open") {
-      this.successCount += 1;
-      if (this.successCount >= this.halfOpenMaxCalls) {
-        this.state = "closed";
-        this.failureCount = 0;
-        this.successCount = 0;
-        this.halfOpenCalls = 0;
+    if (this.snapshot.mode === "open") return;
+    if (this.snapshot.mode === "closed") {
+      if (this.snapshot.consecutiveFailures !== 0) {
+        this.snapshot = { ...this.snapshot, consecutiveFailures: 0 };
       }
       return;
     }
-    this.failureCount = 0;
+    const probeSuccesses = this.snapshot.probeSuccesses + 1;
+    if (probeSuccesses >= this.limits.halfOpenMaxCalls) {
+      this.snapshot = {
+        mode: "closed",
+        consecutiveFailures: 0,
+        openedAt: 0,
+        probeAdmissions: 0,
+        probeSuccesses: 0
+      };
+      return;
+    }
+    this.snapshot = { ...this.snapshot, probeSuccesses };
   }
   /**
-   * Record a failed attempt (`fallback.go:94-115` `RecordFailure`).
+   * Record a failed attempt.
    *   - `half-open` → immediately RE-OPEN (one probe failure is enough); stamp
    *     `lastFailureTime`, reset `successCount`.
    *   - `closed`    → increment the consecutive `failureCount`; at `threshold`,
    *     OPEN the circuit. Always stamp `lastFailureTime`.
    */
   recordFailure() {
-    this.lastFailureTime = this.now();
-    if (this.state === "half-open") {
-      this.state = "open";
-      this.successCount = 0;
-      this.halfOpenCalls = 0;
+    const openedAt = this.now();
+    if (this.snapshot.mode === "half-open") {
+      this.snapshot = {
+        ...this.snapshot,
+        mode: "open",
+        openedAt,
+        probeAdmissions: 0,
+        probeSuccesses: 0
+      };
       return;
     }
-    this.failureCount += 1;
-    if (this.failureCount >= this.threshold) {
-      this.state = "open";
+    const consecutiveFailures = this.snapshot.consecutiveFailures + 1;
+    this.snapshot = {
+      ...this.snapshot,
+      consecutiveFailures,
+      openedAt,
+      mode: consecutiveFailures >= this.limits.threshold ? "open" : this.snapshot.mode
+    };
+    if (this.snapshot.mode === "open") {
+      this.snapshot.probeAdmissions = 0;
+      this.snapshot.probeSuccesses = 0;
     }
   }
 };
@@ -665,8 +856,7 @@ var DEFAULT_OPENCODEGO_MODEL_MAP = {
     modelId: "glm-5"
   },
   complex: {
-    // Reference maps `complex` → `glm-5.1` (config.example.json:55-60); was
-    // drifted to `mimo-v2-pro` (audit D4).
+    // Complex tasks use the higher-capability GLM variant by default.
     modelId: "glm-5.1"
   },
   fast: {
@@ -805,67 +995,44 @@ function resolveOpenCodeGoHalf(modelId, config) {
 
 // src/opencodego/ScenarioRouter.ts
 var COMPLEX_KEYWORDS = [
-  // Architectural
-  "architect",
   "architecture",
   "refactor",
   "redesign",
-  "complex",
-  "difficult",
-  "challenging",
   "optimize",
   "performance",
-  "efficiency",
-  "design pattern",
-  "best practice",
-  // Tool-related keywords indicate complex operations
-  "execute",
-  "run command",
-  "bash",
-  "shell",
   "implement",
   "build",
-  "create",
-  "add feature",
-  "write to",
   "edit file",
-  "create file"
+  "debug",
+  "migrate",
+  "benchmark"
 ];
 var THINKING_KEYWORDS = [
   "think",
-  "thinking",
   "plan",
   "reason",
-  "reasoning",
   "analyze",
-  "analysis",
-  "step by step"
+  "step by step",
+  "evaluate",
+  "compare tradeoffs"
 ];
 var ANT_THINKING_MARKER = "antThinking";
 var TOOL_BLOCKERS = [
   "tool",
   "function",
-  "execute",
-  "run command",
+  "command",
   "write",
   "edit",
-  "create",
   "delete",
-  "remove",
   "implement",
   "build",
-  "add",
   "modify"
 ];
 var BACKGROUND_KEYWORDS = [
   "list directory",
-  "ls -",
-  "dir",
   "show file",
-  "view file",
-  "cat file",
+  "read file",
   "what is",
-  "what's",
   "tell me about",
   "check status",
   "show status"
@@ -921,7 +1088,7 @@ function opencodegoTransformerNamesForShape(shape) {
       return ["gemini"];
     case "chat":
     default:
-      return ["opencodego"];
+      return ["openai"];
   }
 }
 function resolveOpenCodeGoTarget(modelId, config) {
@@ -976,7 +1143,7 @@ var SubscriptionProviderRegistry = class {
           authStrategy: codex,
           mode: "transformer",
           // ChatGPT internal endpoint — accepts the OpenAI Responses API
-          // format. Mirrors `_others/claude-relay-service/src/routes/openaiRoutes.js:454`.
+          // format and uses the Codex OAuth access token below.
           // The Codex OAuth access token grants access here; the public
           // `api.openai.com/v1/responses` endpoint would reject the same token.
           resolveUpstreamUrl: () => "https://chatgpt.com/backend-api/codex/responses",
@@ -1022,8 +1189,8 @@ var SubscriptionProviderRegistry = class {
           // `ocConfig`; the core `/v1/messages` plan builder passes the opaque
           // `route.subscriptionConfig`). With NO zen config every resolved model
           // is go-half → byte-identical to the prior resolver.
-          // `// UNVERIFIED (no live zen key)`: the zen endpoint hosts/paths are
-          // ported from the reference + proven in-process only.
+          // `// UNVERIFIED (no live zen key)`: the ZEN endpoint hosts and paths
+          // are covered by in-process tests only.
           resolveUpstreamUrl: (model, config) => {
             const oc = config;
             const { half, shape } = resolveOpenCodeGoTarget(model, oc);
@@ -1031,7 +1198,7 @@ var SubscriptionProviderRegistry = class {
             return buildOpenCodeGoUrl(half, shape, override);
           },
           // zen seam (Decision 3): vary the provider transformer chain by resolved
-          // shape (anthropic⇒[] verbatim, chat⇒opencodego, responses⇒openai-response,
+          // shape (anthropic⇒[] verbatim, chat⇒openai, responses⇒openai-response,
           // gemini⇒gemini). OPTIONAL on the profile type — only opencodego sets it;
           // claude/codex/gemini omit it and fall back to `providerTransformerNames`,
           // keeping their routing byte-identical. The static `providerTransformerNames`
@@ -1041,7 +1208,7 @@ var SubscriptionProviderRegistry = class {
             const { shape } = resolveOpenCodeGoTarget(model, config);
             return opencodegoTransformerNamesForShape(shape);
           },
-          providerTransformerNames: ["opencodego"],
+          providerTransformerNames: ["openai"],
           modelTransformerNames: [],
           modelMapper: (sdkModel, summary, config) => {
             const scenario = resolveOpenCodeGoScenario(summary, config);
@@ -1055,9 +1222,8 @@ var SubscriptionProviderRegistry = class {
           // circuit is open. `breaker.allowRequest(modelId)` is the admission
           // gate — calling it has the side effect of flipping an `open` model to
           // `half-open` once its 30s window elapses AND counting a half-open admit
-          // slot. It MUST therefore be consulted EXACTLY ONCE per returned model,
-          // on the candidate about to be attempted — mirroring the reference
-          // (`fallback.go` calls `AllowRequest` once, on the model it returns).
+          // slot. It MUST therefore be consulted exactly once per returned model,
+          // on the candidate about to be attempted.
           // An early-returning scan (NOT `Array.filter`, which would `allowRequest`
           // every candidate and burn the admit slots of half-open models AFTER the
           // chosen one — those are never attempted, never recorded, so they would
@@ -1091,9 +1257,9 @@ var SubscriptionProviderRegistry = class {
    * process singleton, built here and captured by the opencodego profile's
    * `nextFallback` (consult) + `recordModelOutcome` (record) closures. Because
    * the `SubscriptionProviderRegistry` is itself a process singleton (via
-   * `setSubscriptionProviderRegistry`), breaker state persists across requests —
-   * exactly the reference's long-lived `FallbackHandler`. Constructed with the
-   * default reference thresholds (3 / 30s / 3) and the default `Date.now` clock.
+   * `setSubscriptionProviderRegistry`), breaker state persists across requests.
+   * Constructed with the production thresholds (3 / 30s / 3) and the default
+   * `Date.now` clock.
    */
   breaker = new CircuitBreakerRegistry();
   /** Returns the dispatch profile for a known subscription provider, or
@@ -1121,6 +1287,8 @@ function getSubscriptionProviderRegistry() {
 }
 
 // src/SubscriptionDispatcher.ts
+import { isAccountAllowanceExhaustedError } from "@omnicross/core/pipeline/AccountAllowanceScheduling";
+import { isBoundAccountSelectionError } from "@omnicross/core/pipeline/BoundAccountSelectionError";
 import { getGeminiCodeAssistResolver } from "@omnicross/core/ports/gemini-code-assist-resolver";
 import {
   getSharedAccountHealth as getSharedAccountHealth2,
@@ -1378,6 +1546,7 @@ var SubscriptionDispatcher = class {
     try {
       await this.profile.authStrategy.applyHeaders(headers, hints);
     } catch (err) {
+      if (isAccountAllowanceExhaustedError(err) || isBoundAccountSelectionError(err)) throw err;
       console.warn("[AgentProxy:subscription] authStrategy.applyHeaders threw:", serializeError(err));
     }
   }

package/dist/oauth.cjs

@@ -2,9 +2,9 @@
 
 
 
-var _chunkTPW5Q25Ycjs = require('./chunk-TPW5Q25Y.cjs');
+var _chunkPWV5NBO5cjs = require('./chunk-PWV5NBO5.cjs');
 
 
 
 
-exports.claudeOAuth = _chunkTPW5Q25Ycjs.claude_exports; exports.codexOAuth = _chunkTPW5Q25Ycjs.codex_exports; exports.geminiOAuth = _chunkTPW5Q25Ycjs.gemini_exports;
+exports.claudeOAuth = _chunkPWV5NBO5cjs.claude_exports; exports.codexOAuth = _chunkPWV5NBO5cjs.codex_exports; exports.geminiOAuth = _chunkPWV5NBO5cjs.gemini_exports;

package/dist/oauth.d.cts

@@ -10,7 +10,7 @@ import { TokenExchangeRequest, OAuthParams } from '@omnicross/contracts/account-
  * through an INJECTED `FetchLike` port — NO `electron`, NO `net`, NO host path
  * (a desktop host can inject an electron-net adapter; the daemon injects global
  * `fetch`). Claude `code=true`, `state` carried in exchange, setup-token has no
- * refresh_token. Reference: claude-relay-service `src/utils/oauthHelper.js`.
+ * refresh_token.
  *
  * @module @omnicross/subscriptions/oauth/flows/claude
  */
@@ -60,8 +60,6 @@ declare namespace claude {
  * the exchange body, refresh carries `scope=openid profile email`, and the refresh
  * defaults `expiresIn` to 3600 + returns an `idToken`. Network goes through the
  * injected `FetchLike`.
- * Reference: claude-relay-service `src/services/openaiAccountService.js`.
- *
  * @module @omnicross/subscriptions/oauth/flows/codex
  */
 
@@ -97,8 +95,6 @@ declare namespace codex {
  * `refreshGeminiToken`). Network goes through the injected `FetchLike`.
  * NOTE: `exchangeCodeForTokens` keeps a POSITIONAL signature
  * `(authorizationCode, codeVerifier)`.
- * Reference: claude-relay-service `src/services/geminiAccountService.js`.
- *
  * @module @omnicross/subscriptions/oauth/flows/gemini
  */
 

package/dist/oauth.d.ts

@@ -10,7 +10,7 @@ import { TokenExchangeRequest, OAuthParams } from '@omnicross/contracts/account-
  * through an INJECTED `FetchLike` port — NO `electron`, NO `net`, NO host path
  * (a desktop host can inject an electron-net adapter; the daemon injects global
  * `fetch`). Claude `code=true`, `state` carried in exchange, setup-token has no
- * refresh_token. Reference: claude-relay-service `src/utils/oauthHelper.js`.
+ * refresh_token.
  *
  * @module @omnicross/subscriptions/oauth/flows/claude
  */
@@ -60,8 +60,6 @@ declare namespace claude {
  * the exchange body, refresh carries `scope=openid profile email`, and the refresh
  * defaults `expiresIn` to 3600 + returns an `idToken`. Network goes through the
  * injected `FetchLike`.
- * Reference: claude-relay-service `src/services/openaiAccountService.js`.
- *
  * @module @omnicross/subscriptions/oauth/flows/codex
  */
 
@@ -97,8 +95,6 @@ declare namespace codex {
  * `refreshGeminiToken`). Network goes through the injected `FetchLike`.
  * NOTE: `exchangeCodeForTokens` keeps a POSITIONAL signature
  * `(authorizationCode, codeVerifier)`.
- * Reference: claude-relay-service `src/services/geminiAccountService.js`.
- *
  * @module @omnicross/subscriptions/oauth/flows/gemini
  */