llm-simple-router 1.1.2 → 1.1.4

package/dist/admin/providers.js

@@ -75,6 +75,8 @@ function extractModelOverrides(models) {
         const entry = { name, patches: (m.patches ?? []).map(normalizePatchName) };
         if (m.stream_timeout_ms != null)
             entry.stream_timeout_ms = m.stream_timeout_ms;
+        if (m.non_stream_timeout_ms != null)
+            entry.non_stream_timeout_ms = m.non_stream_timeout_ms;
         if (m.capabilities != null && Array.isArray(m.capabilities))
             entry.capabilities = m.capabilities;
         entries.push(entry);
@@ -124,8 +126,8 @@ const CreateProviderSchema = Type.Object({
     endpoints: Type.Optional(Type.Array(EndpointSchema, { minItems: 1 })),
     models: Type.Optional(Type.Array(Type.Union([
         Type.String(),
-        Type.Object({ name: Type.String(), context_window: Type.Optional(Type.Number()), patches: Type.Optional(Type.Array(Type.String())), stream_timeout_ms: Type.Optional(Type.Number({ minimum: 0, maximum: 86_400_000 })), capabilities: Type.Optional(Type.Array(Type.String())) }),
-        Type.Object({ id: Type.String(), stream_timeout_ms: Type.Optional(Type.Number({ minimum: 0, maximum: 86_400_000 })) })
+        Type.Object({ name: Type.String(), context_window: Type.Optional(Type.Number()), patches: Type.Optional(Type.Array(Type.String())), stream_timeout_ms: Type.Optional(Type.Number({ minimum: 0, maximum: 86_400_000 })), non_stream_timeout_ms: Type.Optional(Type.Number({ minimum: 0, maximum: 86_400_000 })), capabilities: Type.Optional(Type.Array(Type.String())) }),
+        Type.Object({ id: Type.String(), stream_timeout_ms: Type.Optional(Type.Number({ minimum: 0, maximum: 86_400_000 })), non_stream_timeout_ms: Type.Optional(Type.Number({ minimum: 0, maximum: 86_400_000 })) })
     ]))),
     is_active: Type.Optional(Type.Number()),
     max_concurrency: Type.Optional(Type.Integer({ minimum: 0 })),
@@ -146,8 +148,8 @@ const UpdateProviderSchema = Type.Object({
     endpoints: Type.Optional(Type.Array(EndpointSchema, { minItems: 1 })),
     models: Type.Optional(Type.Array(Type.Union([
         Type.String(),
-        Type.Object({ name: Type.String(), context_window: Type.Optional(Type.Number()), patches: Type.Optional(Type.Array(Type.String())), stream_timeout_ms: Type.Optional(Type.Number({ minimum: 0, maximum: 86_400_000 })), capabilities: Type.Optional(Type.Array(Type.String())) }),
-        Type.Object({ id: Type.String(), stream_timeout_ms: Type.Optional(Type.Number({ minimum: 0, maximum: 86_400_000 })) })
+        Type.Object({ name: Type.String(), context_window: Type.Optional(Type.Number()), patches: Type.Optional(Type.Array(Type.String())), stream_timeout_ms: Type.Optional(Type.Number({ minimum: 0, maximum: 86_400_000 })), non_stream_timeout_ms: Type.Optional(Type.Number({ minimum: 0, maximum: 86_400_000 })), capabilities: Type.Optional(Type.Array(Type.String())) }),
+        Type.Object({ id: Type.String(), stream_timeout_ms: Type.Optional(Type.Number({ minimum: 0, maximum: 86_400_000 })), non_stream_timeout_ms: Type.Optional(Type.Number({ minimum: 0, maximum: 86_400_000 })) })
     ]))),
     is_active: Type.Optional(Type.Number()),
     max_concurrency: Type.Optional(Type.Integer({ minimum: 0 })),

package/dist/admin/quick-setup.js

@@ -53,7 +53,8 @@ const QuickSetupProviderSchema = Type.Object({
         name: Type.String(),
         context_window: Type.Optional(Type.Number()),
         patches: Type.Optional(Type.Array(Type.String())),
-        stream_timeout_ms: Type.Optional(Type.Number()),
+        stream_timeout_ms: Type.Optional(Type.Number({ minimum: 0, maximum: 86_400_000 })),
+        non_stream_timeout_ms: Type.Optional(Type.Number({ minimum: 0, maximum: 86_400_000 })),
         capabilities: Type.Optional(Type.Array(Type.String())),
     })),
     endpoints: Type.Optional(Type.Array(QuickSetupEndpointSchema, { minItems: 1 })),
@@ -122,6 +123,7 @@ export const adminQuickSetupRoutes = (app, options, done) => {
                 ...(m.context_window != null ? { context_window: m.context_window } : {}),
                 ...(m.patches && m.patches.length > 0 ? { patches: m.patches } : {}),
                 ...(m.stream_timeout_ms != null ? { stream_timeout_ms: m.stream_timeout_ms } : {}),
+                ...(m.non_stream_timeout_ms != null ? { non_stream_timeout_ms: m.non_stream_timeout_ms } : {}),
                 ...(m.capabilities && m.capabilities.length > 0 ? { capabilities: m.capabilities } : {}),
             }));
             const adaptiveEnabled = body.provider.concurrency_mode === 'auto' ? 1 : 0;

package/dist/app/register-routes.js

@@ -77,6 +77,8 @@ export function registerRoutes(app, opts) {
         dbSizeMonitor.stop();
         tracker.stopPushInterval();
         tracker.closeAllClients();
+        // 先终止所有 inflight 请求（复用 kill 机制同步释放信号量），再清空信号量配置
+        tracker.abortAllInflight();
         semaphoreManager.removeAll();
         proxyAgentFactory.invalidateAll();
         const sessionTracker = container.resolve(SERVICE_KEYS.sessionTracker);

package/dist/config/model-context.d.ts

@@ -3,6 +3,7 @@ export interface ModelInfo {
     context_window: number | null;
     patches: string[];
     stream_timeout_ms?: number;
+    non_stream_timeout_ms?: number;
     capabilities?: string[];
 }
 export interface ModelEntry {
@@ -10,6 +11,7 @@ export interface ModelEntry {
     context_window?: number;
     patches?: string[];
     stream_timeout_ms?: number;
+    non_stream_timeout_ms?: number;
     capabilities?: string[];
 }
 export declare const MODEL_CONTEXT_WINDOWS: Record<string, number>;

package/dist/config/model-context.js

@@ -247,6 +247,8 @@ export function parseModels(raw) {
             };
             if (obj.stream_timeout_ms != null)
                 entry.stream_timeout_ms = obj.stream_timeout_ms;
+            if (obj.non_stream_timeout_ms != null)
+                entry.non_stream_timeout_ms = obj.non_stream_timeout_ms;
             // capabilities: 显式 > model-directory > 硬编码白名单 > 默认 ["text"]
             entry.capabilities = obj.capabilities ?? lookupCapabilities(modelName);
             return entry;
@@ -267,6 +269,8 @@ export function buildModelInfoList(modelEntries, overrides) {
         };
         if (entry.stream_timeout_ms != null)
             info.stream_timeout_ms = entry.stream_timeout_ms;
+        if (entry.non_stream_timeout_ms != null)
+            info.non_stream_timeout_ms = entry.non_stream_timeout_ms;
         if (entry.capabilities != null)
             info.capabilities = entry.capabilities;
         return info;

package/dist/core/concurrency/semaphore.d.ts

@@ -6,19 +6,32 @@ export interface AcquireToken {
     readonly generation: number;
     /** acquire 时 maxConcurrency=0（不计数），release 时跳过递减 */
     readonly bypassed: boolean;
+    /** 幂等标志：release 置 true，重复 release 直接跳过（防 kill 与自然完成双重递减） */
+    released: boolean;
+    /** 关联请求 ID，用于 releaseByReqId 反查及自然完成时清理 reqTokenMap */
+    readonly reqId?: string;
 }
 export declare class SemaphoreManager {
     private readonly entries;
+    /** reqId → {token, providerId} 映射，支持 kill 时按 reqId 同步释放信号量。
+     *  acquire 成功（含 bypassed/排队 resolve）时存入，release 时按 token.reqId 清理。 */
+    private readonly reqTokenMap;
     /** 全局 generation 计数器 — 每次 getOrCreate 分配唯一值，避免 disable+re-enable 后旧 token 匹配新条目 */
     private nextGeneration;
     private getOrCreate;
     updateConfig(providerId: string, config: ConcurrencyConfig): void;
+    /** 构建 token 并按 reqId 存入 reqTokenMap（统一 bypassed/direct/queued 三路径的记录逻辑） */
+    private buildAndRecordToken;
     acquire(providerId: string, signal?: AbortSignal, onQueued?: () => void, logger?: Logger, override?: {
         max_concurrency?: number;
         queue_timeout_ms?: number;
         max_queue_size?: number;
-    }): Promise<AcquireToken>;
-    release(providerId: string, token: AcquireToken, logger?: Logger): void;
+    }, reqId?: string): Promise<AcquireToken>;
+    release(providerId: string, token: AcquireToken | undefined, logger?: Logger): void;
+    /** 按 reqId 同步释放信号量（kill 路径专用）。
+     *  - 已 acquire：取 {token, providerId} 调 release（幂等）
+     *  - 排队中未 acquire（map 无记录）：noop，不抛错、不递减 current */
+    releaseByReqId(reqId: string): void;
     getStatus(providerId: string): {
         active: number;
         queued: number;

package/dist/core/concurrency/semaphore.js

@@ -2,6 +2,9 @@ import { SemaphoreQueueFullError, SemaphoreTimeoutError } from "../errors.js";
 export { SemaphoreQueueFullError, SemaphoreTimeoutError };
 export class SemaphoreManager {
     entries = new Map();
+    /** reqId → {token, providerId} 映射，支持 kill 时按 reqId 同步释放信号量。
+     *  acquire 成功（含 bypassed/排队 resolve）时存入，release 时按 token.reqId 清理。 */
+    reqTokenMap = new Map();
     /** 全局 generation 计数器 — 每次 getOrCreate 分配唯一值，避免 disable+re-enable 后旧 token 匹配新条目 */
     nextGeneration = 0;
     getOrCreate(providerId) {
@@ -53,17 +56,24 @@ export class SemaphoreManager {
             e.resolve();
         }
     }
-    async acquire(providerId, signal, onQueued, logger, override) {
+    /** 构建 token 并按 reqId 存入 reqTokenMap（统一 bypassed/direct/queued 三路径的记录逻辑） */
+    buildAndRecordToken(entry, bypassed, reqId, providerId) {
+        const token = { generation: entry.generation, bypassed, released: false, reqId };
+        if (reqId)
+            this.reqTokenMap.set(reqId, { token, providerId });
+        return token;
+    }
+    async acquire(providerId, signal, onQueued, logger, override, reqId) {
         const entry = this.getOrCreate(providerId);
         const maxConcurrency = override?.max_concurrency ?? entry.config.maxConcurrency;
         const queueTimeoutMs = Math.max(0, override?.queue_timeout_ms ?? entry.config.queueTimeoutMs);
         const maxQueueSize = Math.max(0, override?.max_queue_size ?? entry.config.maxQueueSize);
         if (maxConcurrency === 0)
-            return { generation: entry.generation, bypassed: true };
+            return this.buildAndRecordToken(entry, true, reqId, providerId);
         if (entry.current < maxConcurrency) {
             entry.current++;
             logger?.debug?.({ providerId, current: entry.current, maxConcurrency, action: "acquire_direct" }, "Semaphore: acquired directly");
-            return { generation: entry.generation, bypassed: false };
+            return this.buildAndRecordToken(entry, false, reqId, providerId);
         }
         if (entry.queue.length >= maxQueueSize) {
             logger?.debug?.({ providerId, queueLength: entry.queue.length, maxQueueSize, action: "acquire_rejected" }, "Semaphore: queue full, rejecting");
@@ -72,9 +82,11 @@ export class SemaphoreManager {
         logger?.debug?.({ providerId, current: entry.current, maxConcurrency, queueLength: entry.queue.length, action: "acquire_queued" }, "Semaphore: entering wait queue");
         onQueued?.();
         return new Promise((resolve, reject) => {
-            const token = { generation: entry.generation, bypassed: false };
             const qe = {
                 resolve: () => {
+                    // 关键：在真正获取槽位后才构建并记录 token。
+                    // 若在 executor 创建 token 后立即记录，排队中被 kill 会误减 current。
+                    const token = this.buildAndRecordToken(entry, false, reqId, providerId);
                     logger?.debug?.({ providerId, current: entry.current, maxConcurrency, queueLength: entry.queue.length, action: "acquire_resolved" }, "Semaphore: left wait queue, acquired");
                     resolve(token);
                 },
@@ -107,6 +119,17 @@ export class SemaphoreManager {
         });
     }
     release(providerId, token, logger) {
+        if (!token)
+            return;
+        // 幂等：kill 强制释放与自然完成都走此处，已 released 则跳过（防双重递减）
+        if (token.released) {
+            logger?.debug?.({ providerId, action: "release_idempotent" }, "Semaphore: token already released, skipping");
+            return;
+        }
+        token.released = true;
+        // 清理 reqTokenMap（自然完成自动回收，防 map 无限增长）
+        if (token.reqId)
+            this.reqTokenMap.delete(token.reqId);
         const entry = this.entries.get(providerId);
         if (!entry)
             return;
@@ -130,6 +153,15 @@ export class SemaphoreManager {
             logger?.debug?.({ providerId, current: entry.current, maxConcurrency: entry.config.maxConcurrency, action: "release_decrement" }, "Semaphore: released slot");
         }
     }
+    /** 按 reqId 同步释放信号量（kill 路径专用）。
+     *  - 已 acquire：取 {token, providerId} 调 release（幂等）
+     *  - 排队中未 acquire（map 无记录）：noop，不抛错、不递减 current */
+    releaseByReqId(reqId) {
+        const record = this.reqTokenMap.get(reqId);
+        if (!record)
+            return;
+        this.release(record.providerId, record.token);
+    }
     getStatus(providerId) {
         const entry = this.entries.get(providerId);
         if (!entry)

package/dist/core/constants.d.ts

@@ -14,5 +14,6 @@ export declare function getProxyApiType(url: string): string | null;
 export declare const MS_PER_SECOND = 1000;
 export declare const SECONDS_PER_DAY = 86400;
 export declare const UPSTREAM_SUCCESS = 200;
+export declare const DEFAULT_GET_TIMEOUT_MS = 30000;
 /** 过滤掉不应转发给下游的 hop-by-hop headers */
 export declare function filterHeaders(raw: import("./types.js").RawHeaders): Record<string, string>;

package/dist/core/constants.js

@@ -27,6 +27,9 @@ export const MS_PER_SECOND = 1000;
 export const SECONDS_PER_DAY = 86_400;
 // 上游成功状态码
 export const UPSTREAM_SUCCESS = 200;
+// callGet（admin 探测 /v1/models）默认超时：30s。
+// 仅响应头前超时，与流式 idleTimer 无关。
+export const DEFAULT_GET_TIMEOUT_MS = 30_000;
 /** 过滤掉不应转发给下游的 hop-by-hop headers */
 const SKIP_DOWNSTREAM = new Set([
     "content-length",

package/dist/core/monitor/request-tracker.d.ts

@@ -35,12 +35,16 @@ export declare class RequestTracker {
     readonly runtimeCollector: RuntimeCollector;
     private readonly semaphoreManager?;
     private adaptiveStatusProvider?;
+    /** kill 时同步释放信号量的回调（绑定到 semaphoreManager.releaseByReqId） */
+    private releaseSlotProvider?;
     constructor(deps?: {
         semaphoreManager?: ISemaphoreStatus;
         runtimeCollector?: RuntimeCollector;
         logger?: Logger;
     });
     setAdaptiveStatusProvider(provider: IAdaptiveStatus): void;
+    /** 注入信号量释放回调，kill 时同步释放槽位（防 kill 不释放信号量） */
+    setReleaseSlotProvider(fn: (reqId: string) => void): void;
     start(req: ActiveRequest): void;
     /** 轻量级节流推送：流式内容变更后 500ms 内批量广播 */
     private scheduleStreamContentPush;
@@ -63,6 +67,8 @@ export declare class RequestTracker {
     registerKillCallback(id: string, callback: () => void): void;
     /** 主动终止指定请求。返回 true 表示成功终止，false 表示请求不存在或已完成 */
     killRequest(id: string): boolean;
+    /** 优雅关闭时终止所有 inflight 请求，复用 kill 机制（含信号量释放 + tracker 完成） */
+    abortAllInflight(): void;
     getStats(): StatsSnapshot;
     getConcurrency(): ProviderConcurrencySnapshot[];
     getRuntime(): RuntimeMetrics;

package/dist/core/monitor/request-tracker.js

@@ -27,6 +27,8 @@ export class RequestTracker {
     runtimeCollector;
     semaphoreManager;
     adaptiveStatusProvider;
+    /** kill 时同步释放信号量的回调（绑定到 semaphoreManager.releaseByReqId） */
+    releaseSlotProvider;
     constructor(deps) {
         this.semaphoreManager = deps?.semaphoreManager;
         this.runtimeCollector = deps?.runtimeCollector ?? new RuntimeCollector();
@@ -36,6 +38,10 @@ export class RequestTracker {
     setAdaptiveStatusProvider(provider) {
         this.adaptiveStatusProvider = provider;
     }
+    /** 注入信号量释放回调，kill 时同步释放槽位（防 kill 不释放信号量） */
+    setReleaseSlotProvider(fn) {
+        this.releaseSlotProvider = fn;
+    }
     // --- Core methods ---
     start(req) {
         this.activeMap.set(req.id, { ...req });
@@ -201,12 +207,21 @@ export class RequestTracker {
         this.killCallbacks.delete(id);
         this.logger?.info?.({ reqId: id }, "Tracker: killRequest");
         callback();
+        // 同步释放信号量槽位（releaseByReqId 幂等：未 acquire 的排队请求 noop）
+        this.releaseSlotProvider?.(id);
         // transport 可能尚未 resolve（上游未响应时 StreamProxy 不存在），强制完成请求
         if (this.activeMap.has(id)) {
             this.complete(id, { status: "failed" });
         }
         return true;
     }
+    /** 优雅关闭时终止所有 inflight 请求，复用 kill 机制（含信号量释放 + tracker 完成） */
+    abortAllInflight() {
+        const ids = [...this.killCallbacks.keys()];
+        for (const id of ids) {
+            this.killRequest(id);
+        }
+    }
     // --- Stats / monitoring ---
     getStats() {
         return this.statsAggregator.getStats();

package/dist/core/types.d.ts

@@ -91,7 +91,7 @@ export type TransportResult = {
         providerId: string;
     };
     timeoutMs?: number;
-    abortReason?: "idle_timeout" | "client_disconnect" | "loop_detection";
+    abortReason?: "idle_timeout" | "client_disconnect" | "loop_detection" | "pipe_error";
 } | {
     kind: "error";
     statusCode: number;

package/dist/db/providers.d.ts

@@ -24,9 +24,22 @@ export interface Provider {
     created_at: string;
     updated_at: string;
 }
-/** 默认流式超时 10 分钟 */
-export declare const DEFAULT_STREAM_TIMEOUT_MS = 600000;
-/** 从 provider 的 models JSON 中查找指定模型的超时值 */
+/**
+ * 默认流式超时 5 分钟。
+ * 行为变更：v1.1.x 起从 600s(10min) 降为 300s(5min)，影响未显式配置 stream_timeout_ms 的 provider。
+ * 长跑流式生成（长推理/长输出）若超 5min 会被中断，需在 provider/model 配置中显式调大或设 0(禁用)。
+ */
+export declare const DEFAULT_STREAM_TIMEOUT_MS = 300000;
+/** 默认非流式超时 10 分钟 */
+export declare const DEFAULT_NON_STREAM_TIMEOUT_MS = 600000;
+/** 从 provider 的 models JSON 中查找指定模型的流式/非流式超时值。
+ *  stream: entry.stream_timeout_ms ?? DEFAULT_STREAM_TIMEOUT_MS，0→Infinity
+ *  nonStream: entry.non_stream_timeout_ms ?? DEFAULT_NON_STREAM_TIMEOUT_MS，0→Infinity */
+export declare function getModelTimeouts(provider: Provider, backendModel: string): {
+    stream: number;
+    nonStream: number;
+};
+/** @deprecated 改用 getModelTimeouts。保留为薄包装以兼容现有调用方（iteration-setup 等）。 */
 export declare function getModelStreamTimeout(provider: Provider, backendModel: string): number;
 export declare const PROVIDER_CONCURRENCY_DEFAULTS: {
     readonly max_concurrency: 0;

package/dist/db/providers.js

@@ -1,20 +1,35 @@
 import { randomUUID } from "crypto";
 import { buildUpdateQuery, deleteById } from "./helpers.js";
 import { parseModels } from "../config/model-context.js";
-/** 默认流式超时 10 分钟 */
-export const DEFAULT_STREAM_TIMEOUT_MS = 600_000;
-/** 从 provider 的 models JSON 中查找指定模型的超时值 */
-export function getModelStreamTimeout(provider, backendModel) {
+/**
+ * 默认流式超时 5 分钟。
+ * 行为变更：v1.1.x 起从 600s(10min) 降为 300s(5min)，影响未显式配置 stream_timeout_ms 的 provider。
+ * 长跑流式生成（长推理/长输出）若超 5min 会被中断，需在 provider/model 配置中显式调大或设 0(禁用)。
+ */
+export const DEFAULT_STREAM_TIMEOUT_MS = 300_000;
+/** 默认非流式超时 10 分钟 */
+export const DEFAULT_NON_STREAM_TIMEOUT_MS = 600_000;
+/** 0 表示禁用超时（返回 Infinity）；undefined/null/未设置 使用默认值 */
+function resolveTimeout(value, fallback) {
+    return value === 0 ? Number.POSITIVE_INFINITY : value ?? fallback;
+}
+/** 从 provider 的 models JSON 中查找指定模型的流式/非流式超时值。
+ *  stream: entry.stream_timeout_ms ?? DEFAULT_STREAM_TIMEOUT_MS，0→Infinity
+ *  nonStream: entry.non_stream_timeout_ms ?? DEFAULT_NON_STREAM_TIMEOUT_MS，0→Infinity */
+export function getModelTimeouts(provider, backendModel) {
     const entries = parseModels(provider.models);
     const entry = entries.find(m => m.name === backendModel);
-    if (!entry)
-        return DEFAULT_STREAM_TIMEOUT_MS;
-    const timeout = entry.stream_timeout_ms;
-    // stream_timeout_ms: 0 表示禁用超时，返回 Infinity；
-    // undefined/null/未设置 表示使用默认值
-    if (timeout === 0)
-        return Number.POSITIVE_INFINITY;
-    return timeout ?? DEFAULT_STREAM_TIMEOUT_MS;
+    if (!entry) {
+        return { stream: DEFAULT_STREAM_TIMEOUT_MS, nonStream: DEFAULT_NON_STREAM_TIMEOUT_MS };
+    }
+    return {
+        stream: resolveTimeout(entry.stream_timeout_ms, DEFAULT_STREAM_TIMEOUT_MS),
+        nonStream: resolveTimeout(entry.non_stream_timeout_ms, DEFAULT_NON_STREAM_TIMEOUT_MS),
+    };
+}
+/** @deprecated 改用 getModelTimeouts。保留为薄包装以兼容现有调用方（iteration-setup 等）。 */
+export function getModelStreamTimeout(provider, backendModel) {
+    return getModelTimeouts(provider, backendModel).stream;
 }
 export const PROVIDER_CONCURRENCY_DEFAULTS = {
     max_concurrency: 0,

package/dist/index.js

@@ -69,6 +69,8 @@ export async function buildApp(options) {
     const pluginRegistry = container.resolve(SERVICE_KEYS.pluginRegistry);
     // Wire adaptive controller to tracker
     tracker.setAdaptiveStatusProvider(adaptiveController);
+    // 绑定信号量释放回调：kill 时按 reqId 同步释放槽位（防 kill 不释放信号量）
+    tracker.setReleaseSlotProvider((reqId) => semaphoreManager.releaseByReqId(reqId));
     // 从 DB 读取已有 provider 的并发配置，初始化信号量/adaptive/tracker 缓存
     initializeProviderState(db, semaphoreManager, adaptiveController, tracker);
     // Step 3: 注册 auth + proxy handlers + 构建 StateRegistry

package/dist/proxy/handler/iteration-setup.js

@@ -1,7 +1,8 @@
 import { resolveEndpoint } from "../routing/resolve-endpoint.js";
 import { sanitizeHeadersForLog } from "../proxy-logging.js";
-import { buildUpstreamHeaders, buildUpstreamUrl } from "../proxy-core.js";
-import { getModelStreamTimeout } from "../../db/providers.js";
+import { buildUpstreamHeaders } from "../proxy-core.js";
+import { buildUpstreamUrl } from "../transport/shared.js";
+import { getModelTimeouts } from "../../db/providers.js";
 import { buildTransportFn } from "../transport/transport-fn.js";
 import { parseModels } from "../../config/model-context.js";
 import { applyProviderPatches } from "../patch/index.js";
@@ -87,10 +88,13 @@ export function buildIterationSetup(params) {
     } : undefined;
     // --- Build transport function ---
     const streamLoopEnabled = enhancementConfig.stream_loop_enabled;
+    // 合并 stream/nonStream 超时查询，单次 parseModels（applyProviderPatches 内另有一次解析）
+    const modelTimeouts = getModelTimeouts(provider, resolved.backend_model);
     const transportFn = buildTransportFn({
         provider, apiKey, body: patchedBody, cliHdrs, reply, upstreamPath: effectiveUpstreamPath, apiType: effectiveApiType,
         isStream, startTime, logId, effectiveModel: clientModel,
-        streamTimeoutMs: getModelStreamTimeout(provider, resolved.backend_model),
+        nonStreamTimeoutMs: modelTimeouts.nonStream,
+        streamTimeoutMs: modelTimeouts.stream,
         tracker, matcher, request,
         streamLoopEnabled, formatTransform, responseTransform, injectedHeaders,
         timeoutContext: { modelId: resolved.backend_model, providerId: provider.id },

package/dist/proxy/orchestration/orchestrator.d.ts

@@ -44,7 +44,7 @@ export interface HandleContext {
     failoverThreshold?: number;
     isFailover?: boolean;
     ruleMatcher?: RetryRuleMatcher;
-    transportFn: (target: Target) => Promise<TransportResult>;
+    transportFn: (target: Target, signal?: AbortSignal) => Promise<TransportResult>;
 }
 /**
  * 工厂函数，消除 openai/anthropic 创建 orchestrator 的重复代码。

package/dist/proxy/orchestration/orchestrator.js

@@ -6,6 +6,9 @@ import { SemaphoreTimeoutError, SemaphoreQueueFullError } from "../../core/error
 import { extractThinkingLevel } from "../../db/logs.js";
 const DEFAULT_BASE_DELAY_MS = 1000;
 const DEFAULT_FAILOVER_THRESHOLD = 400;
+// reply.raw close listener 上限：覆盖 MAX_FAILOVER_ITERATIONS(10) + Fastify/socket 自身 listener。
+// failover 循环复用同一 reply 多次挂载 close listener，不提高上限会触发 MaxListenersExceededWarning。
+const REPLY_CLOSE_MAX_LISTENERS = 16;
 /**
  * 从 clientRequest JSON 中提取 thinking level。
  * 委托给 db/logs.ts 的 extractThinkingLevel，保持日志写入和 orchestrator 使用同一逻辑。
@@ -32,11 +35,21 @@ export class ProxyOrchestrator {
     async handle(request, reply, apiType, config, ctx) {
         const providerId = config.provider.id;
         const controller = new AbortController();
-        // 客户端断连时自动 abort（保留原有行为）
-        request.raw.on("close", () => {
-            if (!request.raw.readableEnded) {
+        // 客户端断连检测：监听 reply.raw（响应端），用 writableEnded 判断响应未完成才 abort。
+        // 旧逻辑监听 request.raw + readableEnded，对 POST 请求 readableEnded 恒为 true（body 已读完），
+        // 导致 close 永不 abort。failover 循环复用同一 reply 多次调用 handle()，每次 new 一个独立
+        // AbortController 并挂载新 close listener，故需提高 listener 上限（覆盖 MAX_FAILOVER_ITERATIONS）；
+        // close 只触发一次，listener 随 reply.raw GC 回收，无永久泄漏。
+        // 防御：reply.raw 在测试中可能是简化 mock（非 EventEmitter），typeof 守卫跳过。
+        const rawEmitter = reply.raw;
+        if (typeof rawEmitter.setMaxListeners === "function") {
+            const current = typeof rawEmitter.getMaxListeners === "function" ? rawEmitter.getMaxListeners() : 0;
+            if (current < REPLY_CLOSE_MAX_LISTENERS)
+                rawEmitter.setMaxListeners(REPLY_CLOSE_MAX_LISTENERS);
+        }
+        reply.raw.on("close", () => {
+            if (!reply.raw.writableEnded)
                 controller.abort();
-            }
         });
         const trackerReq = this.buildActiveRequest(request, config, apiType);
         let wasEverQueued = false;
@@ -48,7 +61,9 @@ export class ProxyOrchestrator {
                     try {
                         reply.raw.destroy();
                     }
-                    catch { /* reply may already be destroyed */ } // eslint-disable-line taste/no-silent-catch
+                    catch (e) {
+                        request.log.debug({ err: e }, "reply.raw.destroy failed (already destroyed)");
+                    }
                 });
                 return this.deps.semaphoreScope.withSlot(providerId, controller.signal, () => {
                     trackerReq.queued = true;
@@ -59,8 +74,8 @@ export class ProxyOrchestrator {
                         trackerReq.queued = false;
                         this.deps.trackerScope.markQueued(trackerReq.id, false);
                     }
-                    return this.executeResilience(config, ctx);
-                }, config.concurrencyOverride);
+                    return this.executeResilience(config, ctx, controller.signal);
+                }, config.concurrencyOverride, trackerReq.id);
             }, (result) => this.extractTrackStatus(result), (result) => result.attempts.map(a => ({
                 statusCode: a.statusCode,
                 error: a.error,
@@ -73,7 +88,10 @@ export class ProxyOrchestrator {
             // 如果有重试尝试（非 throw 类型），说明 resilience 层的重试规则匹配了，
             // 意味着这是一个"有意义的失败"——即使上游返回 200 body error 也应该计入退避
             const retryRuleMatched = status === "failed" && result.attempts.length > 1;
-            this.deps.adaptiveController?.onRequestComplete(providerId, { success: status === "completed", statusCode, retryRuleMatched, requestId: config.trackerId, wasQueued: wasEverQueued });
+            // 客户端断连不计入 provider 失败统计，避免误降并发
+            if (!controller.signal.aborted) {
+                this.deps.adaptiveController?.onRequestComplete(providerId, { success: status === "completed", statusCode, retryRuleMatched, requestId: config.trackerId, wasQueued: wasEverQueued });
+            }
             this.sendResponse(reply, result.result, ctx);
             return result;
         }
@@ -81,11 +99,18 @@ export class ProxyOrchestrator {
             if (e instanceof ProviderSwitchNeeded) {
                 const lastResult = e.lastResult;
                 const statusCode = lastResult && "statusCode" in lastResult ? lastResult.statusCode : undefined;
-                this.deps.adaptiveController?.onRequestComplete(providerId, { success: false, statusCode, retryRuleMatched: true, requestId: config.trackerId, wasQueued: wasEverQueued });
+                // 客户端断连不计入 provider 失败统计
+                if (!controller.signal.aborted) {
+                    this.deps.adaptiveController?.onRequestComplete(providerId, { success: false, statusCode, retryRuleMatched: true, requestId: config.trackerId, wasQueued: wasEverQueued });
+                }
             }
             else if (e instanceof SemaphoreTimeoutError || e instanceof SemaphoreQueueFullError) {
                 // 信号量超时或队列满：说明并发压力大，上报给自适应控制器
-                this.deps.adaptiveController?.onRequestComplete(providerId, { success: false, statusCode: 429, requestId: config.trackerId });
+                // 客户端断连触发的 acquire abort 走 AbortError 而非 SemaphoreError；
+                // queueTimeout 与断连竞态时归类为非 provider 失败更合理
+                if (!controller.signal.aborted) {
+                    this.deps.adaptiveController?.onRequestComplete(providerId, { success: false, statusCode: 429, requestId: config.trackerId });
+                }
             }
             throw e;
         }
@@ -111,7 +136,7 @@ export class ProxyOrchestrator {
             mappingReason: config.mappingReason,
         };
     }
-    async executeResilience(config, ctx) {
+    async executeResilience(config, ctx, signal) {
         if (!ctx?.transportFn)
             throw new Error("HandleContext.transportFn is required");
         const resilienceConfig = {
@@ -121,7 +146,7 @@ export class ProxyOrchestrator {
             ruleMatcher: ctx.ruleMatcher,
             providerId: config.provider.id,
         };
-        return this.deps.resilience.execute(() => [config.resolved], ctx.transportFn, resilienceConfig);
+        return this.deps.resilience.execute(() => [config.resolved], ctx.transportFn, resilienceConfig, signal);
     }
     sendResponse(reply, result, ctx) {
         if (result.kind === "stream_success" || result.kind === "stream_abort" || result.kind === "throw") {

package/dist/proxy/orchestration/resilience.d.ts

@@ -56,5 +56,7 @@ export interface ResilienceState {
 }
 export declare class ResilienceLayer {
     decide(result: TransportResult, state: ResilienceState, config: ResilienceConfig): ResilienceDecision;
-    execute(targets: () => Target[], fn: (target: Target) => Promise<TransportResult>, config: ResilienceConfig): Promise<ResilienceResult>;
+    /** 客户端断连短路结果（不重试、不触发 failover/adaptive 退避） */
+    private clientAbortedResult;
+    execute(targets: () => Target[], fn: (target: Target, signal?: AbortSignal) => Promise<TransportResult>, config: ResilienceConfig, signal?: AbortSignal): Promise<ResilienceResult>;
 }

package/dist/proxy/orchestration/resilience.js

@@ -136,7 +136,16 @@ export class ResilienceLayer {
         }
         return { action: "done" };
     }
-    async execute(targets, fn, config) {
+    /** 客户端断连短路结果（不重试、不触发 failover/adaptive 退避） */
+    clientAbortedResult(allAttempts, excludedTargets) {
+        return {
+            result: { kind: "throw", error: new Error("client aborted") },
+            attempts: allAttempts,
+            excludedTargets,
+            finalDecision: { action: "abort", reason: "client_aborted" },
+        };
+    }
+    async execute(targets, fn, config, signal) {
         const allAttempts = [];
         const excludedTargets = [];
         const perTargetCounts = new Map();
@@ -148,6 +157,9 @@ export class ResilienceLayer {
             perTargetCounts.set(targetKey(t), (perTargetCounts.get(targetKey(t)) ?? 0) + 1);
         };
         while (true) {
+            // 客户端断连短路：不重试、不触发 failover
+            if (signal?.aborted)
+                return this.clientAbortedResult(allAttempts, excludedTargets);
             if (globalAttemptIndex >= (config.iterationCap ?? DEFAULT_ITERATION_CAP)) {
                 return {
                     result: lastResult ?? { kind: "error", statusCode: 502, body: "Iteration cap exceeded", headers: {}, sentHeaders: {}, sentBody: "" },
@@ -171,7 +183,7 @@ export class ResilienceLayer {
             const start = Date.now();
             let transportResult;
             try {
-                transportResult = await fn(currentTarget);
+                transportResult = await fn(currentTarget, signal);
             }
             catch (err) {
                 const errMsg = err instanceof Error ? err.message : JSON.stringify(err);
@@ -211,6 +223,9 @@ export class ResilienceLayer {
                 case "retry":
                     globalAttemptIndex++;
                     await sleep(decision.delayMs);
+                    // sleep 期间客户端可能断连，再次检查避免无效重试
+                    if (signal?.aborted)
+                        return this.clientAbortedResult(allAttempts, excludedTargets);
                     continue;
                 case "failover":
                     excludedTargets.push(decision.excludeTarget);

package/dist/proxy/orchestration/scope.d.ts

@@ -5,7 +5,7 @@ import type { ActiveRequest, AttemptSnapshot } from "../../core/monitor/types.js
 export declare class SemaphoreScope {
     private manager;
     constructor(manager: SemaphoreManager);
-    withSlot<T>(providerId: string, signal: AbortSignal, onQueued: () => void, fn: () => Promise<T>, concurrencyOverride?: ConcurrencyOverride): Promise<T>;
+    withSlot<T>(providerId: string, signal: AbortSignal, onQueued: () => void, fn: () => Promise<T>, concurrencyOverride?: ConcurrencyOverride, reqId?: string): Promise<T>;
 }
 export declare class TrackerScope {
     private tracker;

package/dist/proxy/orchestration/scope.js

@@ -3,8 +3,8 @@ export class SemaphoreScope {
     constructor(manager) {
         this.manager = manager;
     }
-    async withSlot(providerId, signal, onQueued, fn, concurrencyOverride) {
-        const token = await this.manager.acquire(providerId, signal, onQueued, undefined, concurrencyOverride);
+    async withSlot(providerId, signal, onQueued, fn, concurrencyOverride, reqId) {
+        const token = await this.manager.acquire(providerId, signal, onQueued, undefined, concurrencyOverride, reqId);
         try {
             return await fn();
         }