llm-simple-router 0.1.0 → 0.2.0

package/dist/proxy/response-cleaner.js

@@ -0,0 +1,60 @@
+const RE_ROUTER_RESPONSE = /<router-response[^>]*>[\s\S]*?<\/router-response>/g;
+const RE_COMMAND = /\[router-command:/;
+/**
+ * 清理历史消息中的路由相关内容（命令消息和 router-response 标签）。
+ * 只清理历史轮次，跳过最后一条 user 消息（当前轮由 directive-parser 处理）。
+ */
+export function cleanRouterResponses(body) {
+    const messages = body.messages;
+    if (!messages?.length)
+        return body;
+    const cleaned = JSON.parse(JSON.stringify(body));
+    const cleanedMsgs = cleaned.messages;
+    // 定位最后一条 user 消息（当前轮），不参与整条过滤
+    let lastUserIdx = -1;
+    for (let i = cleanedMsgs.length - 1; i >= 0; i--) {
+        if (cleanedMsgs[i].role === "user") {
+            lastUserIdx = i;
+            break;
+        }
+    }
+    const filtered = cleanedMsgs.filter((msg, idx) => {
+        // 当前轮的 user 消息保留，由 directive-parser 处理
+        if (idx === lastUserIdx)
+            return true;
+        if (msg.role === "user") {
+            const blocks = Array.isArray(msg.content) ? msg.content : [msg.content];
+            for (const b of blocks) {
+                if (b && typeof b === "object" && "text" in b && typeof b.text === "string") {
+                    if (RE_COMMAND.test(b.text))
+                        return false;
+                }
+            }
+        }
+        if (msg.role === "assistant") {
+            const blocks = Array.isArray(msg.content) ? msg.content : [msg.content];
+            const texts = blocks
+                .filter((b) => b?.type === "text" && typeof b.text === "string")
+                .map((b) => b.text);
+            const combined = texts.join("");
+            const stripped = combined.replace(RE_ROUTER_RESPONSE, "").trim();
+            if (!stripped)
+                return false;
+        }
+        return true;
+    });
+    // 剥离所有消息中的 <router-response> 标签（包括当前轮）
+    for (const msg of filtered) {
+        const blocks = Array.isArray(msg.content) ? msg.content : [msg.content];
+        for (const b of blocks) {
+            if (b && typeof b === "object" && "text" in b && typeof b.text === "string") {
+                b.text = b.text
+                    .replace(RE_ROUTER_RESPONSE, "")
+                    .replace(/\n{3,}/g, "\n\n")
+                    .trim();
+            }
+        }
+    }
+    cleaned.messages = filtered;
+    return cleaned;
+}

package/dist/proxy/strategy/failover.d.ts

@@ -1,4 +1,4 @@
 import type { MappingStrategy, ResolveContext, Target } from "./types.js";
 export declare class FailoverStrategy implements MappingStrategy {
-    select(_rule: unknown, _context: ResolveContext): Target | undefined;
+    select(rule: unknown, context: ResolveContext): Target | undefined;
 }

package/dist/proxy/strategy/failover.js

@@ -1,5 +1,13 @@
+import { isTargetsRule } from "./targets-rule.js";
 export class FailoverStrategy {
-    select(_rule, _context) {
-        throw new Error("Not implemented");
+    select(rule, context) {
+        if (!isTargetsRule(rule))
+            return undefined;
+        for (const t of rule.targets) {
+            const excluded = context.excludeTargets?.some((e) => e.backend_model === t.backend_model && e.provider_id === t.provider_id);
+            if (!excluded)
+                return t;
+        }
+        return undefined;
     }
 }

package/dist/proxy/strategy/random.d.ts

@@ -1,4 +1,4 @@
 import type { MappingStrategy, ResolveContext, Target } from "./types.js";
 export declare class RandomStrategy implements MappingStrategy {
-    select(_rule: unknown, _context: ResolveContext): Target | undefined;
+    select(rule: unknown, context: ResolveContext): Target | undefined;
 }

package/dist/proxy/strategy/random.js

@@ -1,5 +1,11 @@
+import { isTargetsRule } from "./targets-rule.js";
 export class RandomStrategy {
-    select(_rule, _context) {
-        throw new Error("Not implemented");
+    select(rule, context) {
+        if (!isTargetsRule(rule))
+            return undefined;
+        const filtered = rule.targets.filter((t) => !context.excludeTargets?.some((e) => e.backend_model === t.backend_model && e.provider_id === t.provider_id));
+        if (filtered.length === 0)
+            return undefined;
+        return filtered[Math.floor(Math.random() * filtered.length)];
     }
 }

package/dist/proxy/strategy/round-robin.d.ts

@@ -1,4 +1,5 @@
 import type { MappingStrategy, ResolveContext, Target } from "./types.js";
 export declare class RoundRobinStrategy implements MappingStrategy {
-    select(_rule: unknown, _context: ResolveContext): Target | undefined;
+    private indexMap;
+    select(rule: unknown, context: ResolveContext, clientModel?: string): Target | undefined;
 }

package/dist/proxy/strategy/round-robin.js

@@ -1,5 +1,16 @@
+import { isTargetsRule } from "./targets-rule.js";
 export class RoundRobinStrategy {
-    select(_rule, _context) {
-        throw new Error("Not implemented");
+    indexMap = new Map();
+    select(rule, context, clientModel) {
+        if (!isTargetsRule(rule))
+            return undefined;
+        const key = clientModel ?? JSON.stringify(rule);
+        const filtered = rule.targets.filter((t) => !context.excludeTargets?.some((e) => e.backend_model === t.backend_model && e.provider_id === t.provider_id));
+        if (filtered.length === 0)
+            return undefined;
+        const lastIndex = this.indexMap.get(key) ?? -1;
+        const nextIndex = (lastIndex + 1) % filtered.length;
+        this.indexMap.set(key, nextIndex);
+        return filtered[nextIndex];
     }
 }

package/dist/proxy/strategy/targets-rule.d.ts

@@ -0,0 +1,7 @@
+import type { Target } from "./types.js";
+interface TargetsRule {
+    targets: Target[];
+}
+export declare function isTarget(value: unknown): value is Target;
+export declare function isTargetsRule(value: unknown): value is TargetsRule;
+export {};

package/dist/proxy/strategy/targets-rule.js

@@ -0,0 +1,14 @@
+export function isTarget(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "backend_model" in value &&
+        typeof value.backend_model === "string" &&
+        "provider_id" in value &&
+        typeof value.provider_id === "string");
+}
+export function isTargetsRule(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const r = value;
+    return Array.isArray(r.targets) && r.targets.every(isTarget);
+}

package/dist/proxy/strategy/types.d.ts

@@ -1,5 +1,8 @@
 export declare const STRATEGY_NAMES: {
     readonly SCHEDULED: "scheduled";
+    readonly ROUND_ROBIN: "round-robin";
+    readonly RANDOM: "random";
+    readonly FAILOVER: "failover";
 };
 export interface Target {
     backend_model: string;
@@ -7,7 +10,8 @@ export interface Target {
 }
 export interface ResolveContext {
     now: Date;
+    excludeTargets?: Target[];
 }
 export interface MappingStrategy {
-    select(rule: unknown, context: ResolveContext): Target | undefined;
+    select(rule: unknown, context: ResolveContext, clientModel?: string): Target | undefined;
 }

package/dist/proxy/strategy/types.js

@@ -1,3 +1,6 @@
 export const STRATEGY_NAMES = {
     SCHEDULED: "scheduled",
+    ROUND_ROBIN: "round-robin",
+    RANDOM: "random",
+    FAILOVER: "failover",
 };

package/dist/proxy/upstream-call.d.ts

@@ -0,0 +1,43 @@
+import type { FastifyReply } from "fastify";
+import type { RawHeaders } from "./proxy-core.js";
+import type { MetricsResult } from "../metrics/metrics-extractor.js";
+import { SSEMetricsTransform } from "../metrics/sse-metrics-transform.js";
+export interface UpstreamRequestOptions {
+    hostname: string;
+    port: number;
+    path: string;
+    method: string;
+    headers: Record<string, string>;
+}
+export interface ProxyResult {
+    statusCode: number;
+    body: string;
+    headers: Record<string, string>;
+    sentHeaders: Record<string, string>;
+    sentBody: string;
+}
+export interface StreamProxyResult {
+    statusCode: number;
+    responseBody?: string;
+    upstreamResponseHeaders?: Record<string, string>;
+    sentHeaders?: Record<string, string>;
+    metricsResult?: MetricsResult;
+}
+export interface GetProxyResult {
+    statusCode: number;
+    body: string;
+    headers: Record<string, string>;
+}
+/** 根据 URL scheme 选择 http 或 https 模块 */
+export declare function createUpstreamRequest(url: URL, options: UpstreamRequestOptions): import("http").ClientRequest;
+/** 从 URL + headers 构造 Node.js http.request 所需的 options */
+export declare function buildRequestOptions(url: URL, headers: Record<string, string>, method?: string): UpstreamRequestOptions;
+export declare function proxyNonStream(backend: {
+    base_url: string;
+}, apiKey: string, body: Record<string, unknown>, clientHeaders: RawHeaders, upstreamPath: string, buildHeaders: (cliHdrs: RawHeaders, key: string, bytes?: number) => Record<string, string>): Promise<ProxyResult>;
+export declare function proxyStream(backend: {
+    base_url: string;
+}, apiKey: string, body: Record<string, unknown>, clientHeaders: RawHeaders, reply: FastifyReply, timeoutMs: number, upstreamPath: string, buildHeaders: (cliHdrs: RawHeaders, key: string, bytes?: number) => Record<string, string>, metricsTransform?: SSEMetricsTransform): Promise<StreamProxyResult>;
+export declare function proxyGetRequest(backend: {
+    base_url: string;
+}, apiKey: string, clientHeaders: RawHeaders, upstreamPath: string, buildHeaders: (cliHdrs: RawHeaders, key: string) => Record<string, string>): Promise<GetProxyResult>;

package/dist/proxy/upstream-call.js

@@ -0,0 +1,208 @@
+import { request as httpRequestFn } from "http";
+import { request as httpsRequestFn } from "https";
+import { PassThrough } from "stream";
+// ---------- Constants ----------
+const UPSTREAM_SUCCESS = 200;
+const UPSTREAM_BAD_GATEWAY = 502;
+const HTTPS_DEFAULT_PORT = 443;
+const HTTP_DEFAULT_PORT = 80;
+// ---------- Request utilities ----------
+/** 根据 URL scheme 选择 http 或 https 模块 */
+export function createUpstreamRequest(url, options) {
+    return url.protocol === "https:" ? httpsRequestFn(options) : httpRequestFn(options);
+}
+/** 从 URL + headers 构造 Node.js http.request 所需的 options */
+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,
+    };
+}
+// ---------- Non-stream proxy ----------
+export function proxyNonStream(backend, apiKey, body, clientHeaders, upstreamPath, buildHeaders) {
+    return new Promise((resolve, reject) => {
+        const url = new URL(`${backend.base_url}${upstreamPath}`);
+        const payload = JSON.stringify(body);
+        const upstreamHeaders = buildHeaders(clientHeaders, apiKey, Buffer.byteLength(payload));
+        const options = buildRequestOptions(url, upstreamHeaders);
+        const req = createUpstreamRequest(url, options);
+        req.on("response", (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => {
+                resolve({
+                    statusCode: res.statusCode || UPSTREAM_BAD_GATEWAY,
+                    body: Buffer.concat(chunks).toString("utf-8"),
+                    headers: filterHeaders(res.headers),
+                    sentHeaders: { ...upstreamHeaders },
+                    sentBody: payload,
+                });
+            });
+        });
+        req.on("error", (err) => reject(err));
+        req.write(payload);
+        req.end();
+    });
+}
+// ---------- Stream proxy (SSE) ----------
+export function proxyStream(backend, apiKey, body, clientHeaders, reply, timeoutMs, upstreamPath, buildHeaders, metricsTransform) {
+    return new Promise((resolve, reject) => {
+        const url = new URL(`${backend.base_url}${upstreamPath}`);
+        const payload = JSON.stringify(body);
+        const upstreamHeaders = buildHeaders(clientHeaders, apiKey, Buffer.byteLength(payload));
+        const options = buildRequestOptions(url, upstreamHeaders);
+        const upstreamReq = createUpstreamRequest(url, options);
+        upstreamReq.on("response", (upstreamRes) => {
+            const statusCode = upstreamRes.statusCode || UPSTREAM_BAD_GATEWAY;
+            if (statusCode !== UPSTREAM_SUCCESS) {
+                const chunks = [];
+                upstreamRes.on("data", (chunk) => chunks.push(chunk));
+                upstreamRes.on("end", () => {
+                    const errorBody = Buffer.concat(chunks).toString("utf-8");
+                    resolve({
+                        statusCode,
+                        responseBody: errorBody,
+                        upstreamResponseHeaders: filterHeaders(upstreamRes.headers),
+                        sentHeaders: upstreamHeaders,
+                    });
+                });
+                return;
+            }
+            const sseHeaders = filterHeaders(upstreamRes.headers);
+            sseHeaders["Content-Type"] = "text/event-stream";
+            sseHeaders["Cache-Control"] = "no-cache";
+            sseHeaders["Connection"] = "keep-alive";
+            reply.raw.writeHead(statusCode, sseHeaders);
+            const passThrough = new PassThrough();
+            if (metricsTransform) {
+                metricsTransform.pipe(passThrough).pipe(reply.raw);
+            }
+            else {
+                passThrough.pipe(reply.raw);
+            }
+            const pipeEntry = metricsTransform ?? passThrough;
+            const captureChunks = [];
+            let idleTimer = null;
+            let resolved = false;
+            function cleanup() {
+                if (idleTimer)
+                    clearTimeout(idleTimer);
+                idleTimer = null;
+                if (!passThrough.destroyed)
+                    passThrough.destroy();
+                if (metricsTransform && !metricsTransform.destroyed)
+                    metricsTransform.destroy();
+                if (!upstreamRes.destroyed)
+                    upstreamRes.destroy();
+            }
+            function collectMetrics(isComplete) {
+                if (!metricsTransform)
+                    return undefined;
+                const result = metricsTransform.getExtractor().getMetrics();
+                if (!isComplete) {
+                    return { ...result, is_complete: 0 };
+                }
+                return result;
+            }
+            reply.raw.on("close", () => {
+                if (!resolved) {
+                    cleanup();
+                    resolve({ statusCode, responseBody: undefined, upstreamResponseHeaders: sseHeaders, sentHeaders: upstreamHeaders, metricsResult: collectMetrics(false) });
+                }
+            });
+            passThrough.on("error", () => {
+                cleanup();
+                if (!resolved) {
+                    resolved = true;
+                    resolve({ statusCode, responseBody: undefined, upstreamResponseHeaders: sseHeaders, sentHeaders: upstreamHeaders, metricsResult: collectMetrics(false) });
+                }
+            });
+            function resetIdleTimer() {
+                if (idleTimer)
+                    clearTimeout(idleTimer);
+                idleTimer = setTimeout(() => {
+                    cleanup();
+                    if (!resolved) {
+                        resolved = true;
+                        resolve({ statusCode, responseBody: undefined, upstreamResponseHeaders: sseHeaders, sentHeaders: upstreamHeaders, metricsResult: collectMetrics(false) });
+                    }
+                }, timeoutMs);
+            }
+            resetIdleTimer();
+            upstreamRes.on("data", (chunk) => {
+                if (resolved)
+                    return;
+                resetIdleTimer();
+                pipeEntry.write(chunk);
+                captureChunks.push(chunk);
+            });
+            upstreamRes.on("end", () => {
+                if (resolved)
+                    return;
+                resolved = true;
+                if (idleTimer)
+                    clearTimeout(idleTimer);
+                pipeEntry.end();
+                reply.raw.end();
+                resolve({
+                    statusCode,
+                    responseBody: Buffer.concat(captureChunks).toString("utf-8"),
+                    upstreamResponseHeaders: sseHeaders,
+                    sentHeaders: upstreamHeaders,
+                    metricsResult: collectMetrics(true),
+                });
+            });
+            upstreamRes.on("error", (err) => {
+                if (resolved)
+                    return;
+                resolved = true;
+                cleanup();
+                reject(err);
+            });
+        });
+        upstreamReq.on("error", (err) => reject(err));
+        upstreamReq.write(payload);
+        upstreamReq.end();
+    });
+}
+// ---------- GET proxy ----------
+export function proxyGetRequest(backend, apiKey, clientHeaders, upstreamPath, buildHeaders) {
+    return new Promise((resolve, reject) => {
+        const url = new URL(`${backend.base_url}${upstreamPath}`);
+        const headers = buildHeaders(clientHeaders, apiKey);
+        const options = buildRequestOptions(url, headers, "GET");
+        const req = createUpstreamRequest(url, options);
+        req.on("response", (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => {
+                resolve({
+                    statusCode: res.statusCode || UPSTREAM_BAD_GATEWAY,
+                    body: Buffer.concat(chunks).toString("utf-8"),
+                    headers: filterHeaders(res.headers),
+                });
+            });
+        });
+        req.on("error", (err) => reject(err));
+        req.end();
+    });
+}
+// ---------- Shared header filter ----------
+const SKIP_DOWNSTREAM = new Set([
+    "content-length",
+    "transfer-encoding",
+    "connection",
+    "keep-alive",
+]);
+function filterHeaders(raw) {
+    const out = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (value == null || SKIP_DOWNSTREAM.has(key.toLowerCase()))
+            continue;
+        out[key] = Array.isArray(value) ? value.join(", ") : value;
+    }
+    return out;
+}

