@omnicross/subscriptions 0.1.5 → 0.1.6

package/dist/index.cjs

@@ -108,6 +108,15 @@ var SubscriptionAccountSelector = (_class = class {constructor() { _class.protot
 // src/SubscriptionAccountService.ts
 var _SubscriptionAccountHealth = require('@omnicross/core/pipeline/SubscriptionAccountHealth');
 
+// src/scheduler/accountSelection.ts
+
+
+
+var _AccountAllowanceScheduling = require('@omnicross/core/pipeline/AccountAllowanceScheduling');
+
+
+var _BoundAccountSelectionError = require('@omnicross/core/pipeline/BoundAccountSelectionError');
+
 // src/scheduler/accountModelMap.ts
 function canonicalModelId(value) {
   const idx = value.indexOf(",");
@@ -154,19 +163,103 @@ 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(tokens, providerId, preferredId, activeGetter, ctx) {
+  let config;
+  try {
+    config = await tokens.getFullConfig();
+  } catch (e2) {
+    throw new (0, _BoundAccountSelectionError.BoundAccountSelectionError)(providerId, "unavailable");
+  }
+  let accounts;
+  let activeAccountId;
+  let supportedModelsById;
+  try {
+    ({ accounts, activeAccountId, supportedModelsById } = readSchedulableAccounts(config, providerId));
+  } catch (e3) {
+    throw new (0, _BoundAccountSelectionError.BoundAccountSelectionError)(providerId, "unavailable");
+  }
+  const preferred = accounts.find((account) => account.id === preferredId);
+  if (!preferred) {
+    throw new (0, _BoundAccountSelectionError.BoundAccountSelectionError)(providerId, "not-found");
+  }
+  if (preferred.schedulable === false) {
+    throw new (0, _BoundAccountSelectionError.BoundAccountSelectionError)(providerId, "disabled");
+  }
+  if (ctx.health && !ctx.health.isSchedulable(providerId, preferredId, ctx.now)) {
+    throw new (0, _BoundAccountSelectionError.BoundAccountSelectionError)(providerId, "unhealthy");
+  }
+  if (ctx.resolvedModel && !accountSupportsModel(supportedModelsById.get(preferredId), ctx.resolvedModel)) {
+    throw new (0, _BoundAccountSelectionError.BoundAccountSelectionError)(providerId, "model-incompatible");
+  }
+  const allowance = _AccountAllowanceScheduling.getSharedAccountAllowanceScheduling.call(void 0, ).evaluate(
+    providerId,
+    preferredId,
+    _nullishCoalesce(preferred.priority, () => ( DEFAULT_ACCOUNT_PRIORITY)),
+    ctx.now
+  );
+  if (allowance.action === "pause") {
+    throw new (0, _BoundAccountSelectionError.BoundAccountSelectionError)(providerId, "allowance-paused", allowance.resumeAt);
+  }
+  let token = null;
+  try {
+    token = tokens.getAccessTokenForAccount ? await tokens.getAccessTokenForAccount(providerId, preferredId) : preferredId === activeAccountId ? await activeGetter() : null;
+  } catch (e4) {
+    throw new (0, _BoundAccountSelectionError.BoundAccountSelectionError)(providerId, "unavailable");
+  }
+  if (!hasUsableToken(token)) {
+    throw new (0, _BoundAccountSelectionError.BoundAccountSelectionError)(providerId, "empty-token");
+  }
+  const remapped = remapReportForAccount(supportedModelsById.get(preferredId), ctx.resolvedModel);
+  _optionalChain([ctx, 'access', _ => _.reportSelection, 'optionalCall', _2 => _2(preferredId, preferredId === activeAccountId, remapped)]);
+  return token;
+}
+function gateByAllowance(accounts, providerId, now) {
+  const scheduling = _AccountAllowanceScheduling.getSharedAccountAllowanceScheduling.call(void 0, );
+  const evaluatedAt = _nullishCoalesce(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,
+      _nullishCoalesce(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) => _optionalChain([decision, 'optionalAccess', _3 => _3.action]) === "pause");
+  if (paused.length !== eligibleBeforePolicy.length) return gated;
+  const resumeAt = paused.map((decision) => _optionalChain([decision, 'optionalAccess', _4 => _4.resumeAt])).filter((value) => !!value).sort()[0];
+  throw new (0, _AccountAllowanceScheduling.AccountAllowanceExhaustedError)(providerId, resumeAt);
+}
 function readSchedulableAccounts(config, providerId) {
   const raw = _nullishCoalesce(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])
@@ -184,24 +277,64 @@ function pickByIdTarget(selector, gated, providerId, activeAccountId, sessionKey
   return void 0;
 }
 async function resolveSelectedToken(selector, tokens, providerId, sessionKey, activeGetter, ctx) {
-  const health = _optionalChain([ctx, 'optionalAccess', _ => _.health]);
-  const report = _optionalChain([ctx, 'optionalAccess', _2 => _2.reportSelection]);
-  const now = _optionalChain([ctx, 'optionalAccess', _3 => _3.now]);
-  const resolvedModel = _optionalChain([ctx, 'optionalAccess', _4 => _4.resolvedModel]);
+  const health = _optionalChain([ctx, 'optionalAccess', _5 => _5.health]);
+  const report = _optionalChain([ctx, 'optionalAccess', _6 => _6.reportSelection]);
+  const now = _optionalChain([ctx, 'optionalAccess', _7 => _7.now]);
+  const resolvedModel = _optionalChain([ctx, 'optionalAccess', _8 => _8.resolvedModel]);
+  const preferredId = typeof _optionalChain([ctx, 'optionalAccess', _9 => _9.preferredAccountId]) === "string" && ctx.preferredAccountId.trim() !== "" ? ctx.preferredAccountId.trim() : void 0;
+  const preferredGroup = typeof _optionalChain([ctx, 'optionalAccess', _10 => _10.preferredAccountGroup]) === "string" && ctx.preferredAccountGroup.trim() !== "" ? ctx.preferredAccountGroup.trim() : void 0;
+  if (preferredId && ctx && ctx.boundAccountFallbackPolicy !== "pool") {
+    return resolveStrictPreferredToken(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 && _optionalChain([ctx, 'optionalAccess', _11 => _11.boundAccountFallbackPolicy]) !== "pool") {
+      throw new (0, _BoundAccountSelectionError.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 && _optionalChain([ctx, 'optionalAccess', _12 => _12.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 && _optionalChain([ctx, 'optionalAccess', _13 => _13.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 = _optionalChain([ctx, 'optionalAccess', _5 => _5.preferredAccountId]);
     if (preferredId) {
       const preferred = gated.find((a) => a.id === preferredId);
       if (preferred && preferred.schedulable !== false) {
         const preferredToken = await tokens.getAccessTokenForAccount(providerId, preferredId);
         if (preferredToken) {
           maybeTouchLastUsed(selector, tokens, providerId, preferredId);
-          _optionalChain([report, 'optionalCall', _6 => _6(preferredId, preferredId === activeAccountId, remapFor(preferredId))]);
+          _optionalChain([report, 'optionalCall', _14 => _14(preferredId, preferredId === activeAccountId, remapFor(preferredId))]);
           return preferredToken;
         }
       }
@@ -211,23 +344,39 @@ async function resolveSelectedToken(selector, tokens, providerId, sessionKey, ac
       const byId = await tokens.getAccessTokenForAccount(providerId, targetId);
       if (byId) {
         maybeTouchLastUsed(selector, tokens, providerId, targetId);
-        _optionalChain([report, 'optionalCall', _7 => _7(targetId, false, remapFor(targetId))]);
+        _optionalChain([report, 'optionalCall', _15 => _15(targetId, false, remapFor(targetId))]);
         return byId;
       }
       selector.evictAffinity(providerId, targetId);
-      _optionalChain([health, 'optionalAccess', _8 => _8.recordUpstreamOutcome, 'call', _9 => _9(providerId, targetId, { status: 401, now })]);
+      _optionalChain([health, 'optionalAccess', _16 => _16.recordUpstreamOutcome, 'call', _17 => _17(providerId, targetId, { status: 401, now })]);
       const remaining = gated.filter((a) => a.id !== targetId);
       const retryId = pickByIdTarget(selector, remaining, providerId, activeAccountId, sessionKey, now, poolGated);
       if (retryId !== void 0) {
         const retryToken = await tokens.getAccessTokenForAccount(providerId, retryId);
         if (retryToken) {
           maybeTouchLastUsed(selector, tokens, providerId, retryId);
-          _optionalChain([report, 'optionalCall', _10 => _10(retryId, false, remapFor(retryId))]);
+          _optionalChain([report, 'optionalCall', _18 => _18(retryId, false, remapFor(retryId))]);
           return retryToken;
         }
       }
     }
-    if (activeAccountId) _optionalChain([report, 'optionalCall', _11 => _11(activeAccountId, true, remapFor(activeAccountId))]);
+    if (activeAccountId) {
+      if (preferredGroup && _optionalChain([ctx, 'optionalAccess', _19 => _19.boundAccountFallbackPolicy]) !== "pool" && !candidates.some((account) => account.id === activeAccountId)) {
+        throw new (0, _BoundAccountSelectionError.BoundAccountSelectionError)(providerId, "unavailable");
+      }
+      const persistedActive = accounts.find((account) => account.id === activeAccountId);
+      if (_optionalChain([persistedActive, 'optionalAccess', _20 => _20.schedulable]) === false) return null;
+      const activeAllowance = _AccountAllowanceScheduling.getSharedAccountAllowanceScheduling.call(void 0, ).evaluate(
+        providerId,
+        activeAccountId,
+        _nullishCoalesce(_optionalChain([persistedActive, 'optionalAccess', _21 => _21.priority]), () => ( DEFAULT_ACCOUNT_PRIORITY)),
+        now
+      );
+      if (activeAllowance.action === "pause") {
+        throw new (0, _AccountAllowanceScheduling.AccountAllowanceExhaustedError)(providerId, activeAllowance.resumeAt);
+      }
+      _optionalChain([report, 'optionalCall', _22 => _22(activeAccountId, true, remapFor(activeAccountId))]);
+    }
     return activeGetter();
   }
   return activeGetter();
@@ -276,9 +425,16 @@ var OAuthBearerAuthStrategy = (_class2 = class {
       this.selector,
       this.tokens,
       this.providerId,
-      _optionalChain([hints, 'optionalAccess', _12 => _12.sessionKey]),
+      _optionalChain([hints, 'optionalAccess', _23 => _23.sessionKey]),
       () => this.resolveAccessToken(),
-      { health: this.health, reportSelection: _optionalChain([hints, 'optionalAccess', _13 => _13.reportSelection]), resolvedModel: _optionalChain([hints, 'optionalAccess', _14 => _14.resolvedModel]), preferredAccountId: _optionalChain([hints, 'optionalAccess', _15 => _15.preferredAccountId]) }
+      {
+        health: this.health,
+        reportSelection: _optionalChain([hints, 'optionalAccess', _24 => _24.reportSelection]),
+        resolvedModel: _optionalChain([hints, 'optionalAccess', _25 => _25.resolvedModel]),
+        preferredAccountId: _optionalChain([hints, 'optionalAccess', _26 => _26.preferredAccountId]),
+        preferredAccountGroup: _optionalChain([hints, 'optionalAccess', _27 => _27.preferredAccountGroup]),
+        boundAccountFallbackPolicy: _optionalChain([hints, 'optionalAccess', _28 => _28.boundAccountFallbackPolicy])
+      }
     );
     if (!token) {
       return;
@@ -300,7 +456,7 @@ var OAuthBearerAuthStrategy = (_class2 = class {
   async describeStatus() {
     const config = await this.tokens.getFullConfig();
     const entry = this.providerId === "codex" ? config.codex : config.gemini;
-    if (!_optionalChain([entry, 'optionalAccess', _16 => _16.accessToken])) {
+    if (!_optionalChain([entry, 'optionalAccess', _29 => _29.accessToken])) {
       return { providerId: this.providerId, ok: false, reason: "missing-credential" };
     }
     if (entry.status === "expired") {
@@ -317,7 +473,7 @@ var OAuthBearerAuthStrategy = (_class2 = class {
   async resolveAccessToken() {
     const config = await this.tokens.getFullConfig();
     const entry = this.providerId === "codex" ? config.codex : config.gemini;
-    if (!_optionalChain([entry, 'optionalAccess', _17 => _17.accessToken])) return null;
+    if (!_optionalChain([entry, 'optionalAccess', _30 => _30.accessToken])) return null;
     const expiresAtMs = entry.expiresAt ? new Date(entry.expiresAt).getTime() : 0;
     const expiringSoon = expiresAtMs > 0 && Date.now() >= expiresAtMs - REFRESH_LEAD_MS;
     if (expiringSoon && entry.refreshToken) {
@@ -327,7 +483,7 @@ var OAuthBearerAuthStrategy = (_class2 = class {
       if (!refreshed) return null;
       const fresh = await this.tokens.getFullConfig();
       const freshEntry = this.providerId === "codex" ? fresh.codex : fresh.gemini;
-      return _nullishCoalesce(_optionalChain([freshEntry, 'optionalAccess', _18 => _18.accessToken]), () => ( null));
+      return _nullishCoalesce(_optionalChain([freshEntry, 'optionalAccess', _31 => _31.accessToken]), () => ( null));
     }
     if (entry.status === "expired") return null;
     return entry.accessToken;
@@ -353,9 +509,16 @@ var PassThroughAuthStrategy = (_class3 = class {
       this.selector,
       this.tokens,
       "claude",
-      _optionalChain([hints, 'optionalAccess', _19 => _19.sessionKey]),
+      _optionalChain([hints, 'optionalAccess', _32 => _32.sessionKey]),
       () => this.tokens.getValidClaudeAccessToken(),
-      { health: this.health, reportSelection: _optionalChain([hints, 'optionalAccess', _20 => _20.reportSelection]), resolvedModel: _optionalChain([hints, 'optionalAccess', _21 => _21.resolvedModel]), preferredAccountId: _optionalChain([hints, 'optionalAccess', _22 => _22.preferredAccountId]) }
+      {
+        health: this.health,
+        reportSelection: _optionalChain([hints, 'optionalAccess', _33 => _33.reportSelection]),
+        resolvedModel: _optionalChain([hints, 'optionalAccess', _34 => _34.resolvedModel]),
+        preferredAccountId: _optionalChain([hints, 'optionalAccess', _35 => _35.preferredAccountId]),
+        preferredAccountGroup: _optionalChain([hints, 'optionalAccess', _36 => _36.preferredAccountGroup]),
+        boundAccountFallbackPolicy: _optionalChain([hints, 'optionalAccess', _37 => _37.boundAccountFallbackPolicy])
+      }
     );
     if (!token) return;
     headers["Authorization"] = `Bearer ${token}`;
@@ -375,7 +538,7 @@ var PassThroughAuthStrategy = (_class3 = class {
   async describeStatus() {
     const config = await this.tokens.getFullConfig();
     const claude = config.claude;
-    if (!_optionalChain([claude, 'optionalAccess', _23 => _23.accessToken])) {
+    if (!_optionalChain([claude, 'optionalAccess', _38 => _38.accessToken])) {
       return { providerId: "claude", ok: false, reason: "missing-credential" };
     }
     if (claude.status === "expired") {
@@ -431,15 +594,22 @@ var StaticBearerAuthStrategy = (_class5 = class {
       this.selector,
       this.tokens,
       "opencodego",
-      _optionalChain([hints, 'optionalAccess', _24 => _24.sessionKey]),
+      _optionalChain([hints, 'optionalAccess', _39 => _39.sessionKey]),
       () => this.tokens.getValidOpenCodeGoApiKey(),
-      { health: this.health, reportSelection: _optionalChain([hints, 'optionalAccess', _25 => _25.reportSelection]), resolvedModel: _optionalChain([hints, 'optionalAccess', _26 => _26.resolvedModel]), preferredAccountId: _optionalChain([hints, 'optionalAccess', _27 => _27.preferredAccountId]) }
+      {
+        health: this.health,
+        reportSelection: _optionalChain([hints, 'optionalAccess', _40 => _40.reportSelection]),
+        resolvedModel: _optionalChain([hints, 'optionalAccess', _41 => _41.resolvedModel]),
+        preferredAccountId: _optionalChain([hints, 'optionalAccess', _42 => _42.preferredAccountId]),
+        preferredAccountGroup: _optionalChain([hints, 'optionalAccess', _43 => _43.preferredAccountGroup]),
+        boundAccountFallbackPolicy: _optionalChain([hints, 'optionalAccess', _44 => _44.boundAccountFallbackPolicy])
+      }
     );
     if (!key) {
       return;
     }
     headers["Authorization"] = `Bearer ${key}`;
-    if (_optionalChain([hints, 'optionalAccess', _28 => _28.upstreamUrl, 'optionalAccess', _29 => _29.includes, 'call', _30 => _30(ANTHROPIC_SHAPE_PATH)])) {
+    if (_optionalChain([hints, 'optionalAccess', _45 => _45.upstreamUrl, 'optionalAccess', _46 => _46.includes, 'call', _47 => _47(ANTHROPIC_SHAPE_PATH)])) {
       headers["x-api-key"] = key;
     }
   }
@@ -449,7 +619,7 @@ var StaticBearerAuthStrategy = (_class5 = class {
   async describeStatus() {
     const config = await this.tokens.getFullConfig();
     const oc = config.opencodego;
-    if (!_optionalChain([oc, 'optionalAccess', _31 => _31.apiKey])) {
+    if (!_optionalChain([oc, 'optionalAccess', _48 => _48.apiKey])) {
       return { providerId: "opencodego", ok: false, reason: "missing-credential" };
     }
     if (oc.status === "error") {
@@ -523,31 +693,29 @@ var _GeminiCodeAssistTransformer = require('@omnicross/core/transformer/transfor
 
 // src/opencodego/CircuitBreaker.ts
 var CircuitBreaker = (_class7 = class {
-  __init12() {this.state = "closed"}
-  /** CONSECUTIVE failures while closed (reset by any closed success). */
-  __init13() {this.failureCount = 0}
-  /** Successes accumulated in the current half-open probe window. */
-  __init14() {this.successCount = 0}
-  /** Test calls admitted in the current half-open window (cap = halfOpenMaxCalls). */
-  __init15() {this.halfOpenCalls = 0}
-  /** `now()` at the last recorded failure — drives the open→half-open elapsed check. */
-  __init16() {this.lastFailureTime = 0}
-  
-  
+  __init12() {this.snapshot = {
+    mode: "closed",
+    consecutiveFailures: 0,
+    openedAt: 0,
+    probeAdmissions: 0,
+    probeSuccesses: 0
+  }}
   
   
-  constructor(opts = {}) {;_class7.prototype.__init12.call(this);_class7.prototype.__init13.call(this);_class7.prototype.__init14.call(this);_class7.prototype.__init15.call(this);_class7.prototype.__init16.call(this);
-    this.threshold = _nullishCoalesce(opts.threshold, () => ( 3));
-    this.openMs = _nullishCoalesce(opts.openMs, () => ( 3e4));
-    this.halfOpenMaxCalls = _nullishCoalesce(opts.halfOpenMaxCalls, () => ( 3));
+  constructor(opts = {}) {;_class7.prototype.__init12.call(this);
+    this.limits = {
+      threshold: _nullishCoalesce(opts.threshold, () => ( 3)),
+      openMs: _nullishCoalesce(opts.openMs, () => ( 3e4)),
+      halfOpenMaxCalls: _nullishCoalesce(opts.halfOpenMaxCalls, () => ( 3))
+    };
     this.now = _nullishCoalesce(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,74 +726,91 @@ var CircuitBreaker = (_class7 = 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;
     }
   }
 }, _class7);
 var CircuitBreakerRegistry = (_class8 = class {
-  constructor(options = {}) {;_class8.prototype.__init17.call(this);
+  constructor(options = {}) {;_class8.prototype.__init13.call(this);
     this.options = options;
   }
   
-  __init17() {this.breakers = /* @__PURE__ */ new Map()}
+  __init13() {this.breakers = /* @__PURE__ */ new Map()}
   /** Get (or lazily create) the breaker for a model id. */
   get(modelId) {
     let breaker = this.breakers.get(modelId);
@@ -665,8 +850,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: {
@@ -793,11 +977,11 @@ function resolveOpenCodeGoShape(entry) {
 function resolveOpenCodeGoHalf(modelId, config) {
   if (!config) return "go";
   for (const entry of Object.values(_nullishCoalesce(config.modelMap, () => ( {})))) {
-    if (_optionalChain([entry, 'optionalAccess', _32 => _32.modelId]) === modelId) return _nullishCoalesce(entry.provider, () => ( "go"));
+    if (_optionalChain([entry, 'optionalAccess', _49 => _49.modelId]) === modelId) return _nullishCoalesce(entry.provider, () => ( "go"));
   }
   for (const list of Object.values(_nullishCoalesce(config.fallbacks, () => ( {})))) {
     for (const entry of _nullishCoalesce(list, () => ( []))) {
-      if (_optionalChain([entry, 'optionalAccess', _33 => _33.modelId]) === modelId) return _nullishCoalesce(entry.provider, () => ( "go"));
+      if (_optionalChain([entry, 'optionalAccess', _50 => _50.modelId]) === modelId) return _nullishCoalesce(entry.provider, () => ( "go"));
     }
   }
   return "go";
@@ -805,67 +989,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"
@@ -897,7 +1058,7 @@ function hasBackgroundPattern(loweredSlices) {
   return containsAny(loweredSlices, BACKGROUND_KEYWORDS);
 }
 function resolveOpenCodeGoScenario(summary, config) {
-  const longContextThreshold = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _34 => _34.modelMap, 'optionalAccess', _35 => _35.long_context, 'optionalAccess', _36 => _36.contextThreshold]), () => ( DEFAULT_OPENCODEGO_LONG_CONTEXT_THRESHOLD));
+  const longContextThreshold = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _51 => _51.modelMap, 'optionalAccess', _52 => _52.long_context, 'optionalAccess', _53 => _53.contextThreshold]), () => ( DEFAULT_OPENCODEGO_LONG_CONTEXT_THRESHOLD));
   if (summary.estimatedInputTokens >= longContextThreshold) {
     return "long_context";
   }
@@ -921,7 +1082,7 @@ function opencodegoTransformerNamesForShape(shape) {
       return ["gemini"];
     case "chat":
     default:
-      return ["opencodego"];
+      return ["openai"];
   }
 }
 function resolveOpenCodeGoTarget(modelId, config) {
@@ -930,7 +1091,7 @@ function resolveOpenCodeGoTarget(modelId, config) {
   return { half, shape };
 }
 var SubscriptionProviderRegistry = (_class9 = class {
-  constructor(accounts, tokens) {;_class9.prototype.__init18.call(this);
+  constructor(accounts, tokens) {;_class9.prototype.__init14.call(this);
     this.accounts = accounts;
     this.tokens = tokens;
     const claude = this.accounts.getStrategy("claude");
@@ -976,7 +1137,7 @@ var SubscriptionProviderRegistry = (_class9 = 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,16 +1183,16 @@ var SubscriptionProviderRegistry = (_class9 = 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);
-            const override = half === "zen" ? _optionalChain([oc, 'optionalAccess', _37 => _37.zenBaseUrl]) : _optionalChain([oc, 'optionalAccess', _38 => _38.baseUrl]);
+            const override = half === "zen" ? _optionalChain([oc, 'optionalAccess', _54 => _54.zenBaseUrl]) : _optionalChain([oc, 'optionalAccess', _55 => _55.baseUrl]);
             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,11 +1202,11 @@ var SubscriptionProviderRegistry = (_class9 = class {
             const { shape } = resolveOpenCodeGoTarget(model, config);
             return opencodegoTransformerNamesForShape(shape);
           },
-          providerTransformerNames: ["opencodego"],
+          providerTransformerNames: ["openai"],
           modelTransformerNames: [],
           modelMapper: (sdkModel, summary, config) => {
             const scenario = resolveOpenCodeGoScenario(summary, config);
-            const entry = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _39 => _39.modelMap, 'optionalAccess', _40 => _40[scenario]]), () => ( _optionalChain([config, 'optionalAccess', _41 => _41.modelMap, 'optionalAccess', _42 => _42.default]))), () => ( DEFAULT_OPENCODEGO_MODEL_MAP[scenario])), () => ( DEFAULT_OPENCODEGO_MODEL_MAP.default));
+            const entry = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _56 => _56.modelMap, 'optionalAccess', _57 => _57[scenario]]), () => ( _optionalChain([config, 'optionalAccess', _58 => _58.modelMap, 'optionalAccess', _59 => _59.default]))), () => ( DEFAULT_OPENCODEGO_MODEL_MAP[scenario])), () => ( DEFAULT_OPENCODEGO_MODEL_MAP.default));
             if (!entry) {
               return { resolvedModel: sdkModel, scenario };
             }
@@ -1055,16 +1216,15 @@ var SubscriptionProviderRegistry = (_class9 = 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
           // wedge permanently in half-open). When NO circuit is open this returns
           // the same first non-attempted entry as the prior `!attempted` filter.
           nextFallback: (scenario, attempted, config) => {
-            const list = _nullishCoalesce(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _43 => _43.fallbacks, 'optionalAccess', _44 => _44[scenario]]), () => ( DEFAULT_OPENCODEGO_FALLBACKS[scenario])), () => ( []));
+            const list = _nullishCoalesce(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _60 => _60.fallbacks, 'optionalAccess', _61 => _61[scenario]]), () => ( DEFAULT_OPENCODEGO_FALLBACKS[scenario])), () => ( []));
             for (const entry of list) {
               if (attempted.includes(entry.modelId)) continue;
               if (this.breaker.allowRequest(entry.modelId)) return entry;
@@ -1091,11 +1251,11 @@ var SubscriptionProviderRegistry = (_class9 = 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.
    */
-  __init18() {this.breaker = new CircuitBreakerRegistry()}
+  __init14() {this.breaker = new CircuitBreakerRegistry()}
   /** Returns the dispatch profile for a known subscription provider, or
    *  `null` for unknown ids (callers must treat null as "fall back to the
    *  legacy LLM provider DB lookup"). */
@@ -1121,6 +1281,8 @@ function getSubscriptionProviderRegistry() {
 }
 
 // src/SubscriptionDispatcher.ts
+
+
 var _geminicodeassistresolver = require('@omnicross/core/ports/gemini-code-assist-resolver');
 
 
@@ -1165,7 +1327,7 @@ var SubscriptionDispatcher = class {
       scenario = mapped.scenario;
       req.anthropicBody.model = resolvedModel;
     }
-    const upstreamUrl = _optionalChain([this, 'access', _45 => _45.profile, 'access', _46 => _46.resolveUpstreamUrl, 'optionalCall', _47 => _47(resolvedModel, ocConfig)]);
+    const upstreamUrl = _optionalChain([this, 'access', _62 => _62.profile, 'access', _63 => _63.resolveUpstreamUrl, 'optionalCall', _64 => _64(resolvedModel, ocConfig)]);
     if (!upstreamUrl) {
       throw new Error(`[SubscriptionDispatcher] profile=${this.profile.providerId} missing resolveUpstreamUrl`);
     }
@@ -1197,7 +1359,7 @@ var SubscriptionDispatcher = class {
       );
       try {
         const upstream = await this.hooks.fetchWithRetry(upstreamUrl, headers, req.anthropicBody, currentModel);
-        _optionalChain([this, 'access', _48 => _48.profile, 'access', _49 => _49.recordModelOutcome, 'optionalCall', _50 => _50(currentModel, true)]);
+        _optionalChain([this, 'access', _65 => _65.profile, 'access', _66 => _66.recordModelOutcome, 'optionalCall', _67 => _67(currentModel, true)]);
         this.markHealth(usedAccountId, 200);
         await this.hooks.writeProxyResponse(req.res, upstream, req.isStream, req.reqId);
         return;
@@ -1206,7 +1368,7 @@ var SubscriptionDispatcher = class {
         if (handled.retryOnce) {
           try {
             const upstream = await this.hooks.fetchWithRetry(upstreamUrl, handled.headers, req.anthropicBody, currentModel);
-            _optionalChain([this, 'access', _51 => _51.profile, 'access', _52 => _52.recordModelOutcome, 'optionalCall', _53 => _53(currentModel, true)]);
+            _optionalChain([this, 'access', _68 => _68.profile, 'access', _69 => _69.recordModelOutcome, 'optionalCall', _70 => _70(currentModel, true)]);
             this.markHealth(usedAccountId, 200);
             await this.hooks.writeProxyResponse(req.res, upstream, req.isStream, req.reqId);
             return;
@@ -1216,10 +1378,10 @@ var SubscriptionDispatcher = class {
           }
         }
         if (caughtErrorBreakerOutcome(err) === "failure") {
-          _optionalChain([this, 'access', _54 => _54.profile, 'access', _55 => _55.recordModelOutcome, 'optionalCall', _56 => _56(currentModel, false)]);
+          _optionalChain([this, 'access', _71 => _71.profile, 'access', _72 => _72.recordModelOutcome, 'optionalCall', _73 => _73(currentModel, false)]);
         }
         this.markHealth(usedAccountId, errStatus(err), err);
-        const next = _optionalChain([this, 'access', _57 => _57.profile, 'access', _58 => _58.nextFallback, 'optionalCall', _59 => _59(scenario, attempted, ocConfig)]);
+        const next = _optionalChain([this, 'access', _74 => _74.profile, 'access', _75 => _75.nextFallback, 'optionalCall', _76 => _76(scenario, attempted, ocConfig)]);
         if (!next || attempted.length >= MAX_FALLBACK_ATTEMPTS_LOCAL) {
           throw err;
         }
@@ -1233,7 +1395,7 @@ var SubscriptionDispatcher = class {
   }
   /** Standard subscription transformer chain — Codex/Gemini/OpenCodeGo OpenAI-shape. */
   async dispatchTransformerChain(req, upstreamUrl, resolvedModel, scenario, ocConfig, sessionKey) {
-    const providerNames = _nullishCoalesce(_optionalChain([this, 'access', _60 => _60.profile, 'access', _61 => _61.resolveProviderTransformerNames, 'optionalCall', _62 => _62(resolvedModel, ocConfig)]), () => ( this.profile.providerTransformerNames));
+    const providerNames = _nullishCoalesce(_optionalChain([this, 'access', _77 => _77.profile, 'access', _78 => _78.resolveProviderTransformerNames, 'optionalCall', _79 => _79(resolvedModel, ocConfig)]), () => ( this.profile.providerTransformerNames));
     const providerTransformers = this.resolveTransformers(providerNames);
     const modelTransformers = this.resolveTransformers(this.profile.modelTransformerNames);
     const transformerProvider = {
@@ -1274,7 +1436,7 @@ var SubscriptionDispatcher = class {
       );
       try {
         const upstream = await this.hooks.fetchWithRetry(fetchUrl, headers, requestBody, currentModel);
-        _optionalChain([this, 'access', _63 => _63.profile, 'access', _64 => _64.recordModelOutcome, 'optionalCall', _65 => _65(currentModel, true)]);
+        _optionalChain([this, 'access', _80 => _80.profile, 'access', _81 => _81.recordModelOutcome, 'optionalCall', _82 => _82(currentModel, true)]);
         this.markHealth(usedAccountId, 200);
         const finalResponse = await this.hooks.executor.executeResponseChain(
           requestBody,
@@ -1290,7 +1452,7 @@ var SubscriptionDispatcher = class {
         if (handled.retryOnce) {
           try {
             const upstream = await this.hooks.fetchWithRetry(fetchUrl, handled.headers, requestBody, currentModel);
-            _optionalChain([this, 'access', _66 => _66.profile, 'access', _67 => _67.recordModelOutcome, 'optionalCall', _68 => _68(currentModel, true)]);
+            _optionalChain([this, 'access', _83 => _83.profile, 'access', _84 => _84.recordModelOutcome, 'optionalCall', _85 => _85(currentModel, true)]);
             this.markHealth(usedAccountId, 200);
             const finalResponse = await this.hooks.executor.executeResponseChain(
               requestBody,
@@ -1307,10 +1469,10 @@ var SubscriptionDispatcher = class {
           }
         }
         if (caughtErrorBreakerOutcome(err) === "failure") {
-          _optionalChain([this, 'access', _69 => _69.profile, 'access', _70 => _70.recordModelOutcome, 'optionalCall', _71 => _71(currentModel, false)]);
+          _optionalChain([this, 'access', _86 => _86.profile, 'access', _87 => _87.recordModelOutcome, 'optionalCall', _88 => _88(currentModel, false)]);
         }
         this.markHealth(usedAccountId, errStatus(err), err);
-        const next = _optionalChain([this, 'access', _72 => _72.profile, 'access', _73 => _73.nextFallback, 'optionalCall', _74 => _74(scenario, attempted, ocConfig)]);
+        const next = _optionalChain([this, 'access', _89 => _89.profile, 'access', _90 => _90.nextFallback, 'optionalCall', _91 => _91(scenario, attempted, ocConfig)]);
         if (!next || attempted.length >= MAX_FALLBACK_ATTEMPTS_LOCAL) {
           throw err;
         }
@@ -1340,7 +1502,7 @@ var SubscriptionDispatcher = class {
       return { firstModel: primaryModel, attempted: [] };
     }
     const skipped = [primaryModel];
-    const firstAdmitting = _optionalChain([this, 'access', _75 => _75.profile, 'access', _76 => _76.nextFallback, 'optionalCall', _77 => _77(scenario, skipped, ocConfig)]);
+    const firstAdmitting = _optionalChain([this, 'access', _92 => _92.profile, 'access', _93 => _93.nextFallback, 'optionalCall', _94 => _94(scenario, skipped, ocConfig)]);
     if (firstAdmitting) {
       console.warn(
         `[AgentProxy:subscription] opencodego primary ${primaryModel} circuit open -> first admitting fallback ${firstAdmitting.modelId}`
@@ -1358,7 +1520,7 @@ var SubscriptionDispatcher = class {
    * successfully (caller should retry once); otherwise re-throws.
    */
   async maybeRetryAfterError(err, headers, req, resolvedModel, sessionKey) {
-    const status = _nullishCoalesce(_optionalChain([err, 'optionalAccess', _78 => _78.status]), () => ( 0));
+    const status = _nullishCoalesce(_optionalChain([err, 'optionalAccess', _95 => _95.status]), () => ( 0));
     if (status !== 401) {
       return { retryOnce: false, headers };
     }
@@ -1378,6 +1540,7 @@ var SubscriptionDispatcher = class {
     try {
       await this.profile.authStrategy.applyHeaders(headers, hints);
     } catch (err) {
+      if (_AccountAllowanceScheduling.isAccountAllowanceExhaustedError.call(void 0, err) || _BoundAccountSelectionError.isBoundAccountSelectionError.call(void 0, err)) throw err;
       console.warn("[AgentProxy:subscription] authStrategy.applyHeaders threw:", _serializeError.serializeError.call(void 0, err));
     }
   }
@@ -1480,11 +1643,11 @@ var SubscriptionDispatcher = class {
 };
 var MAX_FALLBACK_ATTEMPTS_LOCAL = 3;
 function errStatus(err) {
-  const status = _optionalChain([err, 'optionalAccess', _79 => _79.status]);
+  const status = _optionalChain([err, 'optionalAccess', _96 => _96.status]);
   return typeof status === "number" ? status : null;
 }
 function errHeaders(err) {
-  const h = _optionalChain([err, 'optionalAccess', _80 => _80.headers]);
+  const h = _optionalChain([err, 'optionalAccess', _97 => _97.headers]);
   if (!h) return void 0;
   if (typeof h.get === "function") return h;
   if (typeof h === "object") return h;
@@ -1492,11 +1655,11 @@ function errHeaders(err) {
 }
 function errBodyText(err) {
   const e = err;
-  const raw = typeof _optionalChain([e, 'optionalAccess', _81 => _81.bodyText]) === "string" ? e.bodyText : typeof _optionalChain([e, 'optionalAccess', _82 => _82.body]) === "string" ? e.body : void 0;
-  return _optionalChain([raw, 'optionalAccess', _83 => _83.slice, 'call', _84 => _84(0, 2048)]);
+  const raw = typeof _optionalChain([e, 'optionalAccess', _98 => _98.bodyText]) === "string" ? e.bodyText : typeof _optionalChain([e, 'optionalAccess', _99 => _99.body]) === "string" ? e.body : void 0;
+  return _optionalChain([raw, 'optionalAccess', _100 => _100.slice, 'call', _101 => _101(0, 2048)]);
 }
 function caughtErrorBreakerOutcome(err) {
-  const status = _optionalChain([err, 'optionalAccess', _85 => _85.status]);
+  const status = _optionalChain([err, 'optionalAccess', _102 => _102.status]);
   if (typeof status !== "number") return "failure";
   if (status === 0) return "neutral";
   if (status >= 500 || status === 429) return "failure";