ai-zero-token 2.0.6 → 2.0.8

package/dist/core/providers/http-client.js

@@ -56,6 +56,60 @@ function logHttpTiming(params) {
     totalMs: params.timing.totalMs
   });
 }
+function createHttpTransportError(message, params) {
+  const error = new Error(message);
+  error.code = params.code;
+  error.elapsedMs = roundMs(params.elapsedMs);
+  error.isTransient = params.transient ?? true;
+  error.method = params.method;
+  error.requestId = params.requestId;
+  error.statusCode = params.statusCode;
+  error.transport = params.transport;
+  error.upstreamConnectionError = params.upstreamConnectionError ?? true;
+  error.url = params.url;
+  return error;
+}
+function classifyCurlRequestError(stderr, exitCode) {
+  const normalized = stderr.toLowerCase();
+  if (exitCode === 35 || normalized.includes("ssl_connect") || normalized.includes("ssl_error_syscall")) {
+    return {
+      code: "curl_request_tls_failed",
+      statusCode: 502
+    };
+  }
+  if (exitCode === 6 || normalized.includes("could not resolve host") || normalized.includes("name lookup timed out")) {
+    return {
+      code: "curl_request_dns_failed",
+      statusCode: 502
+    };
+  }
+  if (exitCode === 7 || normalized.includes("failed to connect") || normalized.includes("connection refused")) {
+    return {
+      code: "curl_request_connect_failed",
+      statusCode: 502
+    };
+  }
+  if (exitCode === 28 || normalized.includes("operation timed out") || normalized.includes("timed out")) {
+    return {
+      code: "curl_request_timeout",
+      statusCode: 504
+    };
+  }
+  return {
+    code: "curl_request_failed",
+    statusCode: 502
+  };
+}
+function isTransientHttpError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const details = error;
+  if (details.isTransient === true || details.upstreamConnectionError === true) {
+    return true;
+  }
+  return typeof details.code === "string" && (details.code === "curl_stream_closed_before_headers" || details.code === "curl_stream_header_timeout" || details.code === "curl_stream_body_failed" || details.code === "curl_request_tls_failed" || details.code === "curl_request_dns_failed" || details.code === "curl_request_connect_failed" || details.code === "curl_request_timeout" || details.code === "curl_request_failed");
+}
 function isElectronRuntime() {
   return typeof process.versions.electron === "string";
 }
@@ -83,12 +137,7 @@ function normalizeCurlHeaders(value) {
     })
   );
 }
