llm-simple-router 1.1.2 → 1.1.4

package/dist/proxy/proxy-core.d.ts

@@ -24,17 +24,6 @@ export type { ErrorKind } from "./format/types.js";
  * 由 formatBody 回调根据 kind 参数映射各自的 type/code 并组装 body。
  */
 export declare function createErrorFormatter(formatBody: (kind: ErrorKind, message: string) => Record<string, unknown>): ProxyErrorFormatter;
-/**
- * 拼接上游 URL，自动处理 base_url 已包含部分或完整 API 路径的情况。
- *
- * 兼容场景：
- * - base_url = `https://host/v1`, upstreamPath = `/v1/chat/completions` → `https://host/v1/chat/completions`
- * - base_url = `https://host/v1/chat/completions`, upstreamPath = `/v1/chat/completions` → `https://host/v1/chat/completions`
- * - base_url = `https://host/chat/completions`, upstreamPath = `/v1/chat/completions` → `https://host/chat/completions`
- * - base_url = `https://host/v1/`, upstreamPath = `/v1/chat/completions` → `https://host/v1/chat/completions`
- * - base_url = `https://host/api/paas/v4`, upstreamPath = `/api/paas/v4/chat/completions` → `https://host/api/paas/v4/chat/completions`
- */
-export declare function buildUpstreamUrl(baseUrl: string, upstreamPath: string): string;
 export declare const SKIP_UPSTREAM: Set<string>;
 export declare function selectHeaders(raw: RawHeaders, skip: Set<string>): Record<string, string>;
 export declare function buildUpstreamHeaders(clientHeaders: RawHeaders, apiKey: string, payloadBytes?: number, apiType?: "openai" | "openai-responses" | "anthropic"): Record<string, string>;

package/dist/proxy/proxy-core.js

@@ -44,69 +44,8 @@ export function createErrorFormatter(formatBody) {
         }),
     };
 }
