@omnicross/subscriptions 0.1.2 → 0.1.4

package/dist/index.cjs

@@ -1,29 +1,293 @@
-"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; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await 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; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9;
 
 
 
 var _chunkTPW5Q25Ycjs = require('./chunk-TPW5Q25Y.cjs');
 
+// src/scheduler/SubscriptionAccountSelector.ts
+var SESSION_AFFINITY_TTL_MS = 36e5;
+var LAST_USED_PERSIST_THROTTLE_MS = 6e4;
+var DEFAULT_ACCOUNT_PRIORITY = 50;
+function scopedKey(providerId, tail) {
+  return `${providerId}\0${tail}`;
+}
+function parseIso(iso) {
+  if (!iso) return 0;
+  const ms = Date.parse(iso);
+  return Number.isNaN(ms) ? 0 : ms;
+}
+var SubscriptionAccountSelector = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this); }
+  /** `providerId\0accountId → live lastUsedAt ms` (authoritative tie-break). */
+  __init() {this.lastUsedOverlay = /* @__PURE__ */ new Map()}
+  /** `providerId\0sessionKey → { accountId, expiresAt }`. */
+  __init2() {this.affinity = /* @__PURE__ */ new Map()}
+  /** `providerId\0accountId → last durable-persist ms` (throttle state). */
+  __init3() {this.lastPersist = /* @__PURE__ */ new Map()}
+  /**
+   * Choose the account to serve this request, or `null` when there are ≤ 1
+   * schedulable accounts (the zero-regression signal — caller uses the active
+   * account). Updates the live `lastUsedAt` overlay for the chosen account and,
+   * when a `sessionKey` is given, records/extends the affinity mapping.
+   */
+  select(input) {
+    const now = _nullishCoalesce(input.now, () => ( Date.now()));
+    const schedulable = input.accounts.filter((a) => a.schedulable !== false);
+    if (schedulable.length <= 1) return null;
+    if (input.sessionKey) {
+      const aKey = scopedKey(input.providerId, input.sessionKey);
+      const hit = this.affinity.get(aKey);
+      if (hit && hit.expiresAt > now && schedulable.some((a) => a.id === hit.accountId)) {
+        hit.expiresAt = now + SESSION_AFFINITY_TTL_MS;
+        this.markUsed(input.providerId, hit.accountId, now);
+        return { accountId: hit.accountId, isActive: hit.accountId === input.activeAccountId };
+      }
+    }
+    const chosen = this.pickOrdered(input.providerId, schedulable);
+    this.markUsed(input.providerId, chosen.id, now);
+    if (input.sessionKey) {
+      this.affinity.set(scopedKey(input.providerId, input.sessionKey), {
+        accountId: chosen.id,
+        expiresAt: now + SESSION_AFFINITY_TTL_MS
+      });
+    }
+    return { accountId: chosen.id, isActive: chosen.id === input.activeAccountId };
+  }
+  /**
+   * Drop every session-affinity mapping bound to this account (subscription-account-
+   * health, task 4.1). Called when a selected account's by-id token turns out
+   * null/invalid or an affinity-bound account becomes unhealthy, so the next
+   * selection for those sessions picks a fresh account instead of re-sticking to
+   * the bad one. O(affinity entries) — the map is tiny (one entry per live
+   * conversation).
+   */
+  evictAffinity(providerId, accountId) {
+    const prefix = `${providerId} `;
+    for (const [key, entry] of this.affinity) {
+      if (entry.accountId === accountId && key.startsWith(prefix)) {
+        this.affinity.delete(key);
+      }
+    }
+  }
+  /**
+   * Whether a best-effort `lastUsedAt` durable persist is DUE for this account
+   * (≥ `LAST_USED_PERSIST_THROTTLE_MS` since the last one). Records the persist
+   * time when it returns `true`, so the strategy calls `touchAccountLastUsed`
+   * sparingly and the request hot path does not rewrite the store every request.
+   */
+  duePersist(providerId, accountId, now = Date.now()) {
+    const key = scopedKey(providerId, accountId);
+    const last = _nullishCoalesce(this.lastPersist.get(key), () => ( 0));
+    if (now - last < LAST_USED_PERSIST_THROTTLE_MS) return false;
+    this.lastPersist.set(key, now);
+    return true;
+  }
+  /** Sort by `priority` asc → effective `lastUsedAt` asc → `createdAt` asc → `[0]`. */
+  pickOrdered(providerId, accounts) {
+    const ranked = accounts.map((account) => ({
+      account,
+      priority: _nullishCoalesce(account.priority, () => ( DEFAULT_ACCOUNT_PRIORITY)),
+      lastUsed: this.effectiveLastUsed(providerId, account),
+      created: parseIso(account.createdAt)
+    }));
+    ranked.sort(
+      (x, y) => x.priority - y.priority || x.lastUsed - y.lastUsed || x.created - y.created
+    );
+    return ranked[0].account;
+  }
+  /** The live tie-break value: the in-memory overlay when set, else the persisted
+   *  `lastUsedAt` (0 when absent). */
+  effectiveLastUsed(providerId, account) {
+    const overlay = this.lastUsedOverlay.get(scopedKey(providerId, account.id));
+    return _nullishCoalesce(overlay, () => ( parseIso(account.lastUsedAt)));
+  }
+  markUsed(providerId, accountId, now) {
+    this.lastUsedOverlay.set(scopedKey(providerId, accountId), now);
+  }
+}, _class);
+
+// src/SubscriptionAccountService.ts
+var _SubscriptionAccountHealth = require('@omnicross/core/pipeline/SubscriptionAccountHealth');
+
+// src/scheduler/accountModelMap.ts
+function canonicalModelId(value) {
+  const idx = value.indexOf(",");
+  const bare = idx >= 0 ? value.slice(idx + 1) : value;
+  return bare.trim().toLowerCase();
+}
+function accountSupportsModel(supportedModels, model) {
+  if (!supportedModels) return true;
+  const target = canonicalModelId(model);
+  if (Array.isArray(supportedModels)) {
+    return supportedModels.some((m) => canonicalModelId(m) === target);
+  }
+  return Object.keys(supportedModels).some((k) => canonicalModelId(k) === target);
+}
+function remapForAccount(supportedModels, model) {
+  if (!supportedModels || Array.isArray(supportedModels)) return model;
+  const target = canonicalModelId(model);
+  for (const [key, actual] of Object.entries(supportedModels)) {
+    if (canonicalModelId(key) === target) return actual;
+  }
+  return model;
+}
+function remapReportForAccount(supportedModels, model) {
+  if (!model) return void 0;
+  const remapped = remapForAccount(supportedModels, model);
+  return remapped === model ? void 0 : remapped;
+}
+
+// src/scheduler/accountSelection.ts
+var ACCOUNTS_KEY = {
+  claude: "claudeAccounts",
+  codex: "codexAccounts",
+  gemini: "geminiAccounts",
+  opencodego: "opencodegoAccounts"
+};
+var ACTIVE_KEY = {
+  claude: "activeClaudeAccountId",
+  codex: "activeCodexAccountId",
+  gemini: "activeGeminiAccountId",
+  opencodego: "activeOpencodegoAccountId"
+};
+function gateSchedulable(accounts, providerId, health, now, resolvedModel, supportedModelsById) {
+  if (!health && !resolvedModel || accounts.length < 2) return accounts;
+  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 };
+  });
+}
+function isPoolGated(accounts, health, resolvedModel) {
+  return (health !== void 0 || resolvedModel !== void 0) && accounts.length >= 2;
+}
+function readSchedulableAccounts(config, providerId) {
+  const raw = _nullishCoalesce(config[ACCOUNTS_KEY[providerId]], () => ( []));
+  const accounts = raw.map((a) => ({
+    id: a.id,
+    priority: a.priority,
+    lastUsedAt: a.lastUsedAt,
+    createdAt: a.createdAt
+  }));
+  const supportedModelsById = new Map(
+    raw.map((a) => [a.id, a.supportedModels])
+  );
+  const activeAccountId = config[ACTIVE_KEY[providerId]];
+  return { accounts, activeAccountId, supportedModelsById };
+}
+function pickByIdTarget(selector, gated, providerId, activeAccountId, sessionKey, now, healthGated) {
+  const selection = selector.select({ providerId, accounts: gated, activeAccountId, sessionKey, now });
+  if (selection && !selection.isActive) return selection.accountId;
+  if (selection === null && healthGated) {
+    const schedulable = gated.filter((a) => a.schedulable !== false);
+    if (schedulable.length === 1 && schedulable[0].id !== activeAccountId) return schedulable[0].id;
+  }
+  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]);
+  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 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))]);
+          return preferredToken;
+        }
+      }
+    }
+    const targetId = pickByIdTarget(selector, gated, providerId, activeAccountId, sessionKey, now, poolGated);
+    if (targetId !== void 0) {
+      const byId = await tokens.getAccessTokenForAccount(providerId, targetId);
+      if (byId) {
+        maybeTouchLastUsed(selector, tokens, providerId, targetId);
+        _optionalChain([report, 'optionalCall', _7 => _7(targetId, false, remapFor(targetId))]);
+        return byId;
+      }
+      selector.evictAffinity(providerId, targetId);
+      _optionalChain([health, 'optionalAccess', _8 => _8.recordUpstreamOutcome, 'call', _9 => _9(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))]);
+          return retryToken;
+        }
+      }
+    }
+    if (activeAccountId) _optionalChain([report, 'optionalCall', _11 => _11(activeAccountId, true, remapFor(activeAccountId))]);
+    return activeGetter();
+  }
+  return activeGetter();
+}
+function maybeTouchLastUsed(selector, tokens, providerId, accountId) {
+  if (!tokens.touchAccountLastUsed) return;
+  if (!selector.duePersist(providerId, accountId)) return;
+  void tokens.touchAccountLastUsed(providerId, accountId, (/* @__PURE__ */ new Date()).toISOString()).catch(() => {
+  });
+}
+async function refreshSelectedAccount(selector, tokens, mutex, providerId, sessionKey) {
+  if (!sessionKey || !selector || !tokens.refreshAccountToken) return null;
+  const config = await tokens.getFullConfig();
+  const { accounts, activeAccountId } = readSchedulableAccounts(config, providerId);
+  const selection = selector.select({ providerId, accounts, activeAccountId, sessionKey });
+  if (!selection || selection.isActive) return null;
+  const accountId = selection.accountId;
+  return mutex.run(`${providerId}:${accountId}`, async () => {
+    try {
+      return await _asyncNullishCoalesce(await tokens.refreshAccountToken(providerId, accountId), async () => ( false));
+    } catch (err) {
+      console.warn(`[accountSelection] ${providerId}:${accountId} by-id refresh failed:`, err);
+      return false;
+    }
+  });
+}
+
 // src/auth/OAuthBearerAuthStrategy.ts
 var REFRESH_LEAD_MS = 5 * 6e4;
