codex-slot 0.1.19 → 0.1.21

package/dist/scheduler.js

@@ -3,216 +3,103 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.pickBestAccount = pickBestAccount;
 exports.listCandidateAccounts = listCandidateAccounts;
 const config_1 = require("./config");
+const scheduler_strategy_1 = require("./scheduler-strategy");
 const status_1 = require("./status");
-const state_1 = require("./state");
-const CRITICAL_WEEKLY_LEFT_PERCENT = 5;
-const LOW_WEEKLY_LEFT_PERCENT = 15;
-const WASTE_HORIZON_SECONDS = 5 * 60 * 60;
-const WEEKLY_WASTE_HORIZON_SECONDS = 7 * 24 * 60 * 60;
-const RECENT_USE_RECOVERY_SECONDS = 30 * 60;
-function nextResetWeight(resetAt) {
-    if (!resetAt) {
-        return Number.MAX_SAFE_INTEGER;
-    }
-    const diff = resetAt * 1000 - Date.now();
-    return diff > 0 ? diff : Number.MAX_SAFE_INTEGER;
-}
-/**
- * 判断账号当前是否仅命中可忽略的短期本地熔断。
- *
- * 这类熔断通常由瞬时网络抖动、上游 5xx 或短暂 token 刷新失败触发，
- * 当系统只剩一个可调度账号时，不应因此立刻把它排除掉。
- *
- * @param status 账号运行时状态。
- * @returns `true` 表示仅存在可回退的短期本地熔断；否则返回 `false`。
- */
-function isSoftLocalBlocked(status) {
-    if (!status.localBlockUntil || status.localBlockUntil * 1000 <= Date.now()) {
-        return false;
-    }
-    return [
-        "request_failed",
-        "upstream_5xx",
-        "temporary_5m_limit",
-        "token_refresh_failed"
-    ].includes(status.localBlockReason ?? "");
-}
+const state_repository_1 = require("./state-repository");
 /**
- * 将百分比字段归一化为 0 到 1 的评分，缺失时按中性值处理。
+ * 构建一次账号调度所需的完整上下文快照。
  *
- * @param value 原始百分比。
- * @returns 归一化后的评分。
- */
-function normalizePercent(value) {
-    if (value === null || value === undefined || Number.isNaN(value)) {
-        return 0.5;
-    }
-    return Math.max(0, Math.min(1, value / 100));
-}
-/**
- * 计算 5 小时窗口的余额浪费压力，越接近重置且剩余额度越多分数越高。
+ * 业务含义：
+ * 1. 调度过程中所有配置、状态与统计都来自同一次快照，避免评分时反复读取文件。
+ * 2. 该函数是调度应用层边界，负责把外部存储数据转成纯策略可消费的输入。
  *
- * @param status 账号运行时状态。
- * @returns 0 到 1 之间的浪费压力评分。
+ * @returns 调度上下文，包含账号配置、运行状态、使用统计与统一时间基准。
+ * @throws 当配置、状态或调度统计读取失败时透传底层异常。
  */