-function parseCurlHeaderDump(raw) {
-  const blocks = raw.replace(/\r\n/g, "\n").split(/\n\n+/).map((block2) => block2.trim()).filter((block2) => /^HTTP\//i.test(block2));
-  const block = blocks[blocks.length - 1];
-  if (!block) {
-    return null;
-  }
+function parseCurlHeaderBlock(block) {
   const lines = block.split("\n");
   const statusMatch = /^HTTP(?:\/\S+)?\s+(\d{3})/i.exec(lines[0]?.trim() ?? "");
   const status = statusMatch ? Number.parseInt(statusMatch[1], 10) : NaN;
@@ -110,6 +159,33 @@ function parseCurlHeaderDump(raw) {
   }
   return { status, headers };
 }
+function parseCurlHeaderDump(raw) {
+  const normalized = raw.replace(/\r\n/g, "\n");
+  const blocks = [];
+  let blockStart = 0;
+  while (blockStart < normalized.length) {
+    const separatorIndex = normalized.indexOf("\n\n", blockStart);
+    if (separatorIndex === -1) {
+      break;
+    }
+    const block = normalized.slice(blockStart, separatorIndex).trim();
+    if (/^HTTP\//i.test(block)) {
+      blocks.push(block);
+    }
+    blockStart = separatorIndex + 2;
+    while (normalized[blockStart] === "\n") {
+      blockStart += 1;
+    }
+  }
+  for (let index = blocks.length - 1; index >= 0; index -= 1) {
+    const parsed = parseCurlHeaderBlock(blocks[index]);
+    if (!parsed || parsed.status >= 100 && parsed.status < 200) {
+      continue;
+    }
+    return parsed;
+  }
+  return null;
+}
 async function runCurlRequest(init, params) {
   const requestId = params?.requestId ?? nextRequestId();
   const startedAt = performance.now();
@@ -166,7 +242,20 @@ async function runCurlRequest(init, params) {
   });
   phases.waitForCurlMs = performance.now() - startedAt - phases.spawnCurlMs;
   if (exitCode !== 0) {
-    throw new Error(stderr.trim() || `curl \u8BF7\u6C42\u5931\u8D25\uFF0C\u9000\u51FA\u7801 ${exitCode}`);
+    const stderrText = stderr.trim();
+    const classification = classifyCurlRequestError(stderrText, exitCode);
+    throw createHttpTransportError(
+      stderrText || `curl \u8BF7\u6C42\u5931\u8D25\uFF0C\u9000\u51FA\u7801 ${exitCode}\uFF08requestId=${requestId}\uFF09\u3002`,
+      {
+        code: classification.code,
+        elapsedMs: performance.now() - startedAt,
+        method: init.method,
+        requestId,
+        statusCode: classification.statusCode,
+        transport: "curl",
+        url: init.url
+      }
+    );
   }
   const parseStartedAt = performance.now();
   const statusMarkerIndex = stdout.lastIndexOf(CURL_STATUS_MARKER);
@@ -224,18 +313,44 @@ async function waitForCurlHeaders(params) {
       const raw = await fs.readFile(params.headerPath, "utf8");
       const parsed = parseCurlHeaderDump(raw);
       if (parsed) {
+        if (parsed.status >= 300 && parsed.status < 400 && !params.isClosed()) {
+          await new Promise((resolve) => setTimeout(resolve, 25));
+          continue;
+        }
         return parsed;
       }
     } catch {
     }
     if (params.isClosed()) {
-      throw new Error(params.stderr().trim() || "curl stream \u8BF7\u6C42\u5728\u8FD4\u56DE\u54CD\u5E94\u5934\u524D\u7ED3\u675F\u3002");
+      const stderr2 = params.stderr().trim();
+      const exitCode = params.exitCode();
+      throw createHttpTransportError(
+        stderr2 || `curl stream \u8BF7\u6C42\u5728\u8FD4\u56DE\u54CD\u5E94\u5934\u524D\u7ED3\u675F\uFF08requestId=${params.requestId}${exitCode ? `, exitCode=${exitCode}` : ""}\uFF09\u3002`,
+        {
+          code: "curl_stream_closed_before_headers",
+          elapsedMs: performance.now() - startedAt,
+          method: params.method,
+          requestId: params.requestId,
+          statusCode: 502,
+          transport: "curl",
+          url: params.url
+        }
+      );
     }
     await new Promise((resolve) => setTimeout(resolve, 25));
   }
   const stderr = params.stderr().trim();
-  throw new Error(
-    `\u7B49\u5F85 curl stream \u54CD\u5E94\u5934\u8D85\u65F6\uFF08${Math.round(params.timeoutMs / 1e3)} \u79D2\uFF0CrequestId=${params.requestId}\uFF09\u3002${stderr ? ` ${stderr}` : ""}`
+  throw createHttpTransportError(
+    `\u7B49\u5F85 curl stream \u54CD\u5E94\u5934\u8D85\u65F6\uFF08${Math.round(params.timeoutMs / 1e3)} \u79D2\uFF0CrequestId=${params.requestId}\uFF09\u3002${stderr ? ` ${stderr}` : ""}`,
+    {
+      code: "curl_stream_header_timeout",
+      elapsedMs: performance.now() - startedAt,
+      method: params.method,
+      requestId: params.requestId,
+      statusCode: 504,
+      transport: "curl",
+      url: params.url
+    }
   );
 }
 async function runCurlStream(init, params) {
@@ -310,17 +425,31 @@ async function runCurlStream(init, params) {
     init.signal?.removeEventListener("abort", abort);
     void fs.unlink(headerPath).catch(() => void 0);
     if (exitCode !== 0 && !init.signal?.aborted) {
-      body.destroy(new Error(stderr.trim() || `curl stream \u8BF7\u6C42\u5931\u8D25\uFF0C\u9000\u51FA\u7801 ${exitCode}`));
+      body.destroy(createHttpTransportError(
+        stderr.trim() || `curl stream \u8BF7\u6C42\u5931\u8D25\uFF0C\u9000\u51FA\u7801 ${exitCode}\uFF08requestId=${requestId}\uFF09\u3002`,
+        {
+          code: "curl_stream_body_failed",
+          elapsedMs: performance.now() - startedAt,
+          method: init.method,
+          requestId,
+          statusCode: 502,
+          transport: "curl",
+          url: init.url
+        }
+      ));
     }
   });
   let parsed;
   try {
     parsed = await waitForCurlHeaders({
       headerPath,
+      method: init.method,
       isClosed: () => closed,
+      exitCode: () => exitCode,
       stderr: () => stderr,
       requestId,
-      timeoutMs: getCurlStreamHeaderTimeoutMs(params?.timeoutMs)
+      timeoutMs: getCurlStreamHeaderTimeoutMs(params?.timeoutMs),
+      url: init.url
     });
   } catch (error) {
     child.kill("SIGTERM");
@@ -480,6 +609,7 @@ async function requestStream(init) {
   });
 }
 export {
+  isTransientHttpError,
   requestStream,
   requestText
 };