-var OAuthBearerAuthStrategy = (_class = class {
-  constructor(providerId, tokens, mutex) {;_class.prototype.__init.call(this);
+var OAuthBearerAuthStrategy = (_class2 = class {
+  constructor(providerId, tokens, mutex, selector, health) {;_class2.prototype.__init4.call(this);
     this.tokens = tokens;
     this.mutex = mutex;
+    this.selector = selector;
+    this.health = health;
     this.providerId = providerId;
   }
   
   
-  __init() {this.kind = "oauth-bearer"}
   
-  async applyHeaders(headers, _hints) {
-    const token = await this.resolveAccessToken();
+  
+  __init4() {this.kind = "oauth-bearer"}
+  
+  async applyHeaders(headers, hints) {
+    const token = await resolveSelectedToken(
+      this.selector,
+      this.tokens,
+      this.providerId,
+      _optionalChain([hints, 'optionalAccess', _12 => _12.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]) }
+    );
     if (!token) {
       return;
     }
     headers["Authorization"] = `Bearer ${token}`;
   }
-  async onUnauthorized() {
+  async onUnauthorized(sessionKey) {
+    const byId = await refreshSelectedAccount(this.selector, this.tokens, this.mutex, this.providerId, sessionKey);
+    if (byId !== null) return byId;
     return this.mutex.run(`${this.providerId}:refresh`, async () => {
       try {
         return this.providerId === "codex" ? await this.tokens.refreshCodexToken() : await this.tokens.refreshGeminiToken();
@@ -36,7 +300,7 @@ var OAuthBearerAuthStrategy = (_class = class {
   async describeStatus() {
     const config = await this.tokens.getFullConfig();
     const entry = this.providerId === "codex" ? config.codex : config.gemini;
-    if (!_optionalChain([entry, 'optionalAccess', _ => _.accessToken])) {
+    if (!_optionalChain([entry, 'optionalAccess', _16 => _16.accessToken])) {
       return { providerId: this.providerId, ok: false, reason: "missing-credential" };
     }
     if (entry.status === "expired") {
@@ -53,7 +317,7 @@ var OAuthBearerAuthStrategy = (_class = class {
   async resolveAccessToken() {
     const config = await this.tokens.getFullConfig();
     const entry = this.providerId === "codex" ? config.codex : config.gemini;
-    if (!_optionalChain([entry, 'optionalAccess', _2 => _2.accessToken])) return null;
+    if (!_optionalChain([entry, 'optionalAccess', _17 => _17.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) {
@@ -63,29 +327,42 @@ var OAuthBearerAuthStrategy = (_class = 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', _3 => _3.accessToken]), () => ( null));
+      return _nullishCoalesce(_optionalChain([freshEntry, 'optionalAccess', _18 => _18.accessToken]), () => ( null));
     }
     if (entry.status === "expired") return null;
     return entry.accessToken;
   }
-}, _class);
+}, _class2);
 
 // src/auth/PassThroughAuthStrategy.ts
-var PassThroughAuthStrategy = (_class2 = class {
-  constructor(tokens, mutex) {;_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);
+var PassThroughAuthStrategy = (_class3 = class {
+  constructor(tokens, mutex, selector, health) {;_class3.prototype.__init5.call(this);_class3.prototype.__init6.call(this);
     this.tokens = tokens;
     this.mutex = mutex;
+    this.selector = selector;
+    this.health = health;
   }
   
   
-  __init2() {this.kind = "pass-through"}
-  __init3() {this.providerId = "claude"}
-  async applyHeaders(headers, _hints) {
-    const token = await this.tokens.getValidClaudeAccessToken();
+  
+  
+  __init5() {this.kind = "pass-through"}
+  __init6() {this.providerId = "claude"}
+  async applyHeaders(headers, hints) {
+    const token = await resolveSelectedToken(
+      this.selector,
+      this.tokens,
+      "claude",
+      _optionalChain([hints, 'optionalAccess', _19 => _19.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]) }
+    );
     if (!token) return;
     headers["Authorization"] = `Bearer ${token}`;
   }
-  async onUnauthorized() {
+  async onUnauthorized(sessionKey) {
+    const byId = await refreshSelectedAccount(this.selector, this.tokens, this.mutex, "claude", sessionKey);
+    if (byId !== null) return byId;
     return this.mutex.run("claude:refresh", async () => {
       try {
         return await this.tokens.refreshClaudeToken();
@@ -98,7 +375,7 @@ var PassThroughAuthStrategy = (_class2 = class {
   async describeStatus() {
     const config = await this.tokens.getFullConfig();
     const claude = config.claude;
-    if (!_optionalChain([claude, 'optionalAccess', _4 => _4.accessToken])) {
+    if (!_optionalChain([claude, 'optionalAccess', _23 => _23.accessToken])) {
       return { providerId: "claude", ok: false, reason: "missing-credential" };
     }
     if (claude.status === "expired") {
@@ -111,11 +388,11 @@ var PassThroughAuthStrategy = (_class2 = class {
     }
     return { providerId: "claude", ok: true, expiresAt: claude.expiresAt };
   }
-}, _class2);
+}, _class3);
 
 // src/auth/RefreshMutex.ts
-var RefreshMutex = (_class3 = class {constructor() { _class3.prototype.__init4.call(this); }
-  __init4() {this.inflight = /* @__PURE__ */ new Map()}
+var RefreshMutex = (_class4 = class {constructor() { _class4.prototype.__init7.call(this); }
+  __init7() {this.inflight = /* @__PURE__ */ new Map()}
   /**
    * Run `task()` exclusively for `key`. If another caller is already running
    * for the same key, this call awaits the existing promise instead of
@@ -134,34 +411,45 @@ var RefreshMutex = (_class3 = class {constructor() { _class3.prototype.__init4.c
     this.inflight.set(key, promise);
     return promise;
   }
-}, _class3);
+}, _class4);
 
 // src/auth/StaticBearerAuthStrategy.ts
 var ANTHROPIC_SHAPE_PATH = "/v1/messages";
-var StaticBearerAuthStrategy = (_class4 = class {
-  constructor(tokens) {;_class4.prototype.__init5.call(this);_class4.prototype.__init6.call(this);
+var StaticBearerAuthStrategy = (_class5 = class {
+  constructor(tokens, selector, health) {;_class5.prototype.__init8.call(this);_class5.prototype.__init9.call(this);
     this.tokens = tokens;
+    this.selector = selector;
+    this.health = health;
   }
   
-  __init5() {this.kind = "static-bearer"}
-  __init6() {this.providerId = "opencodego"}
+  
+  
+  __init8() {this.kind = "static-bearer"}
+  __init9() {this.providerId = "opencodego"}
   async applyHeaders(headers, hints) {
-    const key = await this.tokens.getValidOpenCodeGoApiKey();
+    const key = await resolveSelectedToken(
+      this.selector,
+      this.tokens,
+      "opencodego",
+      _optionalChain([hints, 'optionalAccess', _24 => _24.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]) }
+    );
     if (!key) {
       return;
     }
     headers["Authorization"] = `Bearer ${key}`;
-    if (_optionalChain([hints, 'optionalAccess', _5 => _5.upstreamUrl, 'optionalAccess', _6 => _6.includes, 'call', _7 => _7(ANTHROPIC_SHAPE_PATH)])) {
+    if (_optionalChain([hints, 'optionalAccess', _28 => _28.upstreamUrl, 'optionalAccess', _29 => _29.includes, 'call', _30 => _30(ANTHROPIC_SHAPE_PATH)])) {
       headers["x-api-key"] = key;
     }
   }
-  async onUnauthorized() {
+  async onUnauthorized(_sessionKey) {
     return false;
   }
   async describeStatus() {
     const config = await this.tokens.getFullConfig();
     const oc = config.opencodego;
-    if (!_optionalChain([oc, 'optionalAccess', _8 => _8.apiKey])) {
+    if (!_optionalChain([oc, 'optionalAccess', _31 => _31.apiKey])) {
       return { providerId: "opencodego", ok: false, reason: "missing-credential" };
     }
     if (oc.status === "error") {
@@ -169,7 +457,7 @@ var StaticBearerAuthStrategy = (_class4 = class {
     }
     return { providerId: "opencodego", ok: true };
   }
-}, _class4);
+}, _class5);
 
 // src/SubscriptionAccountService.ts
 var DISPLAY_NAMES = {
@@ -178,15 +466,19 @@ var DISPLAY_NAMES = {
   gemini: "Gemini (Google OAuth)",
   opencodego: "OpenCodeGo (Bearer key)"
 };
-var SubscriptionAccountService = (_class5 = class {
-  __init7() {this.mutex = new RefreshMutex()}
+var SubscriptionAccountService = (_class6 = class {
+  __init10() {this.mutex = new RefreshMutex()}
+  /** ONE account-pool scheduler (subscription-account-scheduling) shared by all
+   *  four strategies so they share the affinity map + the `lastUsedAt` overlay. */
+  __init11() {this.selector = new SubscriptionAccountSelector()}
   
-  constructor(tokens) {;_class5.prototype.__init7.call(this);
+  constructor(tokens) {;_class6.prototype.__init10.call(this);_class6.prototype.__init11.call(this);
+    const health = _SubscriptionAccountHealth.getSharedAccountHealth.call(void 0, );
     this.strategies = /* @__PURE__ */ new Map([
-      ["claude", new PassThroughAuthStrategy(tokens, this.mutex)],
-      ["codex", new OAuthBearerAuthStrategy("codex", tokens, this.mutex)],
-      ["gemini", new OAuthBearerAuthStrategy("gemini", tokens, this.mutex)],
-      ["opencodego", new StaticBearerAuthStrategy(tokens)]
+      ["claude", new PassThroughAuthStrategy(tokens, this.mutex, this.selector, health)],
+      ["codex", new OAuthBearerAuthStrategy("codex", tokens, this.mutex, this.selector, health)],
+      ["gemini", new OAuthBearerAuthStrategy("gemini", tokens, this.mutex, this.selector, health)],
+      ["opencodego", new StaticBearerAuthStrategy(tokens, this.selector, health)]
     ]);
   }
   /** Returns the strategy bound to a subscription provider, or `null` for unknown ids. */
@@ -214,7 +506,7 @@ var SubscriptionAccountService = (_class5 = class {
     }
     return entries;
   }
-}, _class5);
+}, _class6);
 var _moduleSingleton = null;
 function setSubscriptionAccountService(svc) {
   _moduleSingleton = svc;
@@ -230,21 +522,21 @@ var _subscriptionRegistryPort = require('@omnicross/core/outbound-api/subscripti
 var _GeminiCodeAssistTransformer = require('@omnicross/core/transformer/transformers/GeminiCodeAssistTransformer');
 
 // src/opencodego/CircuitBreaker.ts
-var CircuitBreaker = (_class6 = class {
-  __init8() {this.state = "closed"}
+var CircuitBreaker = (_class7 = class {
+  __init12() {this.state = "closed"}
   /** CONSECUTIVE failures while closed (reset by any closed success). */
-  __init9() {this.failureCount = 0}
+  __init13() {this.failureCount = 0}
   /** Successes accumulated in the current half-open probe window. */
-  __init10() {this.successCount = 0}
+  __init14() {this.successCount = 0}
   /** Test calls admitted in the current half-open window (cap = halfOpenMaxCalls). */
-  __init11() {this.halfOpenCalls = 0}
+  __init15() {this.halfOpenCalls = 0}
   /** `now()` at the last recorded failure — drives the open→half-open elapsed check. */
-  __init12() {this.lastFailureTime = 0}
+  __init16() {this.lastFailureTime = 0}
   
   
   
   
-  constructor(opts = {}) {;_class6.prototype.__init8.call(this);_class6.prototype.__init9.call(this);_class6.prototype.__init10.call(this);_class6.prototype.__init11.call(this);_class6.prototype.__init12.call(this);
+  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));
@@ -327,13 +619,13 @@ var CircuitBreaker = (_class6 = class {
       this.state = "open";
     }
   }
-}, _class6);
-var CircuitBreakerRegistry = (_class7 = class {
-  constructor(options = {}) {;_class7.prototype.__init13.call(this);
+}, _class7);
+var CircuitBreakerRegistry = (_class8 = class {
+  constructor(options = {}) {;_class8.prototype.__init17.call(this);
     this.options = options;
   }
   
-  __init13() {this.breakers = /* @__PURE__ */ new Map()}
+  __init17() {this.breakers = /* @__PURE__ */ new Map()}
   /** Get (or lazily create) the breaker for a model id. */
   get(modelId) {
     let breaker = this.breakers.get(modelId);
@@ -355,7 +647,7 @@ var CircuitBreakerRegistry = (_class7 = class {
   recordFailure(modelId) {
     this.get(modelId).recordFailure();
   }
-}, _class7);
+}, _class8);
 
 // src/opencodego/defaults.ts
 var DEFAULT_OPENCODEGO_LONG_CONTEXT_THRESHOLD = 8e4;
@@ -501,11 +793,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', _9 => _9.modelId]) === modelId) return _nullishCoalesce(entry.provider, () => ( "go"));
+    if (_optionalChain([entry, 'optionalAccess', _32 => _32.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', _10 => _10.modelId]) === modelId) return _nullishCoalesce(entry.provider, () => ( "go"));
+      if (_optionalChain([entry, 'optionalAccess', _33 => _33.modelId]) === modelId) return _nullishCoalesce(entry.provider, () => ( "go"));
     }
   }
   return "go";
@@ -605,7 +897,7 @@ function hasBackgroundPattern(loweredSlices) {
   return containsAny(loweredSlices, BACKGROUND_KEYWORDS);
 }
 function resolveOpenCodeGoScenario(summary, config) {
-  const longContextThreshold = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _11 => _11.modelMap, 'optionalAccess', _12 => _12.long_context, 'optionalAccess', _13 => _13.contextThreshold]), () => ( DEFAULT_OPENCODEGO_LONG_CONTEXT_THRESHOLD));
+  const longContextThreshold = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _34 => _34.modelMap, 'optionalAccess', _35 => _35.long_context, 'optionalAccess', _36 => _36.contextThreshold]), () => ( DEFAULT_OPENCODEGO_LONG_CONTEXT_THRESHOLD));
   if (summary.estimatedInputTokens >= longContextThreshold) {
     return "long_context";
   }
@@ -637,8 +929,8 @@ function resolveOpenCodeGoTarget(modelId, config) {
   const shape = resolveOpenCodeGoShape({ provider: half, modelId });
   return { half, shape };
 }
-var SubscriptionProviderRegistry = (_class8 = class {
-  constructor(accounts, tokens) {;_class8.prototype.__init14.call(this);
+var SubscriptionProviderRegistry = (_class9 = class {
+  constructor(accounts, tokens) {;_class9.prototype.__init18.call(this);
     this.accounts = accounts;
     this.tokens = tokens;
     const claude = this.accounts.getStrategy("claude");
@@ -735,7 +1027,7 @@ var SubscriptionProviderRegistry = (_class8 = class {
           resolveUpstreamUrl: (model, config) => {
             const oc = config;
             const { half, shape } = resolveOpenCodeGoTarget(model, oc);
-            const override = half === "zen" ? _optionalChain([oc, 'optionalAccess', _14 => _14.zenBaseUrl]) : _optionalChain([oc, 'optionalAccess', _15 => _15.baseUrl]);
+            const override = half === "zen" ? _optionalChain([oc, 'optionalAccess', _37 => _37.zenBaseUrl]) : _optionalChain([oc, 'optionalAccess', _38 => _38.baseUrl]);
             return buildOpenCodeGoUrl(half, shape, override);
           },
           // zen seam (Decision 3): vary the provider transformer chain by resolved
@@ -753,7 +1045,7 @@ var SubscriptionProviderRegistry = (_class8 = class {
           modelTransformerNames: [],
           modelMapper: (sdkModel, summary, config) => {
             const scenario = resolveOpenCodeGoScenario(summary, config);
-            const entry = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _16 => _16.modelMap, 'optionalAccess', _17 => _17[scenario]]), () => ( _optionalChain([config, 'optionalAccess', _18 => _18.modelMap, 'optionalAccess', _19 => _19.default]))), () => ( DEFAULT_OPENCODEGO_MODEL_MAP[scenario])), () => ( DEFAULT_OPENCODEGO_MODEL_MAP.default));
+            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));
             if (!entry) {
               return { resolvedModel: sdkModel, scenario };
             }
@@ -772,7 +1064,7 @@ var SubscriptionProviderRegistry = (_class8 = class {
           // 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', _20 => _20.fallbacks, 'optionalAccess', _21 => _21[scenario]]), () => ( DEFAULT_OPENCODEGO_FALLBACKS[scenario])), () => ( []));
+            const list = _nullishCoalesce(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _43 => _43.fallbacks, 'optionalAccess', _44 => _44[scenario]]), () => ( DEFAULT_OPENCODEGO_FALLBACKS[scenario])), () => ( []));
             for (const entry of list) {
               if (attempted.includes(entry.modelId)) continue;
               if (this.breaker.allowRequest(entry.modelId)) return entry;
@@ -803,7 +1095,7 @@ var SubscriptionProviderRegistry = (_class8 = class {
    * exactly the reference's long-lived `FallbackHandler`. Constructed with the
    * default reference thresholds (3 / 30s / 3) and the default `Date.now` clock.
    */
-  __init14() {this.breaker = new CircuitBreakerRegistry()}
+  __init18() {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"). */
@@ -818,7 +1110,7 @@ var SubscriptionProviderRegistry = (_class8 = class {
     const full = await this.tokens.getFullConfig();
     return full.opencodego;
   }
-}, _class8);
+}, _class9);
 var _moduleSingleton2 = null;
 function setSubscriptionProviderRegistry(svc) {
   _moduleSingleton2 = svc;
@@ -830,6 +1122,10 @@ function getSubscriptionProviderRegistry() {
 
 // src/SubscriptionDispatcher.ts
 var _geminicodeassistresolver = require('@omnicross/core/ports/gemini-code-assist-resolver');
+
+
+
+
 var _matchText = require('@omnicross/core/provider-proxy/matchText');
 var _serializeError = require('@omnicross/core/serializeError');
 
@@ -858,6 +1154,7 @@ var SubscriptionDispatcher = class {
    * resolution and probe-detection.
    */
   async dispatch(req) {
+    const sessionKey = _matchText.deriveSubscriptionSessionKey.call(void 0, req.anthropicBody);
     const ocConfig = this.profile.providerId === "opencodego" ? await this.getOpenCodeGoConfig() : void 0;
     let scenario = "default";
     let resolvedModel = req.fallbackModel;
@@ -868,7 +1165,7 @@ var SubscriptionDispatcher = class {
       scenario = mapped.scenario;
       req.anthropicBody.model = resolvedModel;
     }
-    const upstreamUrl = _optionalChain([this, 'access', _22 => _22.profile, 'access', _23 => _23.resolveUpstreamUrl, 'optionalCall', _24 => _24(resolvedModel, ocConfig)]);
+    const upstreamUrl = _optionalChain([this, 'access', _45 => _45.profile, 'access', _46 => _46.resolveUpstreamUrl, 'optionalCall', _47 => _47(resolvedModel, ocConfig)]);
     if (!upstreamUrl) {
       throw new Error(`[SubscriptionDispatcher] profile=${this.profile.providerId} missing resolveUpstreamUrl`);
     }
@@ -876,41 +1173,53 @@ var SubscriptionDispatcher = class {
       provider: resolveOpenCodeGoHalf(resolvedModel, ocConfig),
       modelId: resolvedModel
     }) === "anthropic") {
-      await this.dispatchAnthropicShapeBypass(req, upstreamUrl, resolvedModel, scenario, ocConfig);
+      await this.dispatchAnthropicShapeBypass(req, upstreamUrl, resolvedModel, scenario, ocConfig, sessionKey);
       return;
     }
-    await this.dispatchTransformerChain(req, upstreamUrl, resolvedModel, scenario, ocConfig);
+    await this.dispatchTransformerChain(req, upstreamUrl, resolvedModel, scenario, ocConfig, sessionKey);
   }
   /** Bypass path for OpenCodeGo MiniMax models — forwards Anthropic body verbatim. */
-  async dispatchAnthropicShapeBypass(req, upstreamUrl, resolvedModel, scenario, ocConfig) {
+  async dispatchAnthropicShapeBypass(req, upstreamUrl, resolvedModel, scenario, ocConfig, sessionKey) {
     const gate = this.gatePrimaryModel(resolvedModel, scenario, ocConfig);
     const attempted = gate.attempted;
     let currentModel = gate.firstModel;
+    let usedAccountId;
+    const reportSelection = (accountId) => {
+      usedAccountId = accountId;
+    };
     while (attempted.length < MAX_FALLBACK_ATTEMPTS_LOCAL) {
       attempted.push(currentModel);
       req.anthropicBody.model = currentModel;
       const headers = { "content-type": "application/json" };
-      await this.applyHeadersWithRetry(headers, { upstreamUrl, resolvedModel: currentModel });
+      await this.applyHeadersWithRetry(headers, { upstreamUrl, resolvedModel: currentModel, sessionKey, reportSelection });
       console.info(
         `[AgentProxy:subscription] REQ#${req.reqId} | opencodego anthropic-shape -> ${upstreamUrl} model=${currentModel} attempt=${attempted.length}`
       );
       try {
         const upstream = await this.hooks.fetchWithRetry(upstreamUrl, headers, req.anthropicBody, currentModel);
-        _optionalChain([this, 'access', _25 => _25.profile, 'access', _26 => _26.recordModelOutcome, 'optionalCall', _27 => _27(currentModel, true)]);
+        _optionalChain([this, 'access', _48 => _48.profile, 'access', _49 => _49.recordModelOutcome, 'optionalCall', _50 => _50(currentModel, true)]);
+        this.markHealth(usedAccountId, 200);
         await this.hooks.writeProxyResponse(req.res, upstream, req.isStream, req.reqId);
         return;
       } catch (err) {
-        const handled = await this.maybeRetryAfterError(err, headers, req, currentModel);
+        const handled = await this.maybeRetryAfterError(err, headers, req, currentModel, sessionKey);
         if (handled.retryOnce) {
-          const upstream = await this.hooks.fetchWithRetry(upstreamUrl, handled.headers, req.anthropicBody, currentModel);
-          _optionalChain([this, 'access', _28 => _28.profile, 'access', _29 => _29.recordModelOutcome, 'optionalCall', _30 => _30(currentModel, true)]);
-          await this.hooks.writeProxyResponse(req.res, upstream, req.isStream, req.reqId);
-          return;
+          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)]);
+            this.markHealth(usedAccountId, 200);
+            await this.hooks.writeProxyResponse(req.res, upstream, req.isStream, req.reqId);
+            return;
+          } catch (retryErr) {
+            this.markHealth(usedAccountId, errStatus(retryErr), retryErr);
+            throw retryErr;
+          }
         }
         if (caughtErrorBreakerOutcome(err) === "failure") {
-          _optionalChain([this, 'access', _31 => _31.profile, 'access', _32 => _32.recordModelOutcome, 'optionalCall', _33 => _33(currentModel, false)]);
+          _optionalChain([this, 'access', _54 => _54.profile, 'access', _55 => _55.recordModelOutcome, 'optionalCall', _56 => _56(currentModel, false)]);
         }
-        const next = _optionalChain([this, 'access', _34 => _34.profile, 'access', _35 => _35.nextFallback, 'optionalCall', _36 => _36(scenario, attempted, ocConfig)]);
+        this.markHealth(usedAccountId, errStatus(err), err);
+        const next = _optionalChain([this, 'access', _57 => _57.profile, 'access', _58 => _58.nextFallback, 'optionalCall', _59 => _59(scenario, attempted, ocConfig)]);
         if (!next || attempted.length >= MAX_FALLBACK_ATTEMPTS_LOCAL) {
           throw err;
         }
@@ -923,8 +1232,8 @@ var SubscriptionDispatcher = class {
     }
   }
   /** Standard subscription transformer chain — Codex/Gemini/OpenCodeGo OpenAI-shape. */
-  async dispatchTransformerChain(req, upstreamUrl, resolvedModel, scenario, ocConfig) {
-    const providerNames = _nullishCoalesce(_optionalChain([this, 'access', _37 => _37.profile, 'access', _38 => _38.resolveProviderTransformerNames, 'optionalCall', _39 => _39(resolvedModel, ocConfig)]), () => ( this.profile.providerTransformerNames));
+  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 providerTransformers = this.resolveTransformers(providerNames);
     const modelTransformers = this.resolveTransformers(this.profile.modelTransformerNames);
     const transformerProvider = {
@@ -940,6 +1249,10 @@ var SubscriptionDispatcher = class {
     const gate = this.gatePrimaryModel(resolvedModel, scenario, ocConfig);
     const attempted = gate.attempted;
     let currentModel = gate.firstModel;
+    let usedAccountId;
+    const reportSelection = (accountId) => {
+      usedAccountId = accountId;
+    };
     while (attempted.length < MAX_FALLBACK_ATTEMPTS_LOCAL) {
       attempted.push(currentModel);
       req.anthropicBody.model = currentModel;
@@ -954,14 +1267,15 @@ var SubscriptionDispatcher = class {
         ...config.headers
       };
       stripAuthHeaders(headers);
-      await this.applyHeadersWithRetry(headers, { upstreamUrl, resolvedModel: currentModel });
+      await this.applyHeadersWithRetry(headers, { upstreamUrl, resolvedModel: currentModel, sessionKey, reportSelection });
       const fetchUrl = usesResponsesChain(providerNames) ? upstreamUrl : _nullishCoalesce(resolveConfigUrl(config.url), () => ( upstreamUrl));
       console.info(
         `[AgentProxy:subscription] REQ#${req.reqId} | provider=${this.profile.providerId} -> ${fetchUrl} model=${currentModel} attempt=${attempted.length}`
       );
       try {
         const upstream = await this.hooks.fetchWithRetry(fetchUrl, headers, requestBody, currentModel);
-        _optionalChain([this, 'access', _40 => _40.profile, 'access', _41 => _41.recordModelOutcome, 'optionalCall', _42 => _42(currentModel, true)]);
+        _optionalChain([this, 'access', _63 => _63.profile, 'access', _64 => _64.recordModelOutcome, 'optionalCall', _65 => _65(currentModel, true)]);
+        this.markHealth(usedAccountId, 200);
         const finalResponse = await this.hooks.executor.executeResponseChain(
           requestBody,
           upstream,
@@ -972,24 +1286,31 @@ var SubscriptionDispatcher = class {
         await this.hooks.writeProxyResponse(req.res, finalResponse, req.isStream, req.reqId);
         return;
       } catch (err) {
-        const handled = await this.maybeRetryAfterError(err, headers, req, currentModel);
+        const handled = await this.maybeRetryAfterError(err, headers, req, currentModel, sessionKey);
         if (handled.retryOnce) {
-          const upstream = await this.hooks.fetchWithRetry(fetchUrl, handled.headers, requestBody, currentModel);
-          _optionalChain([this, 'access', _43 => _43.profile, 'access', _44 => _44.recordModelOutcome, 'optionalCall', _45 => _45(currentModel, true)]);
-          const finalResponse = await this.hooks.executor.executeResponseChain(
-            requestBody,
-            upstream,
-            transformerProvider,
-            { providerTransformers, modelTransformers },
-            { endpointTransformer: this.hooks.endpointTransformer }
-          );
-          await this.hooks.writeProxyResponse(req.res, finalResponse, req.isStream, req.reqId);
-          return;
+          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)]);
+            this.markHealth(usedAccountId, 200);
+            const finalResponse = await this.hooks.executor.executeResponseChain(
+              requestBody,
+              upstream,
+              transformerProvider,
+              { providerTransformers, modelTransformers },
+              { endpointTransformer: this.hooks.endpointTransformer }
+            );
+            await this.hooks.writeProxyResponse(req.res, finalResponse, req.isStream, req.reqId);
+            return;
+          } catch (retryErr) {
+            this.markHealth(usedAccountId, errStatus(retryErr), retryErr);
+            throw retryErr;
+          }
         }
         if (caughtErrorBreakerOutcome(err) === "failure") {
-          _optionalChain([this, 'access', _46 => _46.profile, 'access', _47 => _47.recordModelOutcome, 'optionalCall', _48 => _48(currentModel, false)]);
+          _optionalChain([this, 'access', _69 => _69.profile, 'access', _70 => _70.recordModelOutcome, 'optionalCall', _71 => _71(currentModel, false)]);
         }
-        const next = _optionalChain([this, 'access', _49 => _49.profile, 'access', _50 => _50.nextFallback, 'optionalCall', _51 => _51(scenario, attempted, ocConfig)]);
+        this.markHealth(usedAccountId, errStatus(err), err);
+        const next = _optionalChain([this, 'access', _72 => _72.profile, 'access', _73 => _73.nextFallback, 'optionalCall', _74 => _74(scenario, attempted, ocConfig)]);
         if (!next || attempted.length >= MAX_FALLBACK_ATTEMPTS_LOCAL) {
           throw err;
         }
@@ -1019,7 +1340,7 @@ var SubscriptionDispatcher = class {
       return { firstModel: primaryModel, attempted: [] };
     }
     const skipped = [primaryModel];
-    const firstAdmitting = _optionalChain([this, 'access', _52 => _52.profile, 'access', _53 => _53.nextFallback, 'optionalCall', _54 => _54(scenario, skipped, ocConfig)]);
+    const firstAdmitting = _optionalChain([this, 'access', _75 => _75.profile, 'access', _76 => _76.nextFallback, 'optionalCall', _77 => _77(scenario, skipped, ocConfig)]);
     if (firstAdmitting) {
       console.warn(
         `[AgentProxy:subscription] opencodego primary ${primaryModel} circuit open -> first admitting fallback ${firstAdmitting.modelId}`
@@ -1036,12 +1357,12 @@ var SubscriptionDispatcher = class {
    * Returns `{ retryOnce: true, headers }` when the strategy refreshed
    * successfully (caller should retry once); otherwise re-throws.
    */
-  async maybeRetryAfterError(err, headers, req, resolvedModel) {
-    const status = _nullishCoalesce(_optionalChain([err, 'optionalAccess', _55 => _55.status]), () => ( 0));
+  async maybeRetryAfterError(err, headers, req, resolvedModel, sessionKey) {
+    const status = _nullishCoalesce(_optionalChain([err, 'optionalAccess', _78 => _78.status]), () => ( 0));
     if (status !== 401) {
       return { retryOnce: false, headers };
     }
-    const refreshed = await this.profile.authStrategy.onUnauthorized();
+    const refreshed = await this.profile.authStrategy.onUnauthorized(sessionKey);
     if (!refreshed) {
       console.warn(
         `[AgentProxy:subscription] REQ#${req.reqId} | 401 not recoverable for provider=${this.profile.providerId}`
@@ -1050,7 +1371,7 @@ var SubscriptionDispatcher = class {
     }
     const fresh = { ...headers };
     stripAuthHeaders(fresh);
-    await this.applyHeadersWithRetry(fresh, { upstreamUrl: "", resolvedModel });
+    await this.applyHeadersWithRetry(fresh, { upstreamUrl: "", resolvedModel, sessionKey });
     return { retryOnce: true, headers: fresh };
   }
   async applyHeadersWithRetry(headers, hints) {
@@ -1060,6 +1381,28 @@ var SubscriptionDispatcher = class {
       console.warn("[AgentProxy:subscription] authStrategy.applyHeaders threw:", _serializeError.serializeError.call(void 0, err));
     }
   }
+  /**
+   * Mark the served account's health against ONE attempt's outcome
+   * (subscription-account-health, task 3.4). No-op when no account was reported
+   * (non-pooled / single-account) or on a session-cancel (status 0). On a caught
+   * error `err` is passed so the 429-reset / 403-ban drivers are read STRUCTURALLY
+   * from the error's upstream `headers` + `bodyText` (the `fetchWithRetry`
+   * contract) — so daemon-path 429 cooldown + ban blocking function for
+   * multi-account codex/gemini/opencodego pools; absent headers ⇒ a bare-429
+   * (unmarked, lazy re-probe). Success (2xx) clears; 401/5xx/thrown → transient.
+   */
+  markHealth(accountId, status, err) {
+    if (accountId === void 0 || status === 0) return;
+    const headers = err !== void 0 ? errHeaders(err) : void 0;
+    const reset = headers ? _SubscriptionAccountHealth.resolveResetSeconds.call(void 0, this.profile.providerId, headers) : { resetHeaderSeconds: null, retryAfterSeconds: null };
+    const bodyText = status === 403 && err !== void 0 ? errBodyText(err) : void 0;
+    _SubscriptionAccountHealth.getSharedAccountHealth.call(void 0, ).recordUpstreamOutcome(this.profile.providerId, accountId, {
+      status,
+      resetHeaderSeconds: reset.resetHeaderSeconds,
+      retryAfterSeconds: reset.retryAfterSeconds,
+      bodyText
+    });
+  }
   /**
    * Resolve the Code Assist project for the gemini subscription profile. Pulls
    * the Bearer the bound `AuthStrategy` would inject (so the strategy stays the
@@ -1136,8 +1479,24 @@ var SubscriptionDispatcher = class {
   }
 };
 var MAX_FALLBACK_ATTEMPTS_LOCAL = 3;
+function errStatus(err) {
+  const status = _optionalChain([err, 'optionalAccess', _79 => _79.status]);
+  return typeof status === "number" ? status : null;
+}
+function errHeaders(err) {
+  const h = _optionalChain([err, 'optionalAccess', _80 => _80.headers]);
+  if (!h) return void 0;
+  if (typeof h.get === "function") return h;
+  if (typeof h === "object") return h;
+  return void 0;
+}
+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)]);
+}
 function caughtErrorBreakerOutcome(err) {
-  const status = _optionalChain([err, 'optionalAccess', _56 => _56.status]);
+  const status = _optionalChain([err, 'optionalAccess', _85 => _85.status]);
   if (typeof status !== "number") return "failure";
   if (status === 0) return "neutral";
   if (status >= 500 || status === 429) return "failure";
@@ -1171,4 +1530,8 @@ function stripAuthHeaders(headers) {
 
 
 
-exports.SubscriptionAccountService = SubscriptionAccountService; exports.SubscriptionDispatcher = SubscriptionDispatcher; exports.SubscriptionProviderRegistry = SubscriptionProviderRegistry; exports.claudeOAuth = _chunkTPW5Q25Ycjs.claude_exports; exports.codexOAuth = _chunkTPW5Q25Ycjs.codex_exports; exports.geminiOAuth = _chunkTPW5Q25Ycjs.gemini_exports; exports.getSubscriptionAccountService = getSubscriptionAccountService; exports.getSubscriptionProviderRegistry = getSubscriptionProviderRegistry; exports.setSubscriptionAccountService = setSubscriptionAccountService; exports.setSubscriptionProviderRegistry = setSubscriptionProviderRegistry;
+
+
+
+
+exports.DEFAULT_ACCOUNT_PRIORITY = DEFAULT_ACCOUNT_PRIORITY; exports.LAST_USED_PERSIST_THROTTLE_MS = LAST_USED_PERSIST_THROTTLE_MS; exports.SESSION_AFFINITY_TTL_MS = SESSION_AFFINITY_TTL_MS; exports.SubscriptionAccountSelector = SubscriptionAccountSelector; exports.SubscriptionAccountService = SubscriptionAccountService; exports.SubscriptionDispatcher = SubscriptionDispatcher; exports.SubscriptionProviderRegistry = SubscriptionProviderRegistry; exports.claudeOAuth = _chunkTPW5Q25Ycjs.claude_exports; exports.codexOAuth = _chunkTPW5Q25Ycjs.codex_exports; exports.geminiOAuth = _chunkTPW5Q25Ycjs.gemini_exports; exports.getSubscriptionAccountService = getSubscriptionAccountService; exports.getSubscriptionProviderRegistry = getSubscriptionProviderRegistry; exports.setSubscriptionAccountService = setSubscriptionAccountService; exports.setSubscriptionProviderRegistry = setSubscriptionProviderRegistry;