@omnicross/subscriptions 0.1.2 → 0.1.4

package/dist/index.js

@@ -4,26 +4,290 @@ import {
   gemini_exports
 } from "./chunk-IXGHVMZB.js";
 
+// 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 {
+  /** `providerId\0accountId → live lastUsedAt ms` (authoritative tie-break). */
+  lastUsedOverlay = /* @__PURE__ */ new Map();
+  /** `providerId\0sessionKey → { accountId, expiresAt }`. */
+  affinity = /* @__PURE__ */ new Map();
+  /** `providerId\0accountId → last durable-persist ms` (throttle state). */
+  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 = 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 = 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: 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 overlay ?? parseIso(account.lastUsedAt);
+  }
+  markUsed(providerId, accountId, now) {
+    this.lastUsedOverlay.set(scopedKey(providerId, accountId), now);
+  }
+};
+
+// src/SubscriptionAccountService.ts
+import { getSharedAccountHealth } from "@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 = 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 = ctx?.health;
+  const report = ctx?.reportSelection;
+  const now = ctx?.now;
+  const resolvedModel = ctx?.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 = ctx?.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);
+          report?.(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);
+        report?.(targetId, false, remapFor(targetId));
+        return byId;
+      }
+      selector.evictAffinity(providerId, targetId);
+      health?.recordUpstreamOutcome(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);
+          report?.(retryId, false, remapFor(retryId));
+          return retryToken;
+        }
+      }
+    }
+    if (activeAccountId) report?.(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 tokens.refreshAccountToken(providerId, accountId) ?? 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 {
-  constructor(providerId, tokens, mutex) {
+  constructor(providerId, tokens, mutex, selector, health) {
     this.tokens = tokens;
     this.mutex = mutex;
+    this.selector = selector;
+    this.health = health;
     this.providerId = providerId;
   }
   tokens;
   mutex;
+  selector;
+  health;
   kind = "oauth-bearer";
   providerId;
-  async applyHeaders(headers, _hints) {
-    const token = await this.resolveAccessToken();
+  async applyHeaders(headers, hints) {
+    const token = await resolveSelectedToken(
+      this.selector,
+      this.tokens,
+      this.providerId,
+      hints?.sessionKey,
+      () => this.resolveAccessToken(),
+      { health: this.health, reportSelection: hints?.reportSelection, resolvedModel: hints?.resolvedModel, preferredAccountId: hints?.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();
@@ -72,20 +336,33 @@ var OAuthBearerAuthStrategy = class {
 
 // src/auth/PassThroughAuthStrategy.ts
 var PassThroughAuthStrategy = class {
-  constructor(tokens, mutex) {
+  constructor(tokens, mutex, selector, health) {
     this.tokens = tokens;
     this.mutex = mutex;
+    this.selector = selector;
+    this.health = health;
   }
   tokens;
   mutex;
+  selector;
+  health;
   kind = "pass-through";
   providerId = "claude";
-  async applyHeaders(headers, _hints) {
-    const token = await this.tokens.getValidClaudeAccessToken();
+  async applyHeaders(headers, hints) {
+    const token = await resolveSelectedToken(
+      this.selector,
+      this.tokens,
+      "claude",
+      hints?.sessionKey,
+      () => this.tokens.getValidClaudeAccessToken(),
+      { health: this.health, reportSelection: hints?.reportSelection, resolvedModel: hints?.resolvedModel, preferredAccountId: hints?.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();
@@ -139,14 +416,25 @@ var RefreshMutex = class {
 // src/auth/StaticBearerAuthStrategy.ts
 var ANTHROPIC_SHAPE_PATH = "/v1/messages";
 var StaticBearerAuthStrategy = class {
-  constructor(tokens) {
+  constructor(tokens, selector, health) {
     this.tokens = tokens;
+    this.selector = selector;
+    this.health = health;
   }
   tokens;
+  selector;
+  health;
   kind = "static-bearer";
   providerId = "opencodego";
   async applyHeaders(headers, hints) {
-    const key = await this.tokens.getValidOpenCodeGoApiKey();
+    const key = await resolveSelectedToken(
+      this.selector,
+      this.tokens,
+      "opencodego",
+      hints?.sessionKey,
+      () => this.tokens.getValidOpenCodeGoApiKey(),
+      { health: this.health, reportSelection: hints?.reportSelection, resolvedModel: hints?.resolvedModel, preferredAccountId: hints?.preferredAccountId }
+    );
     if (!key) {
       return;
     }
@@ -155,7 +443,7 @@ var StaticBearerAuthStrategy = class {
       headers["x-api-key"] = key;
     }
   }
-  async onUnauthorized() {
+  async onUnauthorized(_sessionKey) {
     return false;
   }
   async describeStatus() {
@@ -180,13 +468,17 @@ var DISPLAY_NAMES = {
 };
 var SubscriptionAccountService = class {
   mutex = new RefreshMutex();
+  /** ONE account-pool scheduler (subscription-account-scheduling) shared by all
+   *  four strategies so they share the affinity map + the `lastUsedAt` overlay. */
+  selector = new SubscriptionAccountSelector();
   strategies;
   constructor(tokens) {
+    const health = getSharedAccountHealth();
     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. */
@@ -830,7 +1122,11 @@ function getSubscriptionProviderRegistry() {
 
 // src/SubscriptionDispatcher.ts
 import { getGeminiCodeAssistResolver } from "@omnicross/core/ports/gemini-code-assist-resolver";
-import { collectMatchText } from "@omnicross/core/provider-proxy/matchText";
+import {
+  getSharedAccountHealth as getSharedAccountHealth2,
+  resolveResetSeconds
+} from "@omnicross/core/pipeline/SubscriptionAccountHealth";
+import { collectMatchText, deriveSubscriptionSessionKey } from "@omnicross/core/provider-proxy/matchText";
 import { serializeError } from "@omnicross/core/serializeError";
 
 // src/opencodego/token-count.ts
@@ -858,6 +1154,7 @@ var SubscriptionDispatcher = class {
    * resolution and probe-detection.
    */
   async dispatch(req) {
+    const sessionKey = deriveSubscriptionSessionKey(req.anthropicBody);
     const ocConfig = this.profile.providerId === "opencodego" ? await this.getOpenCodeGoConfig() : void 0;
     let scenario = "default";
     let resolvedModel = req.fallbackModel;
@@ -876,40 +1173,52 @@ 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);
         this.profile.recordModelOutcome?.(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);
-          this.profile.recordModelOutcome?.(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);
+            this.profile.recordModelOutcome?.(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") {
           this.profile.recordModelOutcome?.(currentModel, false);
         }
+        this.markHealth(usedAccountId, errStatus(err), err);
         const next = this.profile.nextFallback?.(scenario, attempted, ocConfig);
         if (!next || attempted.length >= MAX_FALLBACK_ATTEMPTS_LOCAL) {
           throw err;
@@ -923,7 +1232,7 @@ var SubscriptionDispatcher = class {
     }
   }
   /** Standard subscription transformer chain — Codex/Gemini/OpenCodeGo OpenAI-shape. */
-  async dispatchTransformerChain(req, upstreamUrl, resolvedModel, scenario, ocConfig) {
+  async dispatchTransformerChain(req, upstreamUrl, resolvedModel, scenario, ocConfig, sessionKey) {
     const providerNames = this.profile.resolveProviderTransformerNames?.(resolvedModel, ocConfig) ?? this.profile.providerTransformerNames;
     const providerTransformers = this.resolveTransformers(providerNames);
     const modelTransformers = this.resolveTransformers(this.profile.modelTransformerNames);
@@ -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,7 +1267,7 @@ 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 : resolveConfigUrl(config.url) ?? upstreamUrl;
       console.info(
         `[AgentProxy:subscription] REQ#${req.reqId} | provider=${this.profile.providerId} -> ${fetchUrl} model=${currentModel} attempt=${attempted.length}`
@@ -962,6 +1275,7 @@ var SubscriptionDispatcher = class {
       try {
         const upstream = await this.hooks.fetchWithRetry(fetchUrl, headers, requestBody, currentModel);
         this.profile.recordModelOutcome?.(currentModel, true);
+        this.markHealth(usedAccountId, 200);
         const finalResponse = await this.hooks.executor.executeResponseChain(
           requestBody,
           upstream,
@@ -972,23 +1286,30 @@ 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);
-          this.profile.recordModelOutcome?.(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);
+            this.profile.recordModelOutcome?.(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") {
           this.profile.recordModelOutcome?.(currentModel, false);
         }
+        this.markHealth(usedAccountId, errStatus(err), err);
         const next = this.profile.nextFallback?.(scenario, attempted, ocConfig);
         if (!next || attempted.length >= MAX_FALLBACK_ATTEMPTS_LOCAL) {
           throw err;
@@ -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) {
+  async maybeRetryAfterError(err, headers, req, resolvedModel, sessionKey) {
     const status = err?.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(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 ? resolveResetSeconds(this.profile.providerId, headers) : { resetHeaderSeconds: null, retryAfterSeconds: null };
+    const bodyText = status === 403 && err !== void 0 ? errBodyText(err) : void 0;
+    getSharedAccountHealth2().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,6 +1479,22 @@ var SubscriptionDispatcher = class {
   }
 };
 var MAX_FALLBACK_ATTEMPTS_LOCAL = 3;
+function errStatus(err) {
+  const status = err?.status;
+  return typeof status === "number" ? status : null;
+}
+function errHeaders(err) {
+  const h = err?.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 e?.bodyText === "string" ? e.bodyText : typeof e?.body === "string" ? e.body : void 0;
+  return raw?.slice(0, 2048);
+}
 function caughtErrorBreakerOutcome(err) {
   const status = err?.status;
   if (typeof status !== "number") return "failure";
@@ -1161,6 +1520,10 @@ function stripAuthHeaders(headers) {
   delete headers["X-Goog-Api-Key"];
 }
 export {
+  DEFAULT_ACCOUNT_PRIORITY,
+  LAST_USED_PERSIST_THROTTLE_MS,
+  SESSION_AFFINITY_TTL_MS,
+  SubscriptionAccountSelector,
   SubscriptionAccountService,
   SubscriptionDispatcher,
   SubscriptionProviderRegistry,