-// ---------- URL utilities ----------
-/**
- * 已知上游 API 路径后缀（不含 /v1 等版本前缀）。
- * 用于检测 base_url 中是否已包含完整路径。
- */
-const KNOWN_API_SUFFIXES = [
-    "/chat/completions",
-    "/messages",
-    "/responses",
-];
-/**
- * 拼接上游 URL，自动处理 base_url 已包含部分或完整 API 路径的情况。
- *
- * 兼容场景：
- * - base_url = `https://host/v1`, upstreamPath = `/v1/chat/completions` → `https://host/v1/chat/completions`
- * - base_url = `https://host/v1/chat/completions`, upstreamPath = `/v1/chat/completions` → `https://host/v1/chat/completions`
- * - base_url = `https://host/chat/completions`, upstreamPath = `/v1/chat/completions` → `https://host/chat/completions`
- * - base_url = `https://host/v1/`, upstreamPath = `/v1/chat/completions` → `https://host/v1/chat/completions`
- * - base_url = `https://host/api/paas/v4`, upstreamPath = `/api/paas/v4/chat/completions` → `https://host/api/paas/v4/chat/completions`
- */
-export function buildUpstreamUrl(baseUrl, upstreamPath) {
-    const normalized = baseUrl.replace(/\/+$/, "");
-    // 1) 完全匹配：base_url 已包含完整 upstreamPath
-    if (normalized.endsWith(upstreamPath))
-        return normalized;
-    // 2) 检测 base_url 是否已包含已知 API 路径后缀
-    //    例如 `https://host/v1/chat/completions` → 已包含，直接返回
-    for (const suffix of KNOWN_API_SUFFIXES) {
-        if (normalized.endsWith(suffix))
-            return normalized;
-    }
-    // 3) 从 upstreamPath 中找到 base_url 的重叠部分，只追加非重叠尾部
-    //    例如 base_url = `https://host/api/paas/v4`, upstreamPath = `/api/paas/v4/chat/completions`
-    //    → 重叠 `/api/paas/v4`，追加 `/chat/completions`
-    //    例如 base_url = `https://host/v1`, upstreamPath = `/v1/chat/completions`
-    //    → 重叠 `/v1`，追加 `/chat/completions`
-    const overlap = findPathOverlap(normalized, upstreamPath);
-    if (overlap.length > 0) {
-        const rest = upstreamPath.slice(overlap.length);
-        return `${normalized}${rest}`;
-    }
-    // 4) 确保拼接处有且仅有一个 /
-    if (!upstreamPath.startsWith("/"))
-        return `${normalized}/${upstreamPath}`;
-    return `${normalized}${upstreamPath}`;
-}
-/**
- * 找出 base_url 末尾与 upstreamPath 开头的最长重叠路径段。
- * 例如 base_url = `https://host/api/v4`, upstreamPath = `/api/v4/chat/completions` → 返回 `/api/v4`
- */
-function findPathOverlap(baseUrl, upstreamPath) {
-    // 将 upstreamPath 按 / 拆分，逐段检查是否与 baseUrl 末尾匹配
-    const segments = upstreamPath.split("/");
-    // segments[0] 是空字符串（因为 upstreamPath 以 / 开头），至少需要 2 段才有意义
-    const MIN_OVERLAP_SEGMENTS = 2;
-    for (let len = segments.length - 1; len >= MIN_OVERLAP_SEGMENTS; len--) {
-        const candidate = segments.slice(0, len).join("/");
-        if (candidate.length > 0 && baseUrl.endsWith(candidate)) {
-            return candidate;
-        }
-    }
-    return "";
-}
+// buildUpstreamUrl / findPathOverlap / KNOWN_API_SUFFIXES 已下沉至 ./transport/shared.ts
+// （打破 proxy-core ↔ transport/http 循环依赖）
 // ---------- Header utilities ----------
 export const SKIP_UPSTREAM = new Set([
     "host",

package/dist/proxy/transport/http.d.ts

@@ -1,21 +1,19 @@
 import type { Agent } from "http";
 import type { RawHeaders, TransportResult } from "../types.js";
+import { type BuildHeadersFn, type TransportCallOpts } from "./shared.js";
 export { callStream } from "./stream.js";
-export interface UpstreamRequestOptions {
-    hostname: string;
-    port: number;
-    path: string;
-    method: string;
-    headers: Record<string, string>;
+export { _transportInternals } from "./shared.js";
+/** callNonStream 选项：timeoutMs=0/Infinity 表示禁用超时。 */
+export interface NonStreamCallOpts extends TransportCallOpts {
+    timeoutMs?: number;
+}
+/** callGet 选项：仅超时（admin 探测，无客户端 signal 关联）。 */
+export interface GetCallOpts {
+    timeoutMs?: number;
 }
-export declare const _transportInternals: {
-    createUpstreamRequest(url: URL, options: UpstreamRequestOptions, agent?: Agent): import("http").ClientRequest;
-};
-export declare function buildRequestOptions(url: URL, headers: Record<string, string>, method?: string): UpstreamRequestOptions;
-export type BuildHeadersFn = (cliHdrs: RawHeaders, key: string, bytes?: number) => Record<string, string>;
 export declare function callNonStream(backend: {
     base_url: string;
-}, apiKey: string, body: Record<string, unknown>, clientHeaders: RawHeaders, upstreamPath: string, buildHeaders: BuildHeadersFn, agent?: Agent): Promise<TransportResult>;
+}, apiKey: string, body: Record<string, unknown>, clientHeaders: RawHeaders, upstreamPath: string, buildHeaders: BuildHeadersFn, agent?: Agent, opts?: NonStreamCallOpts): Promise<TransportResult>;
 export interface GetTransportResult {
     statusCode: number;
     body: string;
@@ -23,4 +21,4 @@ export interface GetTransportResult {
 }
 export declare function callGet(backend: {
     base_url: string;
-}, apiKey: string, clientHeaders: RawHeaders, upstreamPath: string, buildHeaders: (cliHdrs: RawHeaders, key: string) => Record<string, string>, agent?: Agent): Promise<GetTransportResult>;
+}, apiKey: string, clientHeaders: RawHeaders, upstreamPath: string, buildHeaders: (cliHdrs: RawHeaders, key: string) => Record<string, string>, agent?: Agent, opts?: GetCallOpts): Promise<GetTransportResult>;

package/dist/proxy/transport/http.js

@@ -1,40 +1,47 @@
-import { request as httpRequestFn } from "http";
-import { request as httpsRequestFn } from "https";
 import { UPSTREAM_SUCCESS, filterHeaders } from "../types.js";
-import { buildUpstreamUrl } from "../proxy-core.js";
-// Re-export callStream from stream-proxy.ts for external consumers
+import { DEFAULT_GET_TIMEOUT_MS } from "../../core/constants.js";
+import { buildUpstreamUrl, _transportInternals, buildRequestOptions, } from "./shared.js";
+// Re-export callStream from stream.ts for external consumers
 export { callStream } from "./stream.js";