-function computeFiveHourWastePressure(status) {
-    const leftScore = normalizePercent(status.fiveHourLeftPercent);
-    if (!status.fiveHourResetsAt) {
-        return leftScore * 0.2;
-    }
-    const secondsUntilReset = status.fiveHourResetsAt - Math.floor(Date.now() / 1000);
-    if (secondsUntilReset <= 0) {
-        return 0;
-    }
-    const urgency = Math.max(0.1, Math.min(1, (WASTE_HORIZON_SECONDS - secondsUntilReset) / WASTE_HORIZON_SECONDS));
-    return leftScore * urgency;
+function buildSchedulerContext() {
+    const config = (0, config_1.loadConfig)();
+    return {
+        accounts: config.accounts,
+        statuses: (0, status_1.collectAccountStatuses)(),
+        schedulerStats: (0, state_repository_1.loadSchedulerStatsSnapshot)(),
+        nowMs: Date.now()
+    };
 }
 /**
- * 计算周窗口的余额浪费压力，周额度越接近重置且剩余越多分数越高。
+ * 过滤当前可直接参与调度的账号状态。
  *
- * @param status 账号运行时状态。
- * @returns 0 到 1 之间的周窗口浪费压力评分。
- */
-function computeWeeklyWastePressure(status) {
-    const leftScore = normalizePercent(status.weeklyLeftPercent);
-    if (!status.weeklyResetsAt) {
-        return leftScore * 0.1;
-    }
-    const secondsUntilReset = status.weeklyResetsAt - Math.floor(Date.now() / 1000);
-    if (secondsUntilReset <= 0) {
-        return 0;
-    }
-    const urgency = Math.max(0.05, Math.min(1, (WEEKLY_WASTE_HORIZON_SECONDS - secondsUntilReset) / WEEKLY_WASTE_HORIZON_SECONDS));
-    return leftScore * urgency;
-}
-/**
- * 计算 5 小时窗口调度时可借用的周额度承载系数，周余额越低越抑制短窗口冲动。
+ * 业务含义：
+ * 1. 只保留已启用、登录态完整、未触发刷新错误、未限额、未本地熔断的账号。
+ * 2. 具体排序不在这里处理，排序交给纯调度策略。
  *
- * @param status 账号运行时状态。
- * @returns 0 到 1 之间的周额度承载系数。
+ * @param statuses 当前账号运行状态快照。
+ * @returns 可直接调度的账号状态列表。
+ * @throws 无显式抛出。
  */
-function computeWeeklyCapacityFactor(status) {
-    const weeklyLeft = status.weeklyLeftPercent;
-    if (weeklyLeft === null || weeklyLeft === undefined || Number.isNaN(weeklyLeft)) {
-        return 0.7;
-    }
-    if (weeklyLeft <= CRITICAL_WEEKLY_LEFT_PERCENT) {
-        return 0.05;
-    }
-    if (weeklyLeft < LOW_WEEKLY_LEFT_PERCENT) {
-        return 0.2;
-    }
-    if (weeklyLeft < 30) {
-        return 0.55;
-    }
-    return 1;
+function resolveAvailableStatuses(statuses) {
+    return statuses.filter((item) => item.isAvailable);
 }
 /**
- * 计算周额度健康度，低于保护线时非线性降权，避免个别账号过早打穿周窗口。
+ * 过滤软熔断兜底候选账号。
  *
- * @param status 账号运行时状态。
- * @returns 0 到 1 之间的周额度健康评分。
- */
-function computeWeeklyHealthScore(status) {
-    const weeklyLeft = status.weeklyLeftPercent;
-    if (weeklyLeft === null || weeklyLeft === undefined || Number.isNaN(weeklyLeft)) {
-        return 0.5;
-    }
-    if (weeklyLeft <= CRITICAL_WEEKLY_LEFT_PERCENT) {
-        return 0;
-    }
-    if (weeklyLeft < LOW_WEEKLY_LEFT_PERCENT) {
-        return normalizePercent(weeklyLeft) * 0.35;
-    }
-    return normalizePercent(weeklyLeft);
-}
-/**
- * 计算账号使用分散度，成功次数更少且最近未使用的账号分数更高。
+ * 业务含义：
+ * 1. 当所有未限额账号都只剩短期软熔断时，允许这些账号进入兜底调度。
+ * 2. 硬限额、禁用、登录态缺失仍不会进入兜底池。
  *
- * @param status 账号运行时状态。
- * @param minSuccessCount 当前候选账号中的最小成功次数。
- * @param maxSuccessCount 当前候选账号中的最大成功次数。
- * @returns 0 到 1 之间的分散调度评分。
+ * @param statuses 当前账号运行状态快照。
+ * @returns 可用于软熔断兜底的账号状态列表；不满足兜底条件时返回空列表。
+ * @throws 无显式抛出。
  */
-function computeSpreadScore(status, minSuccessCount, maxSuccessCount) {
-    const stats = (0, state_1.getSchedulerStats)(status.id);
-    const countRange = Math.max(1, maxSuccessCount - minSuccessCount);
-    const countScore = 1 - (stats.success_count - minSuccessCount) / countRange;
-    if (!stats.last_success_at) {
-        return Math.max(0, Math.min(1, countScore * 0.6 + 0.4));
+function resolveSoftFallbackStatuses(statuses) {
+    const eligible = statuses.filter((item) => item.enabled && item.exists && !item.isFiveHourLimited && !item.isWeeklyLimited);
+    if (eligible.length === 0 || !eligible.every(scheduler_strategy_1.isSoftLocalBlocked)) {
+        return [];
     }
-    const secondsSinceLastUse = (Date.now() - new Date(stats.last_success_at).getTime()) / 1000;
-    const recencyScore = Math.max(0, Math.min(1, secondsSinceLastUse / RECENT_USE_RECOVERY_SECONDS));
-    return Math.max(0, Math.min(1, countScore * 0.6 + recencyScore * 0.4));
+    return eligible;
 }
 /**
- * 计算候选账号的综合调度评分。
+ * 将纯调度决策映射为包含账号配置的调度结果。
  *
  * 业务含义：
- * 1. 周窗口承担主防浪费压力，快重置且余额多的账号优先。
- * 2. 5 小时窗口在周额度健康时参与放大，低周余额会抑制短窗口冲动。
- * 3. 本地成功使用历史用于打散连续请求，降低单账号被持续命中的概率。
- *
- * @param status 账号运行时状态。
- * @param minSuccessCount 当前候选账号中的最小成功次数。
- * @param maxSuccessCount 当前候选账号中的最大成功次数。
- * @returns 综合评分，分数越高越优先。
- */
-function computeScheduleScore(status, minSuccessCount, maxSuccessCount) {
-    const weeklyWasteScore = computeWeeklyWastePressure(status);
-    const fiveHourWasteScore = computeFiveHourWastePressure(status) * computeWeeklyCapacityFactor(status);
-    const weeklyHealthScore = computeWeeklyHealthScore(status);
-    const fiveHourLeftScore = normalizePercent(status.fiveHourLeftPercent);
-    const spreadScore = computeSpreadScore(status, minSuccessCount, maxSuccessCount);
-    return (weeklyWasteScore * 0.5 +
-        fiveHourWasteScore * 0.25 +
-        weeklyHealthScore * 0.1 +
-        spreadScore * 0.1 +
-        fiveHourLeftScore * 0.05);
-}
-/**
- * 对候选账号按防浪费、周额度保护与均匀使用策略排序。
+ * 1. 调度策略只认识运行状态，不直接依赖配置存储。
+ * 2. 应用层在这里补齐账号 HOME、名称等后续代理链路需要的配置字段。
  *
- * @param statuses 待排序的账号状态列表。
- * @returns 排序后的账号状态列表，优先返回更适合尝试的账号。
+ * @param decisions 纯策略返回的调度决策列表。
+ * @param accountMap 账号配置索引；key 为账号 id。
+ * @param fallback 是否来自软熔断兜底调度。
+ * @returns 可供代理或 CLI 使用的账号候选列表。
+ * @throws 无显式抛出。
  */
-function rankEligibleStatuses(statuses) {
-    const primaryPool = statuses.some((item) => item.weeklyLeftPercent === null ||
-        item.weeklyLeftPercent === undefined ||
-        item.weeklyLeftPercent > CRITICAL_WEEKLY_LEFT_PERCENT)
-        ? statuses.filter((item) => item.weeklyLeftPercent === null ||
-            item.weeklyLeftPercent === undefined ||
-            item.weeklyLeftPercent > CRITICAL_WEEKLY_LEFT_PERCENT)
-        : statuses;
-    const deferredPool = statuses.filter((item) => !primaryPool.includes(item));
-    const rankPool = (items) => {
-        const successCounts = items.map((item) => (0, state_1.getSchedulerStats)(item.id).success_count);
-        const minSuccessCount = Math.min(...successCounts, 0);
-        const maxSuccessCount = Math.max(...successCounts, 0);
-        return [...items].sort((left, right) => {
-            const scoreDiff = computeScheduleScore(right, minSuccessCount, maxSuccessCount) -
-                computeScheduleScore(left, minSuccessCount, maxSuccessCount);
-            if (Math.abs(scoreDiff) > Number.EPSILON) {
-                return scoreDiff;
-            }
-            const resetDiff = nextResetWeight(left.fiveHourResetsAt) - nextResetWeight(right.fiveHourResetsAt);
-            if (resetDiff !== 0) {
-                return resetDiff;
-            }
-            return (right.weeklyLeftPercent ?? -1) - (left.weeklyLeftPercent ?? -1);
-        });
-    };
-    return [...rankPool(primaryPool), ...rankPool(deferredPool)];
+function mapDecisionsToPicks(decisions, accountMap, fallback) {
+    return decisions
+        .map((decision) => {
+        const account = accountMap.get(decision.status.id);
+        if (!account) {
+            return null;
+        }
+        const pick = {
+            account,
+            status: decision.status,
+            reason: fallback
+                ? `当前仅剩软熔断账号，兜底尝试；${decision.reason}`
+                : decision.reason,
+            score: decision.score,
+            breakdown: decision.breakdown
+        };
+        return pick;
+    })
+        .filter((item) => item !== null);
 }
 /**
  * 选择当前最适合激活的账号。
  *
  * 业务规则：
- * 1. 仅在账号启用且存在凭据时参与调度。
- * 2. 优先选择当前 5 小时和周窗口都未受限的账号。
- * 3. 在多个可用账号间，优先选择 5 小时剩余额度更高的账号。
+ * 1. 仅在账号启用且存在完整凭据时参与调度。
+ * 2. 优先避免周窗口额度浪费，再在周额度健康时消耗 5 小时窗口余额。
+ * 3. 同等条件下根据本地成功使用统计做均匀分摊。
  *
  * @returns 调度结果；若没有可用账号则返回 `null`。
+ * @throws 当配置、状态或调度统计读取失败时透传底层异常。
  */
 function pickBestAccount() {
     return listCandidateAccounts()[0] ?? null;
@@ -221,31 +108,15 @@ function pickBestAccount() {
  * 返回按优先级排序后的可用账号列表，供代理重试链路使用。
  *
  * @returns 候选账号列表，已按优先级从高到低排序。
+ * @throws 当配置、状态或调度统计读取失败时透传底层异常。
  */
 function listCandidateAccounts() {
-    const config = (0, config_1.loadConfig)();
-    const statuses = (0, status_1.collectAccountStatuses)();
-    const accountMap = new Map(config.accounts.map((item) => [item.id, item]));
-    const eligible = statuses.filter((item) => item.enabled && item.exists && !item.isFiveHourLimited && !item.isWeeklyLimited);
-    const available = rankEligibleStatuses(statuses.filter((item) => item.isAvailable));
-    const ranked = available.length > 0 ? available : [];
-    // 当所有未限额账号都只命中短期本地熔断时，仍允许继续兜底尝试，避免把网络抖动误判成“无可用账号”。
-    if (ranked.length === 0 && eligible.length > 0 && eligible.every(isSoftLocalBlocked)) {
-        ranked.push(...rankEligibleStatuses(eligible));
-    }
-    return ranked
-        .map((winner) => {
-        const account = accountMap.get(winner.id);
-        if (!account) {
-            return null;
-        }
-        return {
-            account,
-            status: winner,
-            reason: winner.isAvailable
-                ? "优先选择 5 小时窗口剩余额度最高且当前可用的账号"
-                : "当前仅剩一个可调度账号，忽略短期本地熔断后继续兜底尝试"
-        };
-    })
-        .filter((item) => item !== null);
+    const context = buildSchedulerContext();
+    const accountMap = new Map(context.accounts.map((item) => [item.id, item]));
+    const availableStatuses = resolveAvailableStatuses(context.statuses);
+    if (availableStatuses.length > 0) {
+        return mapDecisionsToPicks((0, scheduler_strategy_1.rankAccountStatuses)(availableStatuses, context.schedulerStats, context.nowMs), accountMap, false);
+    }
+    const fallbackStatuses = resolveSoftFallbackStatuses(context.statuses);
+    return mapDecisionsToPicks((0, scheduler_strategy_1.rankAccountStatuses)(fallbackStatuses, context.schedulerStats, context.nowMs), accountMap, true);
 }

package/dist/server.js

@@ -5,12 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startServer = startServer;
 const fastify_1 = __importDefault(require("fastify"));
-const undici_1 = require("undici");
-const account_store_1 = require("./account-store");
 const config_1 = require("./config");
+const proxy_retry_service_1 = require("./proxy-retry-service");
 const status_1 = require("./status");
 const scheduler_1 = require("./scheduler");
-const state_1 = require("./state");
 const text_1 = require("./text");
 const usage_sync_1 = require("./usage-sync");
 function getBearerToken(headerValue) {
@@ -20,146 +18,6 @@ function getBearerToken(headerValue) {
     const match = /^Bearer\s+(.+)$/i.exec(headerValue);
     return match?.[1] ?? null;
 }
-/**
- * 根据错误文本与当前账号状态，决定本地禁用时长。
- *
- * 业务规则：
- * 1. 周限制优先，直到周窗口重置时间。
- * 2. 5 小时额度限制次之，直到 5 小时窗口重置时间。
- * 3. 未能明确识别时，按 5 分钟临时熔断处理。
- *
- * @param picked 当前被选中的账号及状态。
- * @param errorText 上游返回的错误文本。
- * @returns 本地禁用窗口与原因。
- */
-function resolveBlockWindow(picked, errorText) {
-    const lowerText = errorText.toLowerCase();
-    if (lowerText.includes("weekly") ||
-        lowerText.includes("7 day") ||
-        lowerText.includes("7-day") ||
-        picked.status.isWeeklyLimited) {
-        return {
-            until: picked.status.weeklyResetsAt ?? Math.floor(Date.now() / 1000) + 7 * 24 * 60 * 60,
-            reason: "weekly_limited"
-        };
-    }
-    if (lowerText.includes("5 hour") ||
-        lowerText.includes("5-hour") ||
-        lowerText.includes("5h") ||
-        lowerText.includes("usage limit") ||
-        picked.status.isFiveHourLimited) {
-        return {
-            until: picked.status.fiveHourResetsAt ?? Math.floor(Date.now() / 1000) + 5 * 60,
-            reason: "5h_limited"
-        };
-    }
-    return {
-        until: Math.floor(Date.now() / 1000) + 5 * 60,
-        reason: "temporary_5m_limit"
-    };
-}
-/**
- * 为当前请求失败的账号设置临时熔断状态，避免短时间内被重复选中。
- *
- * @param accountId 账号标识。
- * @param reason 本地状态中记录的失败原因。
- * @param blockSeconds 熔断持续秒数。
- * @returns 无返回值。
- */
-function markAccountFailure(accountId, reason, blockSeconds) {
-    // 请求链路中的短期失败通常是瞬时异常，记录一个较短的本地熔断窗口即可。
-    (0, state_1.setAccountBlock)(accountId, Math.floor(Date.now() / 1000) + blockSeconds, reason);
-}
-/**
- * 提取错误对象中最接近底层网络层的错误码，便于区分网络不可达与上游业务异常。
- *
- * @param error 捕获到的异常对象。
- * @returns 错误码；若无法识别则返回 `null`。
- */
-function extractErrorCode(error) {
-    if (!error || typeof error !== "object") {
-        return null;
-    }
-    const errnoError = error;
-    if (typeof errnoError.code === "string" && errnoError.code.length > 0) {
-        return errnoError.code;
-    }
-    return extractErrorCode(errnoError.cause);
-}
-/**
- * 判断一次请求失败是否属于本机到上游之间的网络不可达场景。
- *
- * @param error 捕获到的异常对象。
- * @returns `true` 表示网络层异常，不应写入账号熔断；否则返回 `false`。
- */
-function isNetworkUnavailableError(error) {
-    const errorCode = extractErrorCode(error);
-    return [
-        "ECONNREFUSED",
-        "ECONNRESET",
-        "EHOSTUNREACH",
-        "ENETDOWN",
-        "ENETUNREACH",
-        "ENOTFOUND",
-        "EAI_AGAIN",
-        "ETIMEDOUT",
-        "UND_ERR_CONNECT_TIMEOUT",
-        "UND_ERR_SOCKET"
-    ].includes(errorCode ?? "");
-}
-/**
- * 将网络层异常转换为统一的响应体，避免误导成“当前没有可用账号”。
- *
- * @param accountId 当前尝试的账号标识。
- * @param error 捕获到的异常对象。
- * @returns 统一的网络异常响应体。
- */
-function buildNetworkUnavailablePayload(accountId, error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-        error: {
-            message: (0, text_1.bi)(`网络不可用，账号 ${accountId} 无法连接上游: ${message}`, `Network unavailable. Account ${accountId} cannot reach upstream: ${message}`),
-            type: "network_unavailable"
-        }
-    };
-}
-/**
- * 构造发往上游的请求头，并移除仅属于本地代理链路的头信息。
- *
- * @param requestHeaders 客户端发到本地服务的原始请求头。
- * @param accessToken 当前候选账号可用的上游访问令牌。
- * @param accountIdHeader 可选的 ChatGPT 账号标识头。
- * @returns 可直接传给上游请求的请求头对象。
- */
-function buildUpstreamHeaders(requestHeaders, accessToken, bodyLength, accountIdHeader) {
-    const headers = {};
-    for (const [headerName, headerValue] of Object.entries(requestHeaders)) {
-        const normalizedName = headerName.toLowerCase();
-        if (headerValue == null ||
-            normalizedName === "authorization" ||
-            normalizedName === "host" ||
-            normalizedName === "connection" ||
-            normalizedName === "content-length") {
-            continue;
-        }
-        headers[normalizedName] = Array.isArray(headerValue)
-            ? headerValue.join(", ")
-            : headerValue;
-    }
-    // 本地服务使用独立 api_key 鉴权，转发时必须替换为真实上游 access token。
-    headers.authorization = `Bearer ${accessToken}`;
-    // 未显式传入 Accept 时，补上兼容 SSE 与 JSON 的默认值。
-    if (!headers.accept) {
-        headers.accept = "text/event-stream, application/json";
-    }
-    // body 会在本地先读取成 Buffer 以支持失败后切换账号重试，因此这里重算长度。
-    headers["content-length"] = String(bodyLength);
-    headers["user-agent"] = "codex-slot/0.1.1";
-    if (accountIdHeader) {
-        headers["chatgpt-account-id"] = accountIdHeader;
-    }
-    return headers;
-}
 /**
  * 读取代理请求的原始 body 字节，供多账号重试时重复发送同一份载荷。
  *
@@ -199,8 +57,12 @@ async function startServer(port) {
         }
         const bearer = getBearerToken(request.headers.authorization);
         if (bearer !== config.server.api_key) {
-            reply.code(401);
-            throw new Error((0, text_1.bi)("本地 API Key 无效", "Invalid local API key"));
+            return reply.code(401).send({
+                error: {
+                    message: (0, text_1.bi)("本地 API Key 无效", "Invalid local API key"),
+                    type: "invalid_local_api_key"
+                }
+            });
         }
     });
     app.get("/health", async () => {
@@ -218,154 +80,21 @@ async function startServer(port) {
     });
     const proxyHandler = async (requestBodyStream, requestHeaders, reply) => {
         const requestBody = await readRawRequestBody(requestBodyStream);
-        const candidates = (0, scheduler_1.listCandidateAccounts)();
-        if (candidates.length === 0) {
-            reply.code(503);
-            reply.send({
-                error: {
-                    message: (0, text_1.bi)("当前没有可用账号", "No available account"),
-                    type: "no_available_account"
-                }
-            });
-            return;
-        }
-        let lastErrorPayload = {
-            error: {
-                message: (0, text_1.bi)("所有账号都请求失败", "All accounts failed"),
-                type: "all_accounts_failed"
+        const result = await (0, proxy_retry_service_1.proxyResponsesWithRetry)(requestHeaders, requestBody);
+        if (result.type === "send") {
+            reply.code(result.statusCode);
+            for (const [headerName, headerValue] of Object.entries(result.headers ?? {})) {
+                reply.header(headerName, headerValue);
             }
-        };
-        let lastStatusCode = 503;
-        for (const picked of candidates) {
-            const auth = (0, account_store_1.readAuthFile)(picked.account.codex_home);
-            let accessToken = auth?.tokens?.access_token;
-            const accountIdHeader = auth?.tokens?.account_id;
-            if (!accessToken) {
-                // 当前账号认证信息不完整时，先做短时熔断，再切到下一个账号。
-                markAccountFailure(picked.account.id, "invalid_account_auth", 10 * 60);
-                lastErrorPayload = {
-                    error: {
-                        message: (0, text_1.bi)(`账号 ${picked.account.id} 缺少 access_token`, `Account ${picked.account.id} is missing access_token`),
-                        type: "invalid_account_auth"
-                    }
-                };
-                lastStatusCode = 503;
-                continue;
-            }
-            const sendUpstream = async (upstreamAccessToken) => await (0, undici_1.request)(`${config.upstream.codex_base_url}/responses`, {
-                method: "POST",
-                headers: buildUpstreamHeaders(requestHeaders, upstreamAccessToken, requestBody.length, accountIdHeader),
-                body: requestBody
-            });
-            let upstream;
-            try {
-                upstream = await sendUpstream(accessToken);
-            }
-            catch (error) {
-                lastStatusCode = 503;
-                if (isNetworkUnavailableError(error)) {
-                    lastErrorPayload = buildNetworkUnavailablePayload(picked.account.id, error);
-                    continue;
-                }
-                // 非网络层异常仍视为当前账号请求链路异常，短时熔断后继续尝试下一个账号。
-                markAccountFailure(picked.account.id, "request_failed", 60);
-                lastErrorPayload = {
-                    error: {
-                        message: `账号 ${picked.account.id} 请求上游失败: ${error instanceof Error ? error.message : String(error)}`,
-                        type: "account_request_failed"
-                    }
-                };
-                continue;
-            }
-            if (upstream.statusCode === 401) {
-                try {
-                    const refreshed = await (0, usage_sync_1.refreshAccountTokens)(picked.account.id);
-                    accessToken = refreshed.tokens?.access_token ?? accessToken;
-                    upstream = await sendUpstream(accessToken);
-                }
-                catch (error) {
-                    lastStatusCode = 503;
-                    if (isNetworkUnavailableError(error)) {
-                        lastErrorPayload = buildNetworkUnavailablePayload(picked.account.id, error);
-                        continue;
-                    }
-                    // token 刷新失败说明该账号短期内不可用，先熔断再切换。
-                    markAccountFailure(picked.account.id, "token_refresh_failed", 10 * 60);
-                    lastErrorPayload = {
-                        error: {
-                            message: `账号 ${picked.account.id} 刷新 token 失败: ${error instanceof Error ? error.message : String(error)}`,
-                            type: "account_token_refresh_failed"
-                        }
-                    };
-                    continue;
-                }
-            }
-            if (upstream.statusCode === 429 || upstream.statusCode === 403) {
-                const errorText = await upstream.body.text();
-                const block = resolveBlockWindow(picked, errorText);
-                (0, state_1.setAccountBlock)(picked.account.id, block.until, block.reason);
-                lastStatusCode = upstream.statusCode;
-                lastErrorPayload = {
-                    error: {
-                        message: `账号 ${picked.account.id} 受限: ${errorText}`,
-                        type: "account_rate_limited"
-                    }
-                };
-                continue;
-            }
-            if (upstream.statusCode >= 400) {
-                const errorText = await upstream.body.text();
-                const lowerText = errorText.toLowerCase();
-                if (lowerText.includes("usage limit") || lowerText.includes("try again later")) {
-                    const block = resolveBlockWindow(picked, errorText);
-                    (0, state_1.setAccountBlock)(picked.account.id, block.until, block.reason);
-                    lastStatusCode = upstream.statusCode;
-                    lastErrorPayload = {
-                        error: {
-                            message: `账号 ${picked.account.id} 命中额度限制: ${errorText}`,
-                            type: "account_usage_limited"
-                        }
-                    };
-                    continue;
-                }
-                if (upstream.statusCode >= 500) {
-                    // 上游 5xx 先视为当前账号链路失败，短时熔断并切到下一个账号。
-                    markAccountFailure(picked.account.id, "upstream_5xx", 60);
-                    lastStatusCode = upstream.statusCode;
-                    lastErrorPayload = {
-                        error: {
-                            message: `账号 ${picked.account.id} 上游异常: ${errorText}`,
-                            type: "account_upstream_failed"
-                        }
-                    };
-                    continue;
-                }
-                reply.raw.writeHead(upstream.statusCode, {
-                    "content-type": "application/json"
-                });
-                reply.raw.end(errorText);
-                return;
-            }
-            const headers = {};
-            const contentType = upstream.headers["content-type"];
-            const cacheControl = upstream.headers["cache-control"];
-            if (typeof contentType === "string") {
-                headers["content-type"] = contentType;
-            }
-            if (typeof cacheControl === "string") {
-                headers["cache-control"] = cacheControl;
-            }
-            (0, state_1.recordAccountScheduleSuccess)(picked.account.id);
-            headers.connection = "keep-alive";
-            reply.raw.writeHead(upstream.statusCode, headers);
-            for await (const chunk of upstream.body) {
-                reply.raw.write(chunk);
-            }
-            reply.raw.end();
+            reply.send(result.payload);
             return;
         }
-        reply.code(lastStatusCode);
-        reply.send(lastErrorPayload);
+        reply.hijack();
+        reply.raw.writeHead(result.statusCode, result.headers);
+        for await (const chunk of result.body) {
+            reply.raw.write(chunk);
+        }
+        reply.raw.end();
     };
     await app.register(async (proxyApp) => {
         // 代理路由需要原样透传 body，不能在本地先做 JSON 解析与大小限制拦截。