opencode-multi-account-core 0.2.83 → 0.2.84

package/README.md

@@ -16,6 +16,7 @@ The npm package name remains `opencode-multi-account-core` for compatibility.
 | `AccountStore` | File-locked account JSON storage |
 | `AccountManager` | Account cache, selection, state mutation |
 | `Executor` | Retry loop and account rotation |
+| `TurnSupervisor` | Pre-output commit gate shared by Plugin and Server Mode |
 | `Claims` | Cross-process account claims |
 | `ProactiveRefreshQueue` | Background token refresh |
 | `NativePluginLifecycle` | OpenCode loader/runtime/refresh wiring |
@@ -23,8 +24,8 @@ The npm package name remains `opencode-multi-account-core` for compatibility.
 | `NativePluginLoader` | Shared `getAuth -> lifecycle.load -> hooks` flow |
 | `NativePluginBootstrapAuth` | Stored-account to OpenCode `auth.json` sync helper |
 
-Provider wire behavior stays in the provider packages. Server Mode behavior stays in
-`@kyoli-gam/core`, `@kyoli-gam/gateway`, and `@kyoli-gam/cli`.
+Provider endpoints stay in the provider packages. The Codex Responses startup classifier
+lives here so Plugin and Server Mode make the same pre-output retry decision.
 
 ## Safety
 

package/dist/index.d.ts

@@ -321,6 +321,35 @@ declare let ACCOUNTS_FILENAME: string;
  */
 declare function setAccountsFilename(filename: string): void;
 
+type TurnFailureClass = "rate_limit" | "quota" | "auth" | "permanent" | "transient" | "neutral";
+type TurnFailurePhase = "connect" | "headers" | "startup" | "mid_stream" | "terminal";
+interface TurnFailureSignal {
+    class: TurnFailureClass;
+    phase: TurnFailurePhase;
+    code?: string;
+    message?: string;
+    httpStatus?: number;
+    metadata?: Record<string, unknown>;
+    retryAfterSeconds?: number;
+    resetAt?: string;
+    retryScope?: "same_account" | "next_account" | "none";
+}
+interface SupervisedTurnResponse {
+    response: Response;
+    failure?: TurnFailureSignal;
+    downstreamVisible?: boolean;
+}
+type TurnResponseSupervisor = (response: Response) => Promise<SupervisedTurnResponse>;
+interface SseStartupSupervisorOptions {
+    maxBufferedBytes: number;
+    classifyFailure(frame: string): TurnFailureSignal | undefined;
+    isCommitFrame(frame: string): boolean;
+    createBufferLimitFailure(bufferedBytes: number): TurnFailureSignal;
+    createFailureResponse(failure: TurnFailureSignal): Response;
+}
+declare function superviseSseResponseStartup(response: Response, options: SseStartupSupervisorOptions): Promise<SupervisedTurnResponse>;
+declare function drainSseFrames(buffer: string, onFrame: (frame: string) => void): string;
+
 interface ExecutorAccountManager {
     getAccountCount(): number;
     refresh(): Promise<void>;
@@ -343,6 +372,7 @@ interface ExecutorDependencies {
     sleep: (ms: number) => Promise<void>;
     showToast: (client: PluginClient, message: string, variant: "info" | "warning" | "success" | "error") => Promise<void>;
     getAccountLabel: (account: ManagedAccount) => string;
+    responseSupervisor?: TurnResponseSupervisor;
 }
 declare function createExecutorForProvider(providerName: string, dependencies: ExecutorDependencies): {
     executeWithAccountRotation: (manager: ExecutorAccountManager, runtimeFactory: ExecutorRuntimeFactory, client: PluginClient, input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
@@ -506,6 +536,16 @@ declare const anthropicOAuthAdapter: OAuthAdapter;
 
 declare const openAIOAuthAdapter: OAuthAdapter;
 
+declare const CODEX_UNKNOWN_RATE_LIMIT_BACKOFF_MS: number;
+declare const CODEX_STARTUP_PROBE_MAX_BYTES: number;
+declare function superviseCodexResponseStartup(response: Response): Promise<SupervisedTurnResponse>;
+declare function isCodexStartupOutputFrame(frame: string): boolean;
+declare function isCodexStartupOutputEvent(value: unknown, event?: string): boolean;
+declare function classifyCodexSseStartupFailure(frame: string): TurnFailureSignal | undefined;
+declare function classifyCodexJsonEventFailure(value: unknown, phase: TurnFailurePhase): TurnFailureSignal | undefined;
+declare function classifyCodexFailure(code: string | undefined, message: string): TurnFailureClass;
+declare function parseCodexRetryAfterSeconds(message: string): number | undefined;
+
 declare const PoolConfigSchema: v.ObjectSchema<{
     readonly name: v.StringSchema<undefined>;
     readonly baseProvider: v.StringSchema<undefined>;
@@ -738,4 +778,4 @@ declare const __openCodeNativeBootstrapAuthTestUtils: {
 
 declare function zeroCostProviderModels(provider: unknown): Promise<Record<string, any>>;
 
-export { ACCOUNTS_FILENAME, ANSI, type AccountManagerClass, type AccountManagerDependencies, type AccountManagerInstance, type AccountMetadataPatch, type AccountSelectionStrategy, AccountSelectionStrategySchema, type AccountStorage, AccountStorageSchema, AccountStore, type BuildFailoverPlanOptions, type CascadeState, CascadeStateManager, type ChainConfig, ChainConfigSchema, type ChainEntryConfig, ChainEntryConfigSchema, type ClaimsManager, type ClaimsMap, type ConfigLoader, type CoreConfig, type CredentialRefreshPatch, CredentialRefreshPatchSchema, type DiskCredentials, type ExecutorAccountManager, type ExecutorDependencies, type ExecutorRuntimeFactory, type FailoverCandidate, type FailoverPlan, type FailoverSkip, type KeyAction, type ManagedAccount, type MenuItem, type NativePluginLifecycle, type NativePluginLifecycleOptions, type NativePluginLoaderResult, type NativePluginManagedAccount, type NativePluginManagerClass, type NativePluginManagerLike, type NativePluginRefreshQueueLike, type NativePluginRuntimeFactoryLike, type NativePluginStoreLike, type OAuthAdapter, type OAuthAdapterPlanLabels, type OAuthAdapterTransformConfig, type OAuthCredentials, OAuthCredentialsSchema, type OpenCodeNativeAuthLoaderOptions, type OpenCodeNativeAuthMethod, type OpenCodeNativeAuthMethodsOptions, type OpenCodeNativeBootstrapAccount, type OpenCodeNativeBootstrapAuthOptions, type OpenCodeNativeBootstrapStore, type OpenCodeNativeLoaderContext, type PluginClient, type PluginConfig, PluginConfigSchema, type PoolChainConfig, PoolChainConfigSchema, type PoolConfig, PoolConfigSchema, PoolManager, type ProactiveRefreshDependencies, type ProactiveRefreshQueueClass, type ProactiveRefreshQueueInstance, type ProfileData, type QuotaResetPaceOptions, type QuotaRoutingWindow, type RateLimitAccountManager, type RateLimitDependencies, type RuntimeFactoryLike, type SelectOptions, type StoredAccount, StoredAccountSchema, TokenRefreshError, type TokenRefreshResult, type UsageLimitEntry, UsageLimitEntrySchema, type UsageLimits, UsageLimitsSchema, __openCodeNativeBootstrapAuthTestUtils, anthropicOAuthAdapter, confirm, createAccountManagerForProvider, createClaimsManager, createConfigLoader, createExecutorForProvider, createMinimalClient, createOpenCodeNativeAuthLoader, createOpenCodeNativeAuthMethods, createOpenCodeNativePluginLifecycle, createProactiveRefreshQueueForProvider, createRateLimitHandlers, debugLog, deduplicateAccounts, formatWaitTime, getAccountLabel, getClearedOAuthBody, getConfig, getConfigDir, getErrorCode, initCoreConfig, isClaimedByOther, isTTY, isTokenRefreshError, loadAccounts, loadConfig, loadPoolChainConfig, migrateFromAuthJson, openAIOAuthAdapter, parseKey, readClaims, readStorageFromDisk, releaseClaim, resetConfigCache, savePoolChainConfig, scoreQuotaResetPace, select, setAccountsFilename, setConfigGetter, showToast, sleep, syncOpenCodeNativeBootstrapAuth, updateConfigField, withDirectoryLock, writeClaim, zeroCostProviderModels };
+export { ACCOUNTS_FILENAME, ANSI, type AccountManagerClass, type AccountManagerDependencies, type AccountManagerInstance, type AccountMetadataPatch, type AccountSelectionStrategy, AccountSelectionStrategySchema, type AccountStorage, AccountStorageSchema, AccountStore, type BuildFailoverPlanOptions, CODEX_STARTUP_PROBE_MAX_BYTES, CODEX_UNKNOWN_RATE_LIMIT_BACKOFF_MS, type CascadeState, CascadeStateManager, type ChainConfig, ChainConfigSchema, type ChainEntryConfig, ChainEntryConfigSchema, type ClaimsManager, type ClaimsMap, type ConfigLoader, type CoreConfig, type CredentialRefreshPatch, CredentialRefreshPatchSchema, type DiskCredentials, type ExecutorAccountManager, type ExecutorDependencies, type ExecutorRuntimeFactory, type FailoverCandidate, type FailoverPlan, type FailoverSkip, type KeyAction, type ManagedAccount, type MenuItem, type NativePluginLifecycle, type NativePluginLifecycleOptions, type NativePluginLoaderResult, type NativePluginManagedAccount, type NativePluginManagerClass, type NativePluginManagerLike, type NativePluginRefreshQueueLike, type NativePluginRuntimeFactoryLike, type NativePluginStoreLike, type OAuthAdapter, type OAuthAdapterPlanLabels, type OAuthAdapterTransformConfig, type OAuthCredentials, OAuthCredentialsSchema, type OpenCodeNativeAuthLoaderOptions, type OpenCodeNativeAuthMethod, type OpenCodeNativeAuthMethodsOptions, type OpenCodeNativeBootstrapAccount, type OpenCodeNativeBootstrapAuthOptions, type OpenCodeNativeBootstrapStore, type OpenCodeNativeLoaderContext, type PluginClient, type PluginConfig, PluginConfigSchema, type PoolChainConfig, PoolChainConfigSchema, type PoolConfig, PoolConfigSchema, PoolManager, type ProactiveRefreshDependencies, type ProactiveRefreshQueueClass, type ProactiveRefreshQueueInstance, type ProfileData, type QuotaResetPaceOptions, type QuotaRoutingWindow, type RateLimitAccountManager, type RateLimitDependencies, type RuntimeFactoryLike, type SelectOptions, type SseStartupSupervisorOptions, type StoredAccount, StoredAccountSchema, type SupervisedTurnResponse, TokenRefreshError, type TokenRefreshResult, type TurnFailureClass, type TurnFailurePhase, type TurnFailureSignal, type TurnResponseSupervisor, type UsageLimitEntry, UsageLimitEntrySchema, type UsageLimits, UsageLimitsSchema, __openCodeNativeBootstrapAuthTestUtils, anthropicOAuthAdapter, classifyCodexFailure, classifyCodexJsonEventFailure, classifyCodexSseStartupFailure, confirm, createAccountManagerForProvider, createClaimsManager, createConfigLoader, createExecutorForProvider, createMinimalClient, createOpenCodeNativeAuthLoader, createOpenCodeNativeAuthMethods, createOpenCodeNativePluginLifecycle, createProactiveRefreshQueueForProvider, createRateLimitHandlers, debugLog, deduplicateAccounts, drainSseFrames, formatWaitTime, getAccountLabel, getClearedOAuthBody, getConfig, getConfigDir, getErrorCode, initCoreConfig, isClaimedByOther, isCodexStartupOutputEvent, isCodexStartupOutputFrame, isTTY, isTokenRefreshError, loadAccounts, loadConfig, loadPoolChainConfig, migrateFromAuthJson, openAIOAuthAdapter, parseCodexRetryAfterSeconds, parseKey, readClaims, readStorageFromDisk, releaseClaim, resetConfigCache, savePoolChainConfig, scoreQuotaResetPace, select, setAccountsFilename, setConfigGetter, showToast, sleep, superviseCodexResponseStartup, superviseSseResponseStartup, syncOpenCodeNativeBootstrapAuth, updateConfigField, withDirectoryLock, writeClaim, zeroCostProviderModels };

package/dist/index.js

@@ -1530,26 +1530,43 @@ function extractStickyKey(input, init) {
   const requestHeader = input instanceof Request ? input.headers.get("x-claude-code-session-id") ?? void 0 : void 0;
   return readStickyHeaderFromInit(init?.headers) ?? requestHeader;
 }
+async function createFetchArgumentsFactory(input, init) {
+  if (!(input instanceof Request)) {
+    if (!(init?.body instanceof ReadableStream)) return () => [input, init];
+    const body2 = new Uint8Array(await new Response(init.body).arrayBuffer());
+    return () => [input, {
+      ...init,
+      body: body2.slice()
+    }];
+  }
+  const request = new Request(input, init);
+  const body = request.body ? new Uint8Array(await request.arrayBuffer()) : void 0;
+  return () => [new Request(request, { body: body?.slice() })];
+}
 function createExecutorForProvider(providerName, dependencies) {
   const {
     handleRateLimitResponse,
     formatWaitTime: formatWaitTime2,
     sleep: sleep4,
     showToast: showToast2,
-    getAccountLabel: getAccountLabel2
+    getAccountLabel: getAccountLabel2,
+    responseSupervisor
   } = dependencies;
   async function executeWithAccountRotation(manager, runtimeFactory, client, input, init) {
     const maxRetries = Math.max(MIN_MAX_RETRIES, manager.getAccountCount() * RETRIES_PER_ACCOUNT);
     let previousAccountUuid;
+    let lastStartupFailure;
+    const startupFailureAccounts = /* @__PURE__ */ new Set();
     const stickyKey = extractStickyKey(input, init);
+    const createFetchArguments = responseSupervisor ? await createFetchArgumentsFactory(input, init) : () => [input, init];
     async function retryServerErrors(account, runtime) {
+      let lastResult;
       for (let attempt = 0; attempt < MAX_SERVER_RETRIES_PER_ATTEMPT; attempt++) {
         const backoff = Math.min(SERVER_RETRY_BASE_MS * 2 ** attempt, SERVER_RETRY_MAX_MS);
         const jitteredBackoff = backoff * (0.5 + Math.random() * 0.5);
         await sleep4(jitteredBackoff);
-        let retryResponse;
         try {
-          retryResponse = await runtime.fetch(input, init);
+          lastResult = await fetchAndSupervise(runtime);
         } catch (error) {
           if (isAbortError(error)) throw error;
           if (await handleRuntimeFetchFailure(manager, runtimeFactory, client, account, error)) {
@@ -1558,25 +1575,39 @@ function createExecutorForProvider(providerName, dependencies) {
           void showToast2(client, `${getAccountLabel2(account)} network error \u2014 switching`, "warning");
           return null;
         }
-        if (retryResponse.status < 500) return retryResponse;
+        if (lastResult.response.status < 500) return lastResult;
       }
-      return null;
+      return lastResult?.failure?.retryScope === "same_account" ? lastResult : null;
     }
-    const dispatchResponseStatus = async (account, accountUuid, runtime, response, allow401Retry, from401RefreshRetry) => {
+    async function fetchAndSupervise(runtime) {
+      const [attemptInput, attemptInit] = createFetchArguments();
+      const response = await runtime.fetch(attemptInput, attemptInit);
+      return responseSupervisor ? responseSupervisor(response) : { response };
+    }
+    const dispatchResponseStatus = async (account, accountUuid, runtime, initialResult, allow401Retry, from401RefreshRetry) => {
+      let result = initialResult;
+      let response = result.response;
+      if (result.failure && (result.downstreamVisible || result.failure.retryScope === "none")) {
+        return { type: "handled", response };
+      }
       if (response.status >= 500) {
         const recovered = await retryServerErrors(account, runtime);
         if (recovered === null) {
           return { type: "retryOuter" };
         }
-        response = recovered;
+        result = recovered;
+        response = result.response;
+        if (result.failure?.retryScope === "same_account" && response.status >= 500) {
+          return { type: "handled", response };
+        }
       }
       if (response.status === 401) {
         if (allow401Retry) {
           runtimeFactory.invalidate(accountUuid);
           try {
             const retryRuntime = await runtimeFactory.getRuntime(accountUuid);
-            const retryResponse = await retryRuntime.fetch(input, init);
-            return dispatchResponseStatus(account, accountUuid, retryRuntime, retryResponse, false, true);
+            const retryResult = await fetchAndSupervise(retryRuntime);
+            return dispatchResponseStatus(account, accountUuid, retryRuntime, retryResult, false, true);
           } catch (error) {
             if (isAbortError(error)) throw error;
             await handleRuntimeFetchFailure(manager, runtimeFactory, client, account, error);
@@ -1617,6 +1648,13 @@ function createExecutorForProvider(providerName, dependencies) {
       }
       if (response.status === 429) {
         await handleRateLimitResponse(manager, client, account, response);
+        if (result.failure?.retryScope === "next_account") {
+          startupFailureAccounts.add(accountUuid);
+          lastStartupFailure = response;
+          if (startupFailureAccounts.size >= manager.getAccountCount()) {
+            return { type: "handled", response };
+          }
+        }
         return { type: "handled" };
       }
       return { type: "success", response };
@@ -1631,10 +1669,10 @@ function createExecutorForProvider(providerName, dependencies) {
       }
       previousAccountUuid = accountUuid;
       let runtime;
-      let response;
+      let result;
       try {
         runtime = await runtimeFactory.getRuntime(accountUuid);
-        response = await runtime.fetch(input, init);
+        result = await fetchAndSupervise(runtime);
       } catch (error) {
         if (isAbortError(error)) throw error;
         if (await handleRuntimeFetchFailure(manager, runtimeFactory, client, account, error)) {
@@ -1643,7 +1681,7 @@ function createExecutorForProvider(providerName, dependencies) {
         void showToast2(client, `${getAccountLabel2(account)} network error \u2014 switching`, "warning");
         continue;
       }
-      const transition = await dispatchResponseStatus(account, accountUuid, runtime, response, true, false);
+      const transition = await dispatchResponseStatus(account, accountUuid, runtime, result, true, false);
       if (transition.type === "retryOuter" || transition.type === "handled") {
         if (transition.type === "handled" && transition.response) {
           return transition.response;
@@ -1653,6 +1691,7 @@ function createExecutorForProvider(providerName, dependencies) {
       await manager.markSuccess(accountUuid);
       return transition.response;
     }
+    if (lastStartupFailure) return lastStartupFailure;
     throw new Error(
       `Exhausted ${maxRetries} retries across all accounts. All attempts failed due to auth errors, rate limits, or token issues.`
     );
@@ -2283,6 +2322,275 @@ var openAIOAuthAdapter = {
   supported: true
 };
 
+// src/turn-supervisor.ts
+async function superviseSseResponseStartup(response, options) {
+  const contentType = response.headers.get("content-type")?.toLowerCase();
+  if (!response.ok || !response.body || !contentType?.includes("text/event-stream")) {
+    return { response };
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  const decoder = new TextDecoder();
+  let bufferedBytes = 0;
+  let pendingText = "";
+  let failure;
+  let downstreamVisible = false;
+  let done = false;
+  while (!failure && !downstreamVisible) {
+    const next = await reader.read();
+    if (next.done) {
+      done = true;
+      break;
+    }
+    chunks.push(next.value);
+    bufferedBytes += next.value.byteLength;
+    pendingText += decoder.decode(next.value, { stream: true });
+    pendingText = drainSseFrames(pendingText, inspectFrame);
+    if (!failure && !downstreamVisible && bufferedBytes >= options.maxBufferedBytes) {
+      failure = options.createBufferLimitFailure(bufferedBytes);
+    }
+  }
+  if (done && !failure && !downstreamVisible) {
+    pendingText += decoder.decode();
+    if (pendingText.trim()) inspectFrame(pendingText);
+  }
+  if (failure) {
+    await reader.cancel().catch(() => void 0);
+    return {
+      failure,
+      downstreamVisible: false,
+      response: options.createFailureResponse(failure)
+    };
+  }
+  return {
+    downstreamVisible,
+    response: new Response(replayResponseBody(chunks, reader), {
+      status: response.status,
+      statusText: response.statusText,
+      headers: filterStreamingResponseHeaders(response.headers)
+    })
+  };
+  function inspectFrame(frame) {
+    if (failure || downstreamVisible) return;
+    failure = options.classifyFailure(frame);
+    if (!failure && options.isCommitFrame(frame)) downstreamVisible = true;
+  }
+}
+function drainSseFrames(buffer, onFrame) {
+  let remainder = buffer;
+  while (true) {
+    const separator = /(?:\r\n|\r|\n)(?:\r\n|\r|\n)/.exec(remainder);
+    if (!separator || separator.index === void 0) return remainder;
+    const frame = remainder.slice(0, separator.index);
+    remainder = remainder.slice(separator.index + separator[0].length);
+    if (frame.trim()) onFrame(frame);
+  }
+}
+function replayResponseBody(chunks, reader) {
+  let index = 0;
+  return new ReadableStream({
+    async pull(controller) {
+      if (index < chunks.length) {
+        controller.enqueue(chunks[index++]);
+        return;
+      }
+      const next = await reader.read();
+      if (next.done) {
+        controller.close();
+        return;
+      }
+      controller.enqueue(next.value);
+    },
+    cancel(reason) {
+      return reader.cancel(reason);
+    }
+  });
+}
+function filterStreamingResponseHeaders(headers) {
+  const filtered = new Headers(headers);
+  filtered.delete("content-encoding");
+  filtered.delete("content-length");
+  filtered.delete("transfer-encoding");
+  filtered.delete("connection");
+  return filtered;
+}
+
+// src/adapters/codex-responses.ts
+var CODEX_UNKNOWN_RATE_LIMIT_BACKOFF_MS = 5 * 60 * 1e3;
+var CODEX_STARTUP_PROBE_MAX_BYTES = 64 * 1024;
+function superviseCodexResponseStartup(response) {
+  return superviseSseResponseStartup(response, {
+    maxBufferedBytes: CODEX_STARTUP_PROBE_MAX_BYTES,
+    classifyFailure: classifyCodexSseStartupFailure,
+    isCommitFrame: isCodexStartupOutputFrame,
+    createBufferLimitFailure: createCodexBufferLimitFailure,
+    createFailureResponse: codexFailureResponse
+  });
+}
+function createCodexBufferLimitFailure(bufferedBytes) {
+  return {
+    class: "transient",
+    phase: "startup",
+    code: "startup_buffer_limit_exceeded",
+    message: `Codex upstream produced ${bufferedBytes} bytes without output; retrying before exposing the stream.`,
+    httpStatus: 502,
+    retryScope: "same_account"
+  };
+}
+function isCodexStartupOutputFrame(frame) {
+  const payload = readSseJsonRecord(frame);
+  if (!payload) return false;
+  return isCodexStartupOutputEvent(payload, readSseEvent(frame));
+}
+function isCodexStartupOutputEvent(value, event) {
+  const payload = readRecord(value);
+  if (!payload) return false;
+  const type = readString(payload.type) ?? event;
+  if (type === "response.output_text.delta" || type === "response.refusal.delta" || type === "response.function_call_arguments.delta" || type === "response.function_call_arguments.done" || type === "response.output_item.done" || type === "response.completed" || type === "response.incomplete") {
+    return true;
+  }
+  if (type === "response.output_item.added") {
+    const item = readRecord(payload.item);
+    const itemType = readString(item?.type);
+    return itemType === "message" || itemType === "function_call";
+  }
+  return false;
+}
+function classifyCodexSseStartupFailure(frame) {
+  const event = readSseEvent(frame);
+  const payload = readSseJsonRecord(frame);
+  if (!payload) return void 0;
+  const payloadType = readString(payload.type);
+  if (event !== "response.failed" && event !== "error" && payloadType !== "response.failed" && payloadType !== "error") {
+    return void 0;
+  }
+  return classifyCodexFailurePayload(payload, "startup");
+}
+function classifyCodexJsonEventFailure(value, phase) {
+  const payload = readRecord(value);
+  if (!payload) return void 0;
+  const payloadType = readString(payload.type);
+  if (payloadType !== "response.failed" && payloadType !== "error") return void 0;
+  return classifyCodexFailurePayload(payload, phase);
+}
+function classifyCodexFailure(code, message) {
+  const normalizedCode = code?.toLowerCase();
+  if (normalizedCode === "rate_limit_exceeded" || normalizedCode === "usage_limit_reached") return "rate_limit";
+  if (normalizedCode === "insufficient_quota" || normalizedCode === "usage_not_included" || normalizedCode === "quota_exceeded") return "quota";
+  if (normalizedCode === "invalid_api_key" || normalizedCode === "invalid_iam_token") return "auth";
+  if (normalizedCode === "server_is_overloaded" || normalizedCode === "slow_down" || normalizedCode === "model_at_capacity") return "transient";
+  const normalized = `${code ?? ""} ${message}`.toLowerCase();
+  if (normalized.includes("rate_limit") || normalized.includes("usage_limit") || normalized.includes("usage limit") || normalized.includes("codex/settings/usage") || normalized.includes("upgrade to pro") || normalized.includes("purchase more credits")) return "rate_limit";
+  if (normalized.includes("quota exceeded") || normalized.includes("insufficient quota") || normalized.includes("usage not included")) return "quota";
+  return "transient";
+}
+function parseCodexRetryAfterSeconds(message) {
+  const match = message.match(/try again in\s*(\d+(?:\.\d+)?)\s*(ms|s|seconds?)/i);
+  if (!match) return void 0;
+  const value = Number.parseFloat(match[1]);
+  if (!Number.isFinite(value) || value <= 0) return void 0;
+  return match[2].toLowerCase() === "ms" ? value / 1e3 : value;
+}
+function classifyCodexFailurePayload(payload, phase) {
+  const response = readRecord(payload.response);
+  const error = readRecord(response?.error) ?? readRecord(payload.error);
+  const code = readString(error?.code) ?? readString(error?.type) ?? readString(payload.code);
+  const message = readString(error?.message) ?? readString(payload.message) ?? (code ? `Codex upstream failed: ${code}` : "Codex upstream failed before producing output.");
+  const failureClass = classifyCodexFailure(code, message);
+  const retryAfterSeconds = parseCodexRetryAfterSeconds(message);
+  const resetAt = parseCodexResetMetadata(error) ?? parseCodexResetMetadata(payload) ?? defaultCodexResetAt(failureClass, code, message);
+  return {
+    class: failureClass,
+    phase,
+    code: code ?? (failureClass === "rate_limit" ? "rate_limit_exceeded" : "upstream_response_failed"),
+    message,
+    httpStatus: readNumber(payload.status) ?? httpStatusFromCodexFailure(failureClass),
+    retryAfterSeconds: retryAfterSeconds ?? secondsUntilIso(resetAt),
+    resetAt,
+    retryScope: failureClass === "rate_limit" || failureClass === "quota" || failureClass === "auth" ? "next_account" : failureClass === "transient" ? "same_account" : "none"
+  };
+}
+function codexFailureResponse(failure) {
+  const headers = new Headers({ "content-type": "application/json; charset=utf-8" });
+  if (failure.retryAfterSeconds) headers.set("retry-after", String(failure.retryAfterSeconds));
+  if (failure.resetAt) headers.set("x-kyoli-account-reset-at", failure.resetAt);
+  return new Response(JSON.stringify({
+    error: {
+      type: failure.code ?? "upstream_response_failed",
+      message: failure.message ?? "Codex upstream failed before producing output.",
+      upstream_status: "response.failed"
+    }
+  }), {
+    status: failure.httpStatus ?? 502,
+    headers
+  });
+}
+function httpStatusFromCodexFailure(failureClass) {
+  if (failureClass === "rate_limit" || failureClass === "quota") return 429;
+  if (failureClass === "auth") return 401;
+  if (failureClass === "permanent") return 403;
+  return 502;
+}
+function parseCodexResetMetadata(value) {
+  if (!value) return void 0;
+  const resetsAt = readNumeric(value.resets_at);
+  if (resetsAt !== void 0 && resetsAt > 0) {
+    const ms = resetsAt > 1e12 ? resetsAt : resetsAt * 1e3;
+    const date = new Date(ms);
+    return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
+  }
+  const resetsInSeconds = readNumeric(value.resets_in_seconds);
+  if (resetsInSeconds !== void 0 && resetsInSeconds > 0) {
+    return new Date(Date.now() + resetsInSeconds * 1e3).toISOString();
+  }
+  return void 0;
+}
+function defaultCodexResetAt(failureClass, code, message) {
+  if (failureClass !== "rate_limit" && failureClass !== "quota") return void 0;
+  if (isCodexUsageLimitFailure(code, message)) return void 0;
+  return new Date(Date.now() + CODEX_UNKNOWN_RATE_LIMIT_BACKOFF_MS).toISOString();
+}
+function isCodexUsageLimitFailure(code, message) {
+  const normalized = `${code ?? ""} ${message}`.toLowerCase();
+  return normalized.includes("usage_limit_reached") || normalized.includes("usage limit") || normalized.includes("codex/settings/usage") || normalized.includes("upgrade to plus") || normalized.includes("upgrade to pro") || normalized.includes("purchase more credits");
+}
+function readSseEvent(frame) {
+  return frame.split(/\r\n|\r|\n/).find((line) => line.startsWith("event:"))?.slice("event:".length).trim();
+}
+function readSseData(frame) {
+  const lines = frame.split(/\r\n|\r|\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice("data:".length).trimStart());
+  return lines.length > 0 ? lines.join("\n") : void 0;
+}
+function readSseJsonRecord(frame) {
+  const data = readSseData(frame);
+  if (!data || data === "[DONE]") return void 0;
+  try {
+    return readRecord(JSON.parse(data));
+  } catch {
+    return void 0;
+  }
+}
+function readRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function readString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readNumeric(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value !== "string") return void 0;
+  const parsed = Number(value.trim());
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function secondsUntilIso(iso) {
+  if (!iso) return void 0;
+  const ms = new Date(iso).getTime() - Date.now();
+  return Number.isFinite(ms) && ms > 0 ? Math.ceil(ms / 1e3) : void 0;
+}
+
 // src/pool-types.ts
 import * as v5 from "valibot";
 var PoolConfigSchema = v5.object({
@@ -2955,6 +3263,8 @@ export {
   AccountSelectionStrategySchema,
   AccountStorageSchema,
   AccountStore,
+  CODEX_STARTUP_PROBE_MAX_BYTES,
+  CODEX_UNKNOWN_RATE_LIMIT_BACKOFF_MS,
   CascadeStateManager,
   ChainConfigSchema,
   ChainEntryConfigSchema,
@@ -2970,6 +3280,9 @@ export {
   UsageLimitsSchema,
   __openCodeNativeBootstrapAuthTestUtils,
   anthropicOAuthAdapter,
+  classifyCodexFailure,
+  classifyCodexJsonEventFailure,
+  classifyCodexSseStartupFailure,
   confirm,
   createAccountManagerForProvider,
   createClaimsManager,
@@ -2983,6 +3296,7 @@ export {
   createRateLimitHandlers,
   debugLog,
   deduplicateAccounts,
+  drainSseFrames,
   formatWaitTime,
   getAccountLabel,
   getClearedOAuthBody,
@@ -2991,6 +3305,8 @@ export {
   getErrorCode,
   initCoreConfig,
   isClaimedByOther,
+  isCodexStartupOutputEvent,
+  isCodexStartupOutputFrame,
   isTTY,
   isTokenRefreshError,
   loadAccounts,
@@ -2998,6 +3314,7 @@ export {
   loadPoolChainConfig,
   migrateFromAuthJson,
   openAIOAuthAdapter,
+  parseCodexRetryAfterSeconds,
   parseKey,
   readClaims,
   readStorageFromDisk,
@@ -3010,6 +3327,8 @@ export {
   setConfigGetter,
   showToast,
   sleep,
+  superviseCodexResponseStartup,
+  superviseSseResponseStartup,
   syncOpenCodeNativeBootstrapAuth,
   updateConfigField,
   withDirectoryLock,