package/dist/utils/password.d.ts

@@ -0,0 +1,2 @@
+export declare function hashPassword(password: string): string;
+export declare function verifyPassword(password: string, stored: string): boolean;

package/dist/utils/password.js

@@ -0,0 +1,14 @@
+import { randomBytes, scryptSync } from "node:crypto";
+const SCRYPT_KEYLEN = 64;
+export function hashPassword(password) {
+    const salt = randomBytes(16).toString("hex");
+    const hash = scryptSync(password, salt, SCRYPT_KEYLEN).toString("hex");
+    return `${salt}:${hash}`;
+}
+export function verifyPassword(password, stored) {
+    const [salt, hash] = stored.split(":");
+    if (!salt || !hash)
+        return false;
+    const derived = scryptSync(password, salt, SCRYPT_KEYLEN).toString("hex");
+    return derived === hash;
+}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "llm-simple-router",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "LLM API proxy router with OpenAI/Anthropic support, model mapping, retry strategies, and admin dashboard",
   "license": "MIT",
-  "author": "ZzzzSsssWwww",
+  "author": "ZZzzswszzZZ",
   "type": "module",
   "repository": {
     "type": "git",
@@ -25,7 +25,7 @@
     "node": ">=20.0.0"
   },
   "bin": {
-    "llm-simple-router": "./dist/index.js"
+    "llm-simple-router": "./dist/cli.js"
   },
   "files": [
     "dist/",
@@ -34,7 +34,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "dev": "tsx watch src/index.ts",
+    "dev": "PORT=9980 tsx watch src/index.ts",
     "build": "tsc",
     "build:full": "tsc && node scripts/build.mjs",
     "prepublishOnly": "node scripts/build.mjs",
@@ -55,7 +55,8 @@
     "fastify": "^5.3.3",
     "fastify-plugin": "^5.1.0",
     "jsonwebtoken": "^9.0.3",
-    "pino": "^9.6.0"
+    "pino": "^9.6.0",
+    "pino-pretty": "^13.1.3"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",

package/.env.example

@@ -1,13 +0,0 @@
-# 必需配置
-ADMIN_PASSWORD=admin123
-ENCRYPTION_KEY=0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef
-JWT_SECRET=0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef
-
-# 可选配置
-PORT=3000
-DB_PATH=./data/router.db
-LOG_LEVEL=info
-TZ=Asia/Shanghai
-STREAM_TIMEOUT_MS=3000000
-RETRY_MAX_ATTEMPTS=3
-RETRY_BASE_DELAY_MS=1000