llm-simple-router 0.10.13 → 0.11.0

package/dist/proxy/handler/failover-loop.js

@@ -18,7 +18,8 @@ import { getProviderById, updateLogClientStatus, insertRequestLog, updateLogStre
 import { getSetting } from "../../db/settings.js";
 import { decrypt } from "../../utils/crypto.js";
 import { resolveMapping, filterExcluded } from "../routing/mapping-resolver.js";
-import { applyOverflowRedirect } from "../routing/overflow.js";
+import { expandOverflowTargets } from "../routing/overflow.js";
+import { computeModalityRedirectTargets } from "../routing/modality-redirect.js";
 import { getConfig } from "../../config/index.js";
 import { insertRejectedLog } from "../log-helpers.js";
 import { logResilienceResult, collectTransportMetrics, sanitizeHeadersForLog } from "../proxy-logging.js";
@@ -88,7 +89,6 @@ export async function executeFailoverLoop(ctx, errors, deps, upstreamPath, adapt
     const enhancementConfig = loadEnhancementConfig(db);
     const excludeTargets = [];
     let rootLogId = null;
-    let toolErrorsLogged = false;
     let pendingToolErrors = null;
     const flushToolErrors = (providerId, model, reqLogId) => {
         if (!pendingToolErrors)
@@ -112,9 +112,77 @@ export async function executeFailoverLoop(ctx, errors, deps, upstreamPath, adapt
     // BP-H3: 请求级 API Key 缓存，避免同一 provider 重复解密
     const decryptedApiKeys = new Map();
     const encryptionKey = getSetting(db, "encryption_key");
-    // BP-H2: 请求级缓存 — resolveMapping 的 DB 查询结果在 failover 迭代间不变，只 excludeTargets 变化
-    let cachedTargets;
-    let cachedConcurrencyOverride;
+    // === 循环前：路由决策（resolveMapping → IR → OF 分层预计算） ===
+    const precomputeSnapshot = new PipelineSnapshot();
+    // 1. resolveMapping — 只调一次，不传 excludeTargets（exclude 在循环内处理）
+    const resolveResult = resolveMapping(db, clientModel, { now: new Date() });
+    // resolveMapping 返回 null 时，需要用占位 snapshot 做错误日志
+    const rejectSnapshot = new PipelineSnapshot();
+    if (!resolveResult) {
+        const logId = randomUUID();
+        const startTime = Date.now();
+        const isStream = ctx.body.stream === true;
+        const rCtx = {
+            db, logId, apiType: ctx.apiType, model: clientModel,
+            startTime, isStream, routerKeyId: request.routerKey?.id ?? null, originalBody: rawBody, clientHeaders: cliHdrs,
+            isFailover: false, originalRequestId: null,
+            sessionId: ctx.metadata.get("session_id"),
+            pipelineSnapshot: rejectSnapshot.toJSON(),
+            matcher, logFileWriter,
+        };
+        return rejectAndReply(reply, rCtx, errors.modelNotFound(clientModel), `No mapping found for model '${clientModel}'`);
+    }
+    let allTargets = resolveResult.allTargets ?? [resolveResult.target];
+    const concurrencyOverride = resolveResult.concurrency_override;
+    // 2. modality-redirect 层：模态重定向 → 可能 prepend fallback target
+    allTargets = computeModalityRedirectTargets(db, allTargets, clientModel, ctx.body, precomputeSnapshot);
+    // 3. OF 层：为每个 target 预计算 overflow
+    const targetsBeforeOF = allTargets.length;
+    const ofResult = expandOverflowTargets(allTargets, db, ctx.body);
+    allTargets = ofResult.targets;
+    precomputeSnapshot.add({ stage: "overflow", triggered: allTargets.length > targetsBeforeOF });
+    // 4. allowed_models 过滤：MRL fallback 和 overflow 扩展的 target 也必须受约束
+    const allowedModels = request.routerKey?.allowed_models;
+    let overflowIndices = ofResult.overflowIndices;
+    if (allowedModels && allowedModels.length > 0) {
+        // 重建 overflowIndices：filter 会改变 index，需同步更新
+        const newOverflowIndices = new Set();
+        const filtered = [];
+        for (let i = 0; i < allTargets.length; i++) {
+            if (allowedModels.includes(allTargets[i].backend_model)) {
+                if (overflowIndices.has(i))
+                    newOverflowIndices.add(filtered.length);
+                filtered.push(allTargets[i]);
+            }
+        }
+        allTargets = filtered;
+        overflowIndices = newOverflowIndices;
+        if (allTargets.length === 0) {
+            const logId = randomUUID();
+            const startTime = Date.now();
+            const isStream = ctx.body.stream === true;
+            const rCtx = {
+                db, logId, apiType: ctx.apiType, model: clientModel,
+                startTime, isStream, routerKeyId: request.routerKey?.id ?? null, originalBody: rawBody, clientHeaders: cliHdrs,
+                isFailover: false, originalRequestId: null,
+                sessionId: ctx.metadata.get("session_id"),
+                pipelineSnapshot: precomputeSnapshot.toJSON(),
+                matcher, logFileWriter,
+            };
+            return rejectAndReply(reply, rCtx, errors.modelNotAllowed(clientModel), `No allowed model available for '${clientModel}'`);
+        }
+    }
+    // 预计算完成，缓存到循环外
+    const cachedTargets = allTargets;
+    // 工具错误日志提取（循环外一次性执行）
+    if (enhancementConfig.tool_error_logging_enabled) {
+        const failures = extractFailedToolResults(ctx.body);
+        if (failures.length > 0) {
+            request.log.info({ failures: failures.length, sessionId: ctx.metadata.get("session_id") }, "Tool error results detected");
+            pendingToolErrors = failures;
+        }
+    }
+    // === while(true)：纯执行循环 ===
     let failoverIteration = 0;
     while (true) {
         // 请求被 kill 后 reply 已销毁，直接退出避免浪费 failover 迭代
@@ -132,10 +200,9 @@ export async function executeFailoverLoop(ctx, errors, deps, upstreamPath, adapt
         const isFailoverIteration = rootLogId !== logId;
         const routerKeyId = request.routerKey?.id ?? null;
         // 浅拷贝：后续操作只修改顶层属性（model），嵌套对象不被修改
-        // 如果需要修改嵌套属性，在使用点做深拷贝（applyProviderPatches 已有 CoW）
         let currentBody = { ...ctx.body };
         const isStream = currentBody.stream === true;
-        const iterationSnapshot = new PipelineSnapshot();
+        const iterationSnapshot = new PipelineSnapshot(precomputeSnapshot.getStages());
         const rCtx = {
             db, logId, apiType: ctx.apiType, model: clientModel,
             startTime, isStream, routerKeyId, originalBody: rawBody, clientHeaders: cliHdrs,
@@ -144,64 +211,17 @@ export async function executeFailoverLoop(ctx, errors, deps, upstreamPath, adapt
             pipelineSnapshot: iterationSnapshot.toJSON(),
             matcher, logFileWriter,
         };
-        // --- Route ---
-        // BP-H2: 后续迭代使用缓存的 targets，只做 filterExcluded，不查 DB
-        let resolveResult;
-        if (cachedTargets) {
-            const filtered = filterExcluded(cachedTargets, excludeTargets);
-            resolveResult = filtered.length > 0
-                ? { target: filtered[0], concurrency_override: cachedConcurrencyOverride, targetCount: cachedTargets.length, mappingReason: "failover_retry" }
-                : null;
-        }
-        else {
-            resolveResult = resolveMapping(db, clientModel, { now: new Date(), excludeTargets });
-            if (resolveResult?.allTargets) {
-                cachedTargets = resolveResult.allTargets;
-                cachedConcurrencyOverride = resolveResult.concurrency_override;
-            }
-        }
-        request.log.debug({ logId, model: clientModel, apiType: ctx.apiType, isStream, action: "resolve_mapping", resolved: !!resolveResult, cached: !!cachedTargets });
-        if (!resolveResult) {
-            if (excludeTargets.length > 0) {
-                return rejectAndReply(reply, rCtx, errors.upstreamConnectionFailed(), `All failover targets exhausted (${excludeTargets.length} attempted)`);
-            }
-            return rejectAndReply(reply, rCtx, errors.modelNotFound(clientModel), `No mapping found for model '${clientModel}'`);
+        // --- 选第一个非 excluded target ---
+        const filtered = filterExcluded(cachedTargets, excludeTargets);
+        if (filtered.length === 0) {
+            return rejectAndReply(reply, rCtx, errors.upstreamConnectionFailed(), `All failover targets exhausted (${excludeTargets.length} attempted)`);
         }
-        const concurrencyOverride = resolveResult.concurrency_override;
-        let resolved = resolveResult.target;
-        const isFailover = resolveResult.targetCount > 1;
-        // allowed_models 检查 — 仅首次迭代（已由 auth 中间件预解析为数组）
-        if (excludeTargets.length === 0) {
-            const allowedModels = request.routerKey?.allowed_models;
-            if (allowedModels && allowedModels.length > 0 && !allowedModels.includes(resolved.backend_model)) {
-                return rejectAndReply(reply, rCtx, errors.modelNotAllowed(resolved.backend_model), `Model '${resolved.backend_model}' not allowed`, resolved.provider_id);
-            }
-        }
-        let provider = getProviderById(db, resolved.provider_id);
+        const resolved = filtered[0];
+        const isFailover = cachedTargets.length > 1;
+        const provider = getProviderById(db, resolved.provider_id);
         if (!provider || !provider.is_active) {
             return rejectAndReply(reply, rCtx, errors.providerUnavailable(), `Provider '${resolved.provider_id}' unavailable`, resolved.provider_id);
         }
-        // 工具错误日志提取（仅首次迭代）
-        if (enhancementConfig.tool_error_logging_enabled && !toolErrorsLogged) {
-            toolErrorsLogged = true;
-            const failures = extractFailedToolResults(ctx.body);
-            if (failures.length > 0) {
-                request.log.info({ failures: failures.length, sessionId: ctx.metadata.get("session_id") }, "Tool error results detected");
-                pendingToolErrors = failures;
-            }
-        }
-        // --- 溢出重定向 ---
-        let effectiveMappingReason = resolveResult.mappingReason;
-        const overflowResult = applyOverflowRedirect(resolved, db, currentBody);
-        if (overflowResult) {
-            const overflowProvider = getProviderById(db, overflowResult.provider_id);
-            if (overflowProvider && overflowProvider.is_active) {
-                resolved = { ...resolved, provider_id: overflowResult.provider_id, backend_model: overflowResult.backend_model };
-                provider = overflowProvider;
-                currentBody = { ...currentBody, model: overflowResult.backend_model };
-                effectiveMappingReason = "overflow_redirect";
-            }
-        }
         // 当前迭代的工具错误刷新闭包（统一 6 处调用）
         const flushCurrentErrors = () => flushToolErrors(provider.id, resolved.backend_model ?? clientModel, logId);
         // --- 格式转换 + upstreamPath 决策 ---
@@ -210,10 +230,15 @@ export async function executeFailoverLoop(ctx, errors, deps, upstreamPath, adapt
         const effectiveApiType = resolvedPath.effectiveApiType;
         const effectiveUpstreamPath = resolvedPath.effectiveUpstreamPath;
         const needsTransform = resolvedPath.needsTransform;
+        // effectiveMappingReason: 首次迭代用 resolveResult.reason，溢出时覆盖
+        let effectiveMappingReason = isFailoverIteration ? "failover_retry" : resolveResult.mappingReason;
+        // 只有当前 target 是 overflow 扩展产生的才标记
+        const resolvedIdx = cachedTargets.findIndex(t => t.provider_id === resolved.provider_id && t.backend_model === resolved.backend_model);
+        if (overflowIndices.has(resolvedIdx))
+            effectiveMappingReason = "overflow_redirect";
         // --- routing ---
         currentBody = { ...currentBody, model: resolved.backend_model };
-        iterationSnapshot.add({ stage: "routing", client_model: clientModel, backend_model: resolved.backend_model, provider_id: resolved.provider_id, strategy: resolveResult.targetCount > 1 ? "failover" : "scheduled", mapping_reason: effectiveMappingReason });
-        iterationSnapshot.add({ stage: "overflow", triggered: overflowResult != null });
+        iterationSnapshot.add({ stage: "routing", client_model: clientModel, backend_model: resolved.backend_model, provider_id: resolved.provider_id, strategy: cachedTargets.length > 1 ? "failover" : "scheduled", mapping_reason: effectiveMappingReason });
         // --- Plugin 调整 body 和 headers ---
         const pluginResult = applyPluginAdjustments(pluginRegistry, currentBody, clientApiType, provider);
         const injectedHeaders = pluginResult.headers;

package/dist/proxy/pipeline-snapshot.d.ts

@@ -21,11 +21,19 @@ export type StageRecord = {
 } | {
     stage: "provider_patch";
     types: string[];
+} | {
+    stage: "modality-redirect";
+    triggered: boolean;
+    original_model: string;
+    redirect_to: string;
+    redirect_provider: string;
+    reason: string;
+    detected_modalities?: string[];
 };
 import type { MappingReason } from "../core/types.js";
 export declare class PipelineSnapshot {
     private readonly stages;
-    constructor(initial?: StageRecord[]);
+    constructor(initial?: readonly StageRecord[]);
     add(record: StageRecord): void;
     toJSON(): string;
     getStages(): readonly StageRecord[];

package/dist/proxy/proxy-logging.js

@@ -134,7 +134,7 @@ export function collectTransportMetrics(db, apiType, result, isStream, lastSucce
                     metrics.cache_read_tokens_estimated = 1;
                     if (tracker) {
                         try {
-                            tracker.updateCompletedMetrics(lastSuccessLogId, cachedTokens);
+                            tracker.updateCompletedMetrics(lastSuccessLogId, cachedTokens, true);
                         }
                         catch (e) {
                             request.log.error({ err: e }, "tracker update failed");
@@ -149,7 +149,7 @@ export function collectTransportMetrics(db, apiType, result, isStream, lastSucce
                             metrics.cache_read_tokens_estimated = 1;
                             if (tracker) {
                                 try {
-                                    tracker.updateCompletedMetrics(lastSuccessLogId, estimated);
+                                    tracker.updateCompletedMetrics(lastSuccessLogId, estimated, true);
                                 }
                                 catch (e) {
                                     request.log.error({ err: e }, "tracker update failed");

package/dist/proxy/routing/modality-redirect.d.ts

@@ -0,0 +1,22 @@
+/**
+ * MRL（Modality Redirect）预计算层
+ *
+ * 纯函数：检测请求体是否包含多模态内容（图片、音频等），若首 target 不支持
+ * 且配置了 multimodal_fallback，则将 fallback target prepend 到列表头部。
+ */
+import type Database from "better-sqlite3";
+import type { Target } from "../../core/types.js";
+import { PipelineSnapshot } from "../pipeline-snapshot.js";
+/**
+ * 检测请求体包含的多模态类型，支持三种 API 格式：
+ * 1. OpenAI: messages[].content 为数组，检测 type="image_url"|"input_audio"
+ * 2. Anthropic: messages[].content[] 含 type="image"（包括嵌套在 tool_result.content[] 中）
+ * 3. Responses API: input[] 含 type="input_image"|"input_audio"（顶层或嵌套在 message content 中）
+ *
+ * 返回检测到的模态 Set（空 Set 表示无多模态内容）。
+ */
+export declare function detectModalities(body: Record<string, unknown>): Set<string>;
+/**
+ * MRL 层主函数。异常安全：任何内部错误均 catch 并返回原始 targets。
+ */
+export declare function computeModalityRedirectTargets(db: Database.Database, targets: Target[], clientModel: string, body: Record<string, unknown>, snapshot: PipelineSnapshot): Target[];

package/dist/proxy/routing/modality-redirect.js

@@ -0,0 +1,252 @@
+import { getProviderById } from "../../db/providers.js";
+import { getMappingGroup } from "../../db/mappings.js";
+import { parseModels } from "../../config/model-context.js";
+// ---------- detectModalities ----------
+/**
+ * 检测请求体包含的多模态类型，支持三种 API 格式：
+ * 1. OpenAI: messages[].content 为数组，检测 type="image_url"|"input_audio"
+ * 2. Anthropic: messages[].content[] 含 type="image"（包括嵌套在 tool_result.content[] 中）
+ * 3. Responses API: input[] 含 type="input_image"|"input_audio"（顶层或嵌套在 message content 中）
+ *
+ * 返回检测到的模态 Set（空 Set 表示无多模态内容）。
+ */
+export function detectModalities(body) {
+    const modalities = new Set();
+    const messages = body.messages;
+    if (Array.isArray(messages)) {
+        for (const msg of messages) {
+            if (msg == null || typeof msg !== "object")
+                continue;
+            const content = msg.content;
+            if (!Array.isArray(content))
+                continue;
+            for (const block of content) {
+                if (block == null || typeof block !== "object")
+                    continue;
+                const rec = block;
+                const t = rec.type;
+                if (t === "image_url")
+                    modalities.add("image");
+                if (t === "input_audio")
+                    modalities.add("audio");
+                if (t === "image")
+                    modalities.add("image");
+                // Anthropic tool_result 内嵌: type="tool_result" → content[] 可能含 image
+                if (t === "tool_result") {
+                    const inner = rec.content;
+                    if (Array.isArray(inner)) {
+                        for (const ib of inner) {
+                            if (ib == null || typeof ib !== "object")
+                                continue;
+                            if (ib.type === "image")
+                                modalities.add("image");
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Responses API: input[]
+    const input = body.input;
+    if (Array.isArray(input)) {
+        for (const item of input) {
+            if (item == null || typeof item !== "object")
+                continue;
+            const rec = item;
+            if (rec.type === "input_image")
+                modalities.add("image");
+            if (rec.type === "input_audio")
+                modalities.add("audio");
+            // 嵌套在 message 的 content 中
+            const content = rec.content;
+            if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (block == null || typeof block !== "object")
+                        continue;
+                    const bt = block.type;
+                    if (bt === "input_image")
+                        modalities.add("image");
+                    if (bt === "input_audio")
+                        modalities.add("audio");
+                }
+            }
+        }
+    }
+    return modalities;
+}
+// ---------- computeModalityRedirectTargets ----------
+/** 判断模型 capabilities 是否包含指定 modality */
+function supportsModality(capabilities, modality) {
+    return Array.isArray(capabilities) && capabilities.includes(modality);
+}
+/**
+ * MRL 层主函数。异常安全：任何内部错误均 catch 并返回原始 targets。
+ */
+export function computeModalityRedirectTargets(db, targets, clientModel, body, snapshot) {
+    try {
+        // 空列表直接返回
+        if (targets.length === 0)
+            return targets;
+        // 检测多模态内容
+        const modalities = detectModalities(body);
+        // 无多模态内容 → no-op
+        if (modalities.size === 0) {
+            snapshot.add({
+                stage: "modality-redirect",
+                triggered: false,
+                original_model: targets[0].backend_model,
+                redirect_to: "",
+                redirect_provider: "",
+                reason: "no-multimodal-detected",
+            });
+            return targets;
+        }
+        // 检查首 target 的 provider 是否已支持所有检测到的模态
+        const firstTarget = targets[0];
+        const provider = getProviderById(db, firstTarget.provider_id);
+        if (provider) {
+            const entries = parseModels(provider.models);
+            const entry = entries.find(e => e.name === firstTarget.backend_model);
+            const firstTargetCapabilities = entry?.capabilities ?? [];
+            const allSupported = [...modalities].every(m => supportsModality(firstTargetCapabilities, m));
+            if (allSupported) {
+                snapshot.add({
+                    stage: "modality-redirect",
+                    triggered: false,
+                    original_model: firstTarget.backend_model,
+                    redirect_to: "",
+                    redirect_provider: "",
+                    reason: "first-target-supports-all-modalities",
+                });
+                return targets;
+            }
+        }
+        // 查找 multimodal_fallback 配置
+        const group = getMappingGroup(db, clientModel);
+        if (!group) {
+            snapshot.add({
+                stage: "modality-redirect",
+                triggered: false,
+                original_model: firstTarget.backend_model,
+                redirect_to: "",
+                redirect_provider: "",
+                reason: "no-mapping-group",
+            });
+            return targets;
+        }
+        let rule;
+        try {
+            rule = JSON.parse(group.rule);
+        }
+        catch {
+            snapshot.add({
+                stage: "modality-redirect",
+                triggered: false,
+                original_model: firstTarget.backend_model,
+                redirect_to: "",
+                redirect_provider: "",
+                reason: "rule-parse-error",
+            });
+            return targets;
+        }
+        const fallback = rule.multimodal_fallback;
+        if (fallback == null || typeof fallback !== "object") {
+            snapshot.add({
+                stage: "modality-redirect",
+                triggered: false,
+                original_model: firstTarget.backend_model,
+                redirect_to: "",
+                redirect_provider: "",
+                reason: "no-multimodal-fallback-configured",
+            });
+            return targets;
+        }
+        const fb = fallback;
+        const fbProviderId = fb.provider_id;
+        const fbBackendModel = fb.backend_model;
+        if (typeof fbProviderId !== "string" || typeof fbBackendModel !== "string") {
+            snapshot.add({
+                stage: "modality-redirect",
+                triggered: false,
+                original_model: firstTarget.backend_model,
+                redirect_to: "",
+                redirect_provider: "",
+                reason: "invalid-fallback-config",
+            });
+            return targets;
+        }
+        // fallback provider 必须存在且 active
+        const fbProvider = getProviderById(db, fbProviderId);
+        if (!fbProvider || fbProvider.is_active !== 1) {
+            snapshot.add({
+                stage: "modality-redirect",
+                triggered: false,
+                original_model: firstTarget.backend_model,
+                redirect_to: fbBackendModel,
+                redirect_provider: fbProviderId,
+                reason: "fallback-provider-unavailable",
+            });
+            return targets;
+        }
+        // 检查 fallback model 是否覆盖所有首 target 缺失的模态
+        const firstTargetCapabilities = provider
+            ? parseModels(provider.models).find(e => e.name === firstTarget.backend_model)?.capabilities ?? []
+            : [];
+        const missingModalities = [...modalities].filter(m => !supportsModality(firstTargetCapabilities, m));
+        const fbEntry = parseModels(fbProvider.models).find(e => e.name === fbBackendModel);
+        const fbCapabilities = fbEntry?.capabilities ?? [];
+        const fbMissing = missingModalities.filter(m => !supportsModality(fbCapabilities, m));
+        if (fbMissing.length > 0) {
+            snapshot.add({
+                stage: "modality-redirect",
+                triggered: false,
+                original_model: firstTarget.backend_model,
+                redirect_to: fbBackendModel,
+                redirect_provider: fbProviderId,
+                reason: "fallback-missing-modality",
+                detected_modalities: [...modalities],
+            });
+            return targets;
+        }
+        // prepend fallback target（如果与首 target 相同则跳过，避免重复消耗 failover 迭代）
+        if (fbProviderId === firstTarget.provider_id && fbBackendModel === firstTarget.backend_model) {
+            snapshot.add({
+                stage: "modality-redirect",
+                triggered: false,
+                original_model: firstTarget.backend_model,
+                redirect_to: fbBackendModel,
+                redirect_provider: fbProviderId,
+                reason: "fallback-same-as-first-target",
+                detected_modalities: [...modalities],
+            });
+            return targets;
+        }
+        const fbTarget = {
+            provider_id: fbProviderId,
+            backend_model: fbBackendModel,
+        };
+        snapshot.add({
+            stage: "modality-redirect",
+            triggered: true,
+            original_model: firstTarget.backend_model,
+            redirect_to: fbBackendModel,
+            redirect_provider: fbProviderId,
+            reason: "first-target-lacks-modality",
+            detected_modalities: [...modalities],
+        });
+        return [fbTarget, ...targets];
+    }
+    catch (err) {
+        // 异常安全：返回原始 targets，但记录诊断信息
+        console.error('computeModalityRedirectTargets: internal error, falling back to original targets', err);
+        snapshot.add({
+            stage: "modality-redirect",
+            triggered: false,
+            original_model: targets[0]?.backend_model ?? "",
+            redirect_to: "",
+            redirect_provider: "",
+            reason: "internal-error",
+        });
+        return targets;
+    }
+}

package/dist/proxy/routing/overflow.d.ts

@@ -10,9 +10,20 @@ interface OverflowResult {
     provider_id: string;
     backend_model: string;
 }
+export interface OverflowExpansionResult {
+    targets: Target[];
+    /** expanded 中哪些 index 是 overflow 扩展产生的 */
+    overflowIndices: Set<number>;
+}
 /**
  * 检查请求是否超出当前模型的上下文窗口，若超出且配置了溢出目标，则返回重定向信息。
  * 返回 null 表示无需溢出。
  */
+/**
+ * 为 targets 列表中每个配置了溢出的 target 预计算 overflow 重定向目标。
+ * 返回值中溢出目标排在原 target 之前，供 failover 循环直接消费。
+ * 单个 target 的溢出计算失败不影响其他 target。
+ */
+export declare function expandOverflowTargets(targets: Target[], db: Database.Database, body: Record<string, unknown>): OverflowExpansionResult;
 export declare function applyOverflowRedirect(target: Target, db: Database.Database, body: Record<string, unknown>): OverflowResult | null;
 export {};

package/dist/proxy/routing/overflow.js

@@ -101,6 +101,30 @@ function getContextWindow(db, providerId, modelName) {
  * 检查请求是否超出当前模型的上下文窗口，若超出且配置了溢出目标，则返回重定向信息。
  * 返回 null 表示无需溢出。
  */
+/**
+ * 为 targets 列表中每个配置了溢出的 target 预计算 overflow 重定向目标。
+ * 返回值中溢出目标排在原 target 之前，供 failover 循环直接消费。
+ * 单个 target 的溢出计算失败不影响其他 target。
+ */
+export function expandOverflowTargets(targets, db, body) {
+    const expanded = [];
+    const overflowIndices = new Set();
+    for (const target of targets) {
+        try {
+            const result = applyOverflowRedirect(target, db, body);
+            if (result) {
+                overflowIndices.add(expanded.length);
+                expanded.push({ provider_id: result.provider_id, backend_model: result.backend_model });
+            }
+            // eslint-disable-next-line taste/no-silent-catch -- 单target溢出失败不阻塞其余target
+        }
+        catch (err) {
+            console.error('expandOverflowTargets: overflow computation failed for target', target.backend_model, err);
+        }
+        expanded.push(target);
+    }
+    return { targets: expanded, overflowIndices };
+}
 export function applyOverflowRedirect(target, db, body) {
     if (!target.overflow_provider_id || !target.overflow_model)
         return null;

package/dist/proxy/transform/plugin-registry.js

@@ -24,7 +24,7 @@ export class PluginRegistry {
         if (!existsSync(resolvedDir)) {
             return loaded;
         }
-        const files = readdirSync(resolvedDir).filter((f) => f.endsWith(".js") || f.endsWith(".mjs"));
+        const files = readdirSync(resolvedDir).filter((f) => f.endsWith(".js") || f.endsWith(".mjs") || f.endsWith(".cjs"));
         for (const file of files) {
             const filePath = join(resolvedDir, file);
             try {

package/dist/proxy/transform/stream-oa2ant.js

@@ -16,6 +16,9 @@ export class OpenAIToAnthropicTransform extends BaseSSETransform {
     completedToolCallIndices = new Set();
     finishReasonReceived = false;
     processEvent(event) {
+        // OpenAI SSE 标准结束信号 [DONE] 不是 JSON，跳过解析
+        if (event.data === '[DONE]')
+            return;
         let chunk;
         try {
             chunk = JSON.parse(event.data);

package/dist/proxy/transport/http.js

@@ -63,6 +63,9 @@ export function callNonStream(backend, apiKey, body, clientHeaders, upstreamPath
                     });
                 }
             });
+            // 上游响应过程中连接中断时，IncomingMessage 发射 'error' 事件。
+            // 无 listener 会导致 uncaught exception 使进程退出。
+            res.on("error", (error) => resolve({ kind: "throw", error }));
         });
         req.on("error", (error) => resolve({ kind: "throw", error }));
         req.write(payload);
@@ -85,6 +88,9 @@ export function callGet(backend, apiKey, clientHeaders, upstreamPath, buildHeade
                     headers: filterHeaders(res.headers),
                 });
             });
+            // 上游响应过程中连接中断时，IncomingMessage 发射 'error' 事件。
+            // 无 listener 会导致 uncaught exception 使进程退出。
+            res.on("error", (err) => reject(err));
         });
         req.on("error", (err) => reject(err));
         req.end();

package/dist/proxy/transport/proxy-agent.js

@@ -24,9 +24,15 @@ export class ProxyAgentFactory {
             cached.agent.destroy();
             this.cache.delete(provider.id);
         }
-        const agent = this.createAgent(provider.proxy_type, fullUrl);
-        this.cache.set(provider.id, { agent, proxyUrl: fullUrl });
-        return agent;
+        try {
+            const agent = this.createAgent(provider.proxy_type, fullUrl);
+            this.cache.set(provider.id, { agent, proxyUrl: fullUrl });
+            return agent;
+        }
+        catch {
+            // proxy_url 格式无效时返回 undefined，由调用方回退到非代理的 keep-alive agent
+            return undefined;
+        }
     }
     invalidate(providerId) {
         const cached = this.cache.get(providerId);
@@ -64,11 +70,17 @@ export class ProxyAgentFactory {
         const username = provider.proxy_username;
         const password = provider.proxy_password;
         if (username) {
-            const parsed = new URL(url);
-            parsed.username = username;
-            if (password)
-                parsed.password = password;
-            url = parsed.toString();
+            try {
+                const parsed = new URL(url);
+                parsed.username = username;
+                if (password)
+                    parsed.password = password;
+                url = parsed.toString();
+            }
+            catch {
+                // proxy_url 格式无效时返回原始 URL，由上游请求层处理连接错误
+                return url;
+            }
         }
         return url;
     }