package/dist/core/providers/openai-codex/chat.js

@@ -1,8 +1,11 @@
 #!/usr/bin/env node
+import { createHash } from "node:crypto";
 import { DEFAULT_CODEX_MODEL } from "../../models/openai-codex-models.js";
 import { requestStream, requestText } from "../http-client.js";
 const CODEX_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
 const CODEX_RESPONSES_COMPACT_URL = `${CODEX_RESPONSES_URL}/compact`;
+const COMPAT_PROMPT_CACHE_KEY_PREFIX = "compat_cc_";
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 const URL_KEY_RE = /(url|uri|href|download|preview|thumbnail|image|asset|file)/i;
 const REFERENCE_KEY_RE = /(image|asset|file|media|blob|artifact|download|preview|thumbnail)/i;
 const REFERENCE_VALUE_RE = /^(file|asset|image|img|media|blob)-[\w-]+$/i;
@@ -60,8 +63,125 @@ function parseUpstreamErrorBody(body) {
     return void 0;
   }
 }
-function buildCodexRequestHeaders(profile) {
-  return {
+function hashShort(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 16);
+}
+function stableStringify(value) {
+  if (typeof value === "undefined") {
+    return "";
+  }
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value) ?? String(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const record = value;
+  return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+}
+function shouldAutoInjectPromptCacheKeyForCompat(model) {
+  const normalized = typeof model === "string" && model.trim() ? model.trim().toLowerCase() : DEFAULT_CODEX_MODEL.toLowerCase();
+  return normalized.includes("gpt-5") || normalized.includes("codex");
+}
+function extractInputContentText(content) {
+  if (typeof content === "string") {
+    return content.trim();
+  }
+  if (!Array.isArray(content)) {
+    const record = asRecord(content);
+    return typeof record?.text === "string" ? record.text.trim() : "";
+  }
+  return content.map((part) => {
+    const record = asRecord(part);
+    if (!record) {
+      return "";
+    }
+    if (typeof record.text === "string") {
+      return record.text.trim();
+    }
+    if (typeof record.input_text === "string") {
+      return record.input_text.trim();
+    }
+    return "";
+  }).filter(Boolean).join("\n").trim();
+}
+function extractFirstInputTextByRole(input, roles) {
+  if (typeof input === "string") {
+    return roles.has("user") ? input.trim() : "";
+  }
+  if (!Array.isArray(input)) {
+    return "";
+  }
+  for (const item of input) {
+    const record = asRecord(item);
+    if (!record) {
+      continue;
+    }
+    const role = typeof record.role === "string" ? record.role.trim().toLowerCase() : "user";
+    if (!roles.has(role)) {
+      continue;
+    }
+    const text = extractInputContentText(record.content);
+    if (text) {
+      return text;
+    }
+  }
+  return "";
+}
+function deriveCompatPromptCacheKey(body) {
+  const model = typeof body.model === "string" && body.model.trim() ? body.model.trim() : DEFAULT_CODEX_MODEL;
+  if (!shouldAutoInjectPromptCacheKeyForCompat(model)) {
+    return "";
+  }
+  const seedParts = [`model=${model}`];
+  const reasoning = asRecord(body.reasoning);
+  if (typeof reasoning?.effort === "string" && reasoning.effort.trim()) {
+    seedParts.push(`reasoning_effort=${reasoning.effort.trim()}`);
+  }
+  if (typeof body.tool_choice !== "undefined") {
+    seedParts.push(`tool_choice=${stableStringify(body.tool_choice)}`);
+  }
+  if (Array.isArray(body.tools) && body.tools.length > 0) {
+    seedParts.push(`tools=${stableStringify(body.tools)}`);
+  }
+  if (typeof body.instructions === "string" && body.instructions.trim()) {
+    seedParts.push(`instructions=${body.instructions.trim()}`);
+  }
+  const systemText = extractFirstInputTextByRole(body.input, /* @__PURE__ */ new Set(["system", "developer"]));
+  if (systemText) {
+    seedParts.push(`system=${systemText}`);
+  }
+  const firstUserText = extractFirstInputTextByRole(body.input, /* @__PURE__ */ new Set(["user"]));
+  if (firstUserText) {
+    seedParts.push(`first_user=${firstUserText}`);
+  }
+  return `${COMPAT_PROMPT_CACHE_KEY_PREFIX}${hashShort(seedParts.join("|"))}`;
+}
+function withCompatPromptCacheKey(body) {
+  const existing = typeof body.prompt_cache_key === "string" ? body.prompt_cache_key.trim() : "";
+  if (existing) {
+    return body;
+  }
+  const promptCacheKey = deriveCompatPromptCacheKey(body);
+  return promptCacheKey ? { ...body, prompt_cache_key: promptCacheKey } : body;
+}
+function deterministicSessionUUID(seed) {
+  const hash = Buffer.from(createHash("sha256").update(seed).digest().subarray(0, 16));
+  hash[6] = hash[6] & 15 | 64;
+  hash[8] = hash[8] & 63 | 128;
+  const hex = hash.toString("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function normalizeSessionIdentifier(value) {
+  const trimmed = value.trim();
+  return UUID_RE.test(trimmed) ? trimmed : deterministicSessionUUID(trimmed);
+}
+function requestBodyString(body, key) {
+  const value = body?.[key];
+  return typeof value === "string" ? value.trim() : "";
+}
+function buildCodexRequestHeaders(profile, requestBody) {
+  const headers = {
     Accept: "text/event-stream",
     "Content-Type": "application/json",
     Authorization: `Bearer ${profile.access}`,
@@ -70,6 +190,17 @@ function buildCodexRequestHeaders(profile) {
     Originator: "pi",
     "User-Agent": "pi (bun demo)"
   };
+  const explicitSessionId = requestBodyString(requestBody, "session_id");
+  const conversationId = requestBodyString(requestBody, "conversation_id");
+  const promptCacheKey = requestBodyString(requestBody, "prompt_cache_key");
+  const sessionSeed = explicitSessionId || promptCacheKey || conversationId;
+  if (sessionSeed) {
+    headers.session_id = normalizeSessionIdentifier(sessionSeed);
+  }
+  if (conversationId) {
+    headers.conversation_id = normalizeSessionIdentifier(conversationId);
+  }
+  return headers;
 }
 function createCodexUpstreamError(status, body, transport, quota, requestId) {
   const upstreamError = parseUpstreamErrorBody(body);
@@ -397,17 +528,17 @@ function extractCodexText(body, requestBody) {
   };
 }
 async function askOpenAICodex(params) {
-  const requestBody = {
+  const requestBody = withCompatPromptCacheKey({
     ...buildDefaultRequestBody(params),
     ...params.bodyOverride ?? {}
-  };
+  });
   if (typeof requestBody.input === "undefined") {
     throw new Error("Codex \u8BF7\u6C42\u7F3A\u5C11 input\u3002\u8BF7\u63D0\u4F9B prompt \u6216\u5728\u5B9E\u9A8C\u8BF7\u6C42\u4F53\u91CC\u663E\u5F0F\u4F20\u5165 input\u3002");
   }
   const response = await requestText({
     method: "POST",
     url: CODEX_RESPONSES_URL,
-    headers: buildCodexRequestHeaders(params.profile),
+    headers: buildCodexRequestHeaders(params.profile, requestBody),
     body: JSON.stringify(requestBody)
   });
   const quota = extractCodexQuotaSnapshot(response.headers, response.requestId);
@@ -420,17 +551,17 @@ async function askOpenAICodex(params) {
   };
 }
 async function streamOpenAICodex(params) {
-  const requestBody = params.passthroughBody ? { ...params.bodyOverride ?? {} } : {
+  const requestBody = params.passthroughBody ? { ...params.bodyOverride ?? {} } : withCompatPromptCacheKey({
     ...buildDefaultRequestBody(params),
     ...params.bodyOverride ?? {}
-  };
+  });
   if (!params.passthroughBody && typeof requestBody.input === "undefined") {
     throw new Error("Codex \u8BF7\u6C42\u7F3A\u5C11 input\u3002\u8BF7\u63D0\u4F9B prompt \u6216\u5728\u5B9E\u9A8C\u8BF7\u6C42\u4F53\u91CC\u663E\u5F0F\u4F20\u5165 input\u3002");
   }
   const response = await requestStream({
     method: "POST",
     url: params.endpoint === "responses/compact" ? CODEX_RESPONSES_COMPACT_URL : CODEX_RESPONSES_URL,
-    headers: buildCodexRequestHeaders(params.profile),
+    headers: buildCodexRequestHeaders(params.profile, requestBody),
     body: JSON.stringify(requestBody),
     signal: params.signal
   });

package/dist/core/services/auth-service.js

@@ -14,6 +14,7 @@ import {
   refreshOpenAICodexToken
 } from "../providers/openai-codex/oauth.js";
 import { askOpenAICodex } from "../providers/openai-codex/chat.js";
+import { isTransientHttpError } from "../providers/http-client.js";
 import {
   applyGatewayToCodexProviderConfig,
   applyProfileToCodexAuth,
@@ -151,6 +152,17 @@ class AuthService {
     const percents = this.getQuotaPercents(profile);
     return percents.length > 0 && percents.some((value) => value >= 100);
   }
+  isQuotaSnapshotExhausted(quota) {
+    if (!quota) {
+      return false;
+    }
+    return [quota.primaryUsedPercent, quota.secondaryUsedPercent].some(
+      (value) => typeof value === "number" && Number.isFinite(value) && value >= 100
+    );
+  }
+  isQuotaBlocked(profile) {
+    return this.isQuotaExhausted(profile) && !this.hasResetElapsedForExhaustedQuota(profile);
+  }
   timestampToMillis(value) {
     if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
       return void 0;
@@ -201,17 +213,38 @@ class AuthService {
     }
     const percents = this.getQuotaPercents(profile);
     if (percents.length === 0) {
-      return false;
+      return true;
     }
     return percents.every((value) => value < 100) || this.hasResetElapsedForExhaustedQuota(profile);
   }
   hasInvalidAuthStatus(profile) {
     return profile.authStatus?.state === "token_invalidated" || profile.authStatus?.state === "auth_error";
   }
+  shouldLeaveActiveProfile(profile) {
+    return this.hasInvalidAuthStatus(profile) || this.isQuotaBlocked(profile);
+  }
+  isRotationTrigger(error, quota) {
+    if (this.isQuotaSnapshotExhausted(quota)) {
+      return true;
+    }
+    if (isTransientHttpError(error)) {
+      return true;
+    }
+    const normalized = error instanceof Error ? error : new Error(String(error));
+    const details = normalized;
+    const status = typeof details.upstreamStatus === "number" ? details.upstreamStatus : void 0;
+    const marker = [
+      normalized.message,
+      details.upstreamErrorCode,
+      details.upstreamErrorType,
+      details.upstreamErrorMessage
+    ].filter((value) => typeof value === "string").join(" ").toLowerCase();
+    return status === 429 || status === 401 || status === 403 || marker.includes("usage_limit_reached") || marker.includes("token_invalidated") || marker.includes("authentication token has been invalidated") || marker.includes("\u5237\u65B0 token \u5931\u8D25");
+  }
   getQuotaUsageScore(profile) {
     const percents = this.getQuotaPercents(profile);
     if (percents.length === 0) {
-      return 100;
+      return 50;
     }
     return Math.max(...percents);
   }
@@ -222,12 +255,12 @@ class AuthService {
       }
       return updater(profile);
     });
-    if (!options?.checkAutoSwitch || options.skipAutoSwitch || !updated || updated.provider !== provider || !this.isQuotaExhausted(updated)) {
+    if (!options?.checkAutoSwitch || options.skipAutoSwitch || !updated || updated.provider !== provider || !this.shouldLeaveActiveProfile(updated)) {
       return updated;
     }
     const activeProfile = await this.getActiveProfile(provider);
     if (activeProfile?.profileId === updated.profileId) {
-      await this.maybeAutoSwitchProfile(updated, provider);
+      return this.maybeAutoSwitchProfile(updated, provider);
     }
     return updated;
   }
@@ -259,7 +292,7 @@ class AuthService {
   async maybeAutoSwitchProfile(profile, provider) {
     const settings = await this.configService.getSettings();
     const excludedProfileIds = new Set(settings.autoSwitch.excludedProfileIds);
-    if (!settings.autoSwitch.enabled || excludedProfileIds.has(profile.profileId) || !this.isQuotaExhausted(profile)) {
+    if (!settings.autoSwitch.enabled || excludedProfileIds.has(profile.profileId) || !this.shouldLeaveActiveProfile(profile)) {
       return profile;
     }
     const [profiles, codexStatus] = await Promise.all([
@@ -302,8 +335,9 @@ class AuthService {
     if (!activated) {
       return profile;
     }
-    console.info("[auth] auto switched active profile after quota exhaustion", {
+    console.info("[auth] auto switched active profile", {
       provider,
+      reason: this.hasInvalidAuthStatus(profile) ? "auth_error" : "quota_exhausted",
       fromProfileId: profile.profileId,
       toProfileId: activated.profileId,
       avoidedCodexAccount: Boolean(codexAccountId && activated.accountId !== codexAccountId)
@@ -448,6 +482,69 @@ class AuthService {
     }
     return this.refreshStoredProfile(profile, provider);
   }
+  async requireUsableProfileById(profileId, provider = "openai-codex") {
+    const profiles = await listProfiles();
+    const profile = profiles.find((item) => item.provider === provider && item.profileId === profileId);
+    if (!profile) {
+      throw new Error(`\u6CA1\u6709\u627E\u5230\u8D26\u53F7: ${profileId}`);
+    }
+    if (Date.now() < profile.expires) {
+      return this.toManagedProfile(profile);
+    }
+    return this.refreshStoredProfile(profile, provider);
+  }
+  async withProfileRotation(provider, runner, options) {
+    const maxAttempts = Math.max(1, Math.min(8, options?.maxAttempts ?? 2));
+    const attemptedProfileIds = /* @__PURE__ */ new Set();
+    let lastError;
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+      let profile;
+      try {
+        profile = await this.requireUsableProfile(provider, {
+          skipAutoSwitch: options?.skipAutoSwitch
+        });
+      } catch (error) {
+        lastError = error;
+        if (options?.skipAutoSwitch || attempt >= maxAttempts - 1 || !this.isRotationTrigger(error)) {
+          throw error;
+        }
+        const activeProfile = await this.getActiveProfile(provider);
+        if (!activeProfile) {
+          throw error;
+        }
+        const switchedProfile = await this.recordProfileRequestFailure(activeProfile.profileId, error, void 0, provider);
+        if (!switchedProfile || switchedProfile.profileId === activeProfile.profileId) {
+          throw error;
+        }
+        continue;
+      }
+      if (attemptedProfileIds.has(profile.profileId)) {
+        break;
+      }
+      attemptedProfileIds.add(profile.profileId);
+      try {
+        const result = await runner(profile, attempt);
+        await this.recordProfileRequestSuccess(profile.profileId, result.quota, provider, {
+          skipAutoSwitch: options?.skipAutoSwitch
+        });
+        return {
+          profile,
+          result,
+          retryCount: attempt
+        };
+      } catch (error) {
+        lastError = error;
+        const quota = error.quota;
+        const switchedProfile = await this.recordProfileRequestFailure(profile.profileId, error, quota, provider, {
+          skipAutoSwitch: options?.skipAutoSwitch
+        });
+        if (options?.skipAutoSwitch || attempt >= maxAttempts - 1 || !this.isRotationTrigger(error, quota) || !switchedProfile || switchedProfile.profileId === profile.profileId || attemptedProfileIds.has(switchedProfile.profileId)) {
+          throw error;
+        }
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError ?? "\u6CA1\u6709\u53EF\u7528\u8D26\u53F7\u53EF\u8F6E\u6362\u3002"));
+  }
   async requireFreshProfileWithIdToken(profileId, provider = "openai-codex") {
     const profiles = await listProfiles();
     const profile = profiles.find((item) => item.provider === provider && item.profileId === profileId);
@@ -585,7 +682,7 @@ class AuthService {
       }),
       {
         skipAutoSwitch: options?.skipAutoSwitch,
-        checkAutoSwitch: Boolean(quota)
+        checkAutoSwitch: Boolean(quota || authStatus)
       }
     );
   }

package/dist/core/services/chat-service.js

@@ -9,29 +9,27 @@ class ChatService {
     const model = await this.deps.modelService.resolveModel(provider, request.model, {
       allowUnknown: request.experimental?.allowUnknownModel
     });
-    const profile = await this.deps.authService.requireUsableProfile(provider);
-    try {
-      const result = await askOpenAICodex({
+    const rotation = await this.deps.authService.withProfileRotation(
+      provider,
+      (profile) => askOpenAICodex({
         profile,
         prompt: request.input,
         model,
         system: request.system,
         bodyOverride: request.experimental?.codexBody
-      });
-      await this.deps.authService.recordProfileRequestSuccess(profile.profileId, result.quota, provider);
-      return {
-        provider,
-        model,
-        text: result.text,
-        toolCalls: result.toolCalls,
-        raw: result.raw,
-        artifacts: result.artifacts
-      };
-    } catch (error) {
-      const quota = error.quota;
-      await this.deps.authService.recordProfileRequestFailure(profile.profileId, error, quota, provider);
-      throw error;
-    }
+      })
+    );
+    const result = rotation.result;
+    return {
+      provider,
+      model,
+      profile: rotation.profile,
+      retryCount: rotation.retryCount,
+      text: result.text,
+      toolCalls: result.toolCalls,
+      raw: result.raw,
+      artifacts: result.artifacts
+    };
   }
 }
 export {