+// 兼容测试 mock：transport.test.ts 经 http 模块命名空间修改 _transportInternals 属性
+export { _transportInternals } from "./shared.js";
 // ---------- Constants ----------
 const UPSTREAM_BAD_GATEWAY = 502;
 const UPSTREAM_SUCCESS_RANGE = 100;
-const HTTPS_DEFAULT_PORT = 443;
-const HTTP_DEFAULT_PORT = 80;
-export const _transportInternals = {
-    createUpstreamRequest(url, options, agent) {
-        const opts = agent ? { ...options, agent } : options;
-        return url.protocol === "https:"
-            ? httpsRequestFn(opts)
-            : httpRequestFn(opts);
-    },
-};
-export function buildRequestOptions(url, headers, method = "POST") {
-    return {
-        hostname: url.hostname,
-        port: Number(url.port) ||
-            (url.protocol === "https:" ? HTTPS_DEFAULT_PORT : HTTP_DEFAULT_PORT),
-        path: url.pathname,
-        method,
-        headers,
-    };
-}
 // ---------- callNonStream ----------
-export function callNonStream(backend, apiKey, body, clientHeaders, upstreamPath, buildHeaders, agent) {
+export function callNonStream(backend, apiKey, body, clientHeaders, upstreamPath, buildHeaders, agent, opts) {
     return new Promise((resolve) => {
         const url = new URL(buildUpstreamUrl(backend.base_url, upstreamPath));
         const payload = JSON.stringify(body);
         const upstreamHeaders = buildHeaders(clientHeaders, apiKey, Buffer.byteLength(payload));
         const options = buildRequestOptions(url, upstreamHeaders);
         const req = _transportInternals.createUpstreamRequest(url, options, agent);
+        // 上游无活动超时：0/Infinity 跳过（与 StreamProxy idleTimer 守卫对称）。
+        // destroy 必须带 error 参数，否则不 emit 'error' 事件，Promise 永挂。
+        const timeoutMs = opts?.timeoutMs;
+        if (timeoutMs !== undefined && Number.isFinite(timeoutMs) && timeoutMs > 0) {
+            req.setTimeout(timeoutMs);
+            req.on("timeout", () => req.destroy(new Error("upstream inactivity timeout")));
+        }
+        // 客户端断连：abort 信号穿透到上游 socket，立即切断连接。
+        // resolveOnce 在 Promise settle 时移除 abort listener，避免重试累积残留
+        // （与 callStream 的 resolveOnce 模式对称）。
+        const clientSignal = opts?.signal;
+        const onClientAbort = clientSignal ? () => req.destroy(new Error("client aborted")) : undefined;
+        const resolveOnce = (r) => {
+            if (onClientAbort && clientSignal && !clientSignal.aborted) {
+                clientSignal.removeEventListener("abort", onClientAbort);
+            }
+            resolve(r);
+        };
+        if (onClientAbort && clientSignal) {
+            if (clientSignal.aborted) {
+                onClientAbort();
+            }
+            else {
+                clientSignal.addEventListener("abort", onClientAbort, { once: true });
+            }
+        }
         req.on("response", (res) => {
             const chunks = [];
             res.on("data", (chunk) => chunks.push(chunk));
@@ -43,7 +50,7 @@ export function callNonStream(backend, apiKey, body, clientHeaders, upstreamPath
                 const responseBody = Buffer.concat(chunks).toString("utf-8");
                 const headers = filterHeaders(res.headers);
                 if (statusCode >= UPSTREAM_SUCCESS && statusCode < UPSTREAM_SUCCESS + UPSTREAM_SUCCESS_RANGE) {
-                    resolve({
+                    resolveOnce({
                         kind: "success",
                         statusCode,
                         body: responseBody,
@@ -53,7 +60,7 @@ export function callNonStream(backend, apiKey, body, clientHeaders, upstreamPath
                     });
                 }
                 else {
-                    resolve({
+                    resolveOnce({
                         kind: "error",
                         statusCode,
                         body: responseBody,
@@ -65,19 +72,22 @@ export function callNonStream(backend, apiKey, body, clientHeaders, upstreamPath
             });
             // 上游响应过程中连接中断时，IncomingMessage 发射 'error' 事件。
             // 无 listener 会导致 uncaught exception 使进程退出。
-            res.on("error", (error) => resolve({ kind: "throw", error }));
+            res.on("error", (error) => resolveOnce({ kind: "throw", error }));
         });
-        req.on("error", (error) => resolve({ kind: "throw", error }));
+        req.on("error", (error) => resolveOnce({ kind: "throw", error }));
         req.write(payload);
         req.end();
     });
 }
-export function callGet(backend, apiKey, clientHeaders, upstreamPath, buildHeaders, agent) {
+export function callGet(backend, apiKey, clientHeaders, upstreamPath, buildHeaders, agent, opts) {
     return new Promise((resolve, reject) => {
         const url = new URL(buildUpstreamUrl(backend.base_url, upstreamPath));
         const headers = buildHeaders(clientHeaders, apiKey);
         const options = buildRequestOptions(url, headers, "GET");
         const req = _transportInternals.createUpstreamRequest(url, options, agent);
+        // GET 探测默认 30s 超时；destroy(error) 触发 'error' 事件 → reject。
+        req.setTimeout(opts?.timeoutMs ?? DEFAULT_GET_TIMEOUT_MS);
+        req.on("timeout", () => req.destroy(new Error("GET timeout")));
         req.on("response", (res) => {
             const chunks = [];
             res.on("data", (chunk) => chunks.push(chunk));

package/dist/proxy/transport/shared.d.ts

@@ -0,0 +1,23 @@
+import type { Agent } from "http";
+import type { RawHeaders } from "../types.js";
+/** 非流式/流式调用通用可选项：客户端断连信号。 */
+export interface TransportCallOpts {
+    signal?: AbortSignal;
+}
+/**
+ * 拼接上游 URL，自动处理 base_url 已包含部分或完整 API 路径的情况。
+ * 兼容：base_url 可带或不带 /v1 前缀、可含完整 endpoint，本函数只追加非重叠尾部。
+ */
+export declare function buildUpstreamUrl(baseUrl: string, upstreamPath: string): string;
+export interface UpstreamRequestOptions {
+    hostname: string;
+    port: number;
+    path: string;
+    method: string;
+    headers: Record<string, string>;
+}
+export declare const _transportInternals: {
+    createUpstreamRequest(url: URL, options: UpstreamRequestOptions, agent?: Agent): import("http").ClientRequest;
+};
+export declare function buildRequestOptions(url: URL, headers: Record<string, string>, method?: string): UpstreamRequestOptions;
+export type BuildHeadersFn = (cliHdrs: RawHeaders, key: string, bytes?: number) => Record<string, string>;

package/dist/proxy/transport/shared.js

@@ -0,0 +1,58 @@
+import { request as httpRequestFn } from "http";
+import { request as httpsRequestFn } from "https";
+// ===== URL building =====
+const KNOWN_API_SUFFIXES = [
+    "/chat/completions",
+    "/messages",
+    "/responses",
+];
+/**
+ * 拼接上游 URL，自动处理 base_url 已包含部分或完整 API 路径的情况。
+ * 兼容：base_url 可带或不带 /v1 前缀、可含完整 endpoint，本函数只追加非重叠尾部。
+ */
+export function buildUpstreamUrl(baseUrl, upstreamPath) {
+    const normalized = baseUrl.replace(/\/+$/, "");
+    if (normalized.endsWith(upstreamPath))
+        return normalized;
+    for (const suffix of KNOWN_API_SUFFIXES) {
+        if (normalized.endsWith(suffix))
+            return normalized;
+    }
+    const overlap = findPathOverlap(normalized, upstreamPath);
+    if (overlap.length > 0) {
+        return `${normalized}${upstreamPath.slice(overlap.length)}`;
+    }
+    if (!upstreamPath.startsWith("/"))
+        return `${normalized}/${upstreamPath}`;
+    return `${normalized}${upstreamPath}`;
+}
+function findPathOverlap(baseUrl, upstreamPath) {
+    const segments = upstreamPath.split("/");
+    const MIN_OVERLAP_SEGMENTS = 2;
+    for (let len = segments.length - 1; len >= MIN_OVERLAP_SEGMENTS; len--) {
+        const candidate = segments.slice(0, len).join("/");
+        if (candidate.length > 0 && baseUrl.endsWith(candidate)) {
+            return candidate;
+        }
+    }
+    return "";
+}
+// ===== Request utilities =====
+const HTTPS_DEFAULT_PORT = 443;
+const HTTP_DEFAULT_PORT = 80;
+export const _transportInternals = {
+    createUpstreamRequest(url, options, agent) {
+        const opts = agent ? { ...options, agent } : options;
+        return url.protocol === "https:" ? httpsRequestFn(opts) : httpRequestFn(opts);
+    },
+};
+export function buildRequestOptions(url, headers, method = "POST") {
+    return {
+        hostname: url.hostname,
+        port: Number(url.port) ||
+            (url.protocol === "https:" ? HTTPS_DEFAULT_PORT : HTTP_DEFAULT_PORT),
+        path: url.pathname,
+        method,
+        headers,
+    };
+}

package/dist/proxy/transport/stream.d.ts

@@ -1,12 +1,65 @@
-import type { Agent } from "http";
+import { Transform } from "stream";
+import type { Agent, ClientRequest, IncomingMessage } from "http";
 import type { FastifyReply } from "fastify";
 import type { RawHeaders, TransportResult } from "../types.js";
 import type { SSEMetricsTransform } from "../../metrics/sse-metrics-transform.js";
 import type { StreamLoopGuard } from "../../core/loop-prevention/index.js";
-import { type BuildHeadersFn } from "./http.js";
+import { type BuildHeadersFn, type TransportCallOpts } from "./shared.js";
+/** callStream 选项：connectTimeoutMs 为响应头前的无活动超时（复用 stream timeout 语义）。 */
+export interface StreamCallOpts extends TransportCallOpts {
+    connectTimeoutMs?: number;
+}
+/**
+ * SSE 流式代理状态机。导出仅为单元测试，非公开 API。
+ * 负责 buffering/streaming 状态转换、idle 超时、上游资源销毁。
+ */
+export declare class StreamProxy {
+    private readonly statusCode;
+    private readonly sentUpstreamHeaders;
+    private readonly reply;
+    private readonly metricsTransform;
+    private readonly checkEarlyError;
+    private readonly timeoutMs;
+    private readonly loopGuard;
+    private readonly timeoutContext?;
+    private readonly onTimeoutAbort?;
+    private readonly upstreamRes?;
+    private readonly upstreamReq?;
+    private state;
+    private resolved;
+    private resolveFn;
+    private pendingResult;
+    private readonly bufferChunks;
+    private totalBuffered;
+    private lastChunkEndedWithNewline;
+    private idleTimer;
+    private headersSent;
+    private closeHandlerRegistered;
+    private readonly sseHeaders;
+    private readonly passThrough;
+    private readonly pipeEntry;
+    private readonly formatTransform;
+    private sseScanBuffer;
+    private static readonly SSE_SCAN_MAX;
+    constructor(statusCode: number, rawUpstreamHeaders: RawHeaders, sentUpstreamHeaders: Record<string, string>, reply: FastifyReply, metricsTransform: SSEMetricsTransform | undefined, checkEarlyError: ((data: string) => boolean) | undefined, timeoutMs: number, loopGuard: StreamLoopGuard | undefined, formatTransform?: Transform, timeoutContext?: {
+        modelId: string;
+        providerId: string;
+    } | undefined, onTimeoutAbort?: ((timeoutMs: number) => void) | undefined, upstreamRes?: IncomingMessage | undefined, upstreamReq?: ClientRequest | undefined);
+    bindResolve(resolve: (result: TransportResult) => void): void;
+    private transition;
+    private terminal;
+    private cleanup;
+    private collectMetrics;
+    resetIdleTimer(): void;
+    startStreaming(): void;
+    registerCloseHandler(): void;
+    onData(chunk: Buffer): void;
+    onEnd(): void;
+    onUpstreamError(err: Error): void;
+}
 export declare function callStream(backend: {
     base_url: string;
 }, apiKey: string, body: Record<string, unknown>, clientHeaders: RawHeaders, reply: FastifyReply, timeoutMs: number, upstreamPath: string, buildHeaders: BuildHeadersFn, metricsTransform?: SSEMetricsTransform, checkEarlyError?: (bufferedData: string) => boolean, compatResolve?: (result: TransportResult) => void, loopGuard?: StreamLoopGuard, formatTransform?: import("stream").Transform, timeoutContext?: {
     modelId: string;
     providerId: string;
-}, onTimeoutAbort?: (timeoutMs: number) => void, agent?: Agent): Promise<TransportResult>;
+}, onTimeoutAbort?: (timeoutMs: number) => void, agent?: Agent, opts?: StreamCallOpts): Promise<TransportResult>;