llm-simple-router 0.5.0 → 0.5.2

package/dist/index.js

@@ -5,19 +5,10 @@ import { existsSync } from "node:fs";
 import { randomUUID } from "crypto";
 import Fastify from "fastify";
 import { insertRequestLog } from "./db/logs.js";
-import { HTTP_NOT_FOUND, HTTP_INTERNAL_ERROR, HTTP_BAD_REQUEST } from "./constants.js";
+import { HTTP_NOT_FOUND, HTTP_INTERNAL_ERROR, getProxyApiType } from "./constants.js";
+import { API_CODE, apiError, isAdminApiResponse, statusToApiCode } from "./admin/api-response.js";
 const PROVIDER_DEFAULT_QUEUE_TIMEOUT_MS = 5000;
 const PROVIDER_DEFAULT_MAX_QUEUE_SIZE = 100;
-// 代理路由路径 → api_type，用于在全局 hook/errorHandler 中识别代理请求
-const PROXY_API_TYPES = {
-    "/v1/chat/completions": "openai",
-    "/v1/messages": "anthropic",
-    "/v1/models": "openai",
-};
-function getProxyApiType(url) {
-    const path = url.split("?")[0];
-    return PROXY_API_TYPES[path] ?? null;
-}
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 import { getConfig } from "./config.js";
@@ -34,6 +25,7 @@ import { modelState } from "./proxy/model-state.js";
 import { UsageWindowTracker } from "./proxy/usage-window-tracker.js";
 import { scheduleLogCleanup } from "./db/log-cleaner.js";
 import { scheduleDbSizeMonitor } from "./db/db-size-monitor.js";
+import { startUpgradeChecker, stopUpgradeChecker } from "./admin/upgrade.js";
 import fastifyStatic from "@fastify/static";
 export async function buildApp(options) {
     const config = options?.config ?? getBaseConfig();
@@ -79,34 +71,62 @@ export async function buildApp(options) {
             .join("; ");
         return new Error(message);
     });
-    // 统一 schema validation 错误响应格式，代理路由的错误也记录到 request_logs
+    // 统一错误处理：代理路由保持 {error:{message}}，Admin API 使用信封格式
     app.setErrorHandler((error, request, reply) => {
         const fastifyError = error;
         const status = fastifyError.statusCode ?? HTTP_INTERNAL_ERROR;
-        const proxyApiType = getProxyApiType(request.url);
-        if (proxyApiType) {
-            request.log.error({ statusCode: status, err: error }, `Proxy request error: ${fastifyError.message}`);
-            const body = request.body;
-            insertRequestLog(db, {
-                id: randomUUID(),
-                api_type: proxyApiType,
-                model: body?.model || null,
-                provider_id: null,
-                status_code: status,
-                latency_ms: 0,
-                is_stream: 0,
-                error_message: fastifyError.message,
-                created_at: new Date().toISOString(),
-                client_request: JSON.stringify({ headers: request.headers }),
-                router_key_id: request.routerKey?.id ?? null,
-            });
+        // 代理路由保持原有格式，并记录到 request_logs
+        if (!isAdminApiResponse(request.url)) {
+            const proxyApiType = getProxyApiType(request.url);
+            if (proxyApiType) {
+                request.log.error({ statusCode: status, err: error }, `Proxy request error: ${fastifyError.message}`);
+                const body = request.body;
+                insertRequestLog(db, {
+                    id: randomUUID(),
+                    api_type: proxyApiType,
+                    model: body?.model || null,
+                    provider_id: null,
+                    status_code: status,
+                    latency_ms: 0,
+                    is_stream: 0,
+                    error_message: fastifyError.message,
+                    created_at: new Date().toISOString(),
+                    client_request: JSON.stringify({ headers: request.headers }),
+                    router_key_id: request.routerKey?.id ?? null,
+                });
+            }
+            return reply.code(status).send({ error: { message: fastifyError.message } });
         }
-        if (status === HTTP_BAD_REQUEST && fastifyError.validation) {
-            return reply.code(HTTP_BAD_REQUEST).send({ error: { message: fastifyError.message } });
+        // Admin API — 统一信封错误格式
+        const code = statusToApiCode(status);
+        return reply.code(status).send(apiError(code, fastifyError.message));
+    });
+    // onSend hook：自动包装 Admin API 成功响应为信封格式
+    app.addHook('onSend', async (request, reply, payload) => {
+        if (!isAdminApiResponse(request.url, reply.getHeader('content-type'))) {
+            return payload;
         }
-        return reply.code(status).send({ error: { message: fastifyError.message } });
+        // 已是错误信封（errorHandler 已包装）或已是信封格式 — 跳过
+        if (typeof payload === 'string') {
+            try {
+                const parsed = JSON.parse(payload);
+                if ('code' in parsed)
+                    return payload; // errorHandler 或路由已手动包装
+            }
+            catch {
+                return payload;
+            }
+        }
+        // 包装成功响应
+        const wrapped = {
+            code: API_CODE.SUCCESS,
+            message: 'ok',
+            data: typeof payload === 'string' ? JSON.parse(payload) : payload,
+        };
+        return JSON.stringify(wrapped);
     });
     loadRecommendedConfig();
+    startUpgradeChecker(options?.upgradeCheckerOptions);
     // 启动时回填：补齐回退老版本期间缺失的 metrics 冗余列
     if (shouldBackfill) {
         const backfilled = backfillMetricsFromRequestMetrics(db);
@@ -145,20 +165,20 @@ export async function buildApp(options) {
     app.register(openaiProxy, {
         db,
         streamTimeoutMs: config.STREAM_TIMEOUT_MS,
-        retryMaxAttempts: config.RETRY_MAX_ATTEMPTS,
         retryBaseDelayMs: config.RETRY_BASE_DELAY_MS,
         matcher,
         semaphoreManager,
         tracker,
+        usageWindowTracker,
     });
     app.register(anthropicProxy, {
         db,
         streamTimeoutMs: config.STREAM_TIMEOUT_MS,
-        retryMaxAttempts: config.RETRY_MAX_ATTEMPTS,
         retryBaseDelayMs: config.RETRY_BASE_DELAY_MS,
         matcher,
         semaphoreManager,
         tracker,
+        usageWindowTracker,
     });
     app.register(adminRoutes, { db, matcher, tracker, semaphoreManager });
     // 前端静态文件服务（生产环境）
@@ -193,6 +213,7 @@ export async function buildApp(options) {
         db,
         usageWindowTracker,
         close: async () => {
+            stopUpgradeChecker();
             logCleanup.stop();
             dbSizeMonitor.stop();
             tracker.stopPushInterval();

package/dist/metrics/metrics-extractor.js

@@ -1,4 +1,4 @@
-const MS_PER_SECOND = 1000;
+import { MS_PER_SECOND } from "../constants.js";
 export class MetricsExtractor {
     apiType;
     requestStartTime;

package/dist/metrics/sse-parser.js

@@ -5,6 +5,8 @@ export class SSEParser {
         if (this.isDone)
             return [];
         this.buffer += chunk;
+        // SSE 规范允许 \r\n 行尾，统一为 \n
+        this.buffer = this.buffer.replace(/\r\n/g, "\n");
         return this.drainEvents();
     }
     flush() {

package/dist/middleware/admin-auth.js

@@ -3,6 +3,7 @@ import cookie from "@fastify/cookie";
 import jwt from "jsonwebtoken";
 import { isInitialized, getSetting } from "../db/settings.js";
 import { verifyPassword } from "../utils/password.js";
+import { API_CODE, apiError } from "../admin/api-response.js";
 const HTTP_UNAUTHORIZED = 401;
 const adminAuthRaw = (app, options, done) => {
     app.register(cookie);
@@ -19,11 +20,11 @@ const adminAuthRaw = (app, options, done) => {
             return;
         // 未初始化时返回 needsSetup
         if (!isInitialized(options.db)) {
-            return reply.code(HTTP_UNAUTHORIZED).send({ error: { message: "Not initialized", needsSetup: true } });
+            return reply.code(HTTP_UNAUTHORIZED).send(apiError(API_CODE.NOT_INITIALIZED, "Not initialized"));
         }
         const token = request.cookies["admin_token"];
         if (!token) {
-            reply.code(HTTP_UNAUTHORIZED).send({ error: { message: "Not authenticated" } });
+            reply.code(HTTP_UNAUTHORIZED).send(apiError(API_CODE.TOKEN_INVALID, "Not authenticated"));
             return reply;
         }
         const secret = getSetting(options.db, "jwt_secret");
@@ -32,7 +33,7 @@ const adminAuthRaw = (app, options, done) => {
         }
         catch (err) {
             request.log.debug({ err }, "invalid JWT token");
-            reply.code(HTTP_UNAUTHORIZED).send({ error: { message: "Invalid or expired token" } });
+            reply.code(HTTP_UNAUTHORIZED).send(apiError(API_CODE.TOKEN_INVALID, "Invalid or expired token"));
             return reply;
         }
     });
@@ -44,12 +45,12 @@ export const adminLoginRoutes = (app, options, done) => {
     app.post("/admin/api/login", async (request, reply) => {
         const { password } = request.body;
         if (!password) {
-            return reply.code(HTTP_UNAUTHORIZED).send({ error: { message: "Invalid password" } });
+            return reply.code(HTTP_UNAUTHORIZED).send(apiError(API_CODE.WRONG_PASSWORD, "Invalid password"));
         }
         // DB 模式：scrypt hash 验证
         const hash = getSetting(options.db, "admin_password_hash");
         if (!hash || !verifyPassword(password, hash)) {
-            return reply.code(HTTP_UNAUTHORIZED).send({ error: { message: "Invalid password" } });
+            return reply.code(HTTP_UNAUTHORIZED).send(apiError(API_CODE.WRONG_PASSWORD, "Invalid password"));
         }
         const secret = getSetting(options.db, "jwt_secret");
         const token = jwt.sign({ role: "admin" }, secret, { expiresIn: TOKEN_EXPIRY_SECONDS });

package/dist/middleware/auth.js

@@ -2,6 +2,7 @@ import { createHash, randomUUID } from "crypto";
 import fp from "fastify-plugin";
 import { isInitialized } from "../db/settings.js";
 import { insertRequestLog } from "../db/logs.js";
+import { getProxyApiType } from "../constants.js";
 const SKIP_PATHS = ["/health", "/admin"];
 const HTTP_UNAUTHORIZED = 401;
 const HTTP_SERVICE_UNAVAILABLE = 503;
@@ -19,16 +20,6 @@ function unauthorizedReply(reply) {
         },
     });
 }
-// 代理路由路径 → api_type 映射，用于记录被认证拒绝的请求
-const PROXY_API_TYPES = {
-    "/v1/chat/completions": "openai",
-    "/v1/messages": "anthropic",
-    "/v1/models": "openai",
-};
-function getProxyApiType(url) {
-    const path = url.split("?")[0];
-    return PROXY_API_TYPES[path] ?? null;
-}
 function logRejectedAuth(db, apiType, statusCode, errorMessage, request) {
     insertRequestLog(db, {
         id: randomUUID(),

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

@@ -15,6 +15,7 @@ export declare class RequestTracker {
     private providerConfigCache;
     private pushTimer;
     private tickCount;
+    private streamAccumulators;
     /** Visible for testing */
     readonly statsAggregator: StatsAggregator;
     readonly runtimeCollector: RuntimeCollector;

package/dist/monitor/request-tracker.js

@@ -1,6 +1,6 @@
 import { StatsAggregator } from "./stats-aggregator.js";
 import { RuntimeCollector } from "./runtime-collector.js";
-import { extractStreamText } from "./stream-extractor.js";
+import { StreamContentAccumulator } from "./stream-content-accumulator.js";
 const RUNTIME_PUSH_TICK_INTERVAL = 2;
 const RECENT_COMPLETED_MAX = 200;
 const RECENT_TTL_MS = 5 * 60 * 1000; // eslint-disable-line no-magic-numbers
@@ -14,6 +14,7 @@ export class RequestTracker {
     providerConfigCache = new Map();
     pushTimer = null;
     tickCount = 0;
+    streamAccumulators = new Map();
     /** Visible for testing */
     statsAggregator;
     runtimeCollector;
@@ -48,51 +49,13 @@ export class RequestTracker {
         const req = this.activeMap.get(id);
         if (!req)
             return;
-        if (!req.streamContent) {
-            req.streamContent = { rawChunks: "", textContent: "", totalChars: 0, blocks: [] };
-        }
-        const sc = req.streamContent;
-        sc.totalChars += rawLine.length;
-        // 环形缓冲区：超过限制时截断保留尾部
-        sc.rawChunks += rawLine + "\n";
-        if (sc.rawChunks.length > maxRaw) {
-            sc.rawChunks = sc.rawChunks.slice(-maxRaw);
-        }
-        // 初始化 blocks 数组
-        if (!sc.blocks) {
-            sc.blocks = [];
-        }
-        const extracted = extractStreamText(rawLine, apiType);
-        // 拼接纯文本（text 和 text_delta）
-        if (extracted.text) {
-            sc.textContent += extracted.text;
-            if (sc.textContent.length > maxText) {
-                sc.textContent = sc.textContent.slice(-maxText);
-            }
-        }
-        // 维护结构化内容块
-        if (extracted.block) {
-            const { index, type, content, name } = extracted.block;
-            while (sc.blocks.length <= index) {
-                sc.blocks.push({ type: 'text', content: '' });
-            }
-            if (name) {
-                sc.blocks[index].name = name;
-            }
-            if (content === '' && type !== 'text') {
-                sc.blocks[index].type = type;
-            }
-            else if (content) {
-                sc.blocks[index].content += content;
-                sc.blocks[index].type = type;
-            }
-            const MAX_BLOCK_CONTENT = maxText;
-            for (const block of sc.blocks) {
-                if (block.content.length > MAX_BLOCK_CONTENT) {
-                    block.content = block.content.slice(-MAX_BLOCK_CONTENT);
-                }
-            }
+        let acc = this.streamAccumulators.get(id);
+        if (!acc) {
+            acc = new StreamContentAccumulator(maxRaw, maxText);
+            this.streamAccumulators.set(id, acc);
         }
+        acc.append(rawLine, apiType);
+        req.streamContent = acc.getSnapshot();
     }
     complete(id, result) {
         const req = this.activeMap.get(id);
@@ -112,6 +75,7 @@ export class RequestTracker {
             completedAt: now,
         };
         this.activeMap.delete(id);
+        this.streamAccumulators.delete(id);
         this.recentCompleted.unshift(completed);
         if (this.recentCompleted.length > RECENT_COMPLETED_MAX) {
             this.recentCompleted.length = RECENT_COMPLETED_MAX;

package/dist/monitor/runtime-collector.js

@@ -1,5 +1,5 @@
 import { performance } from "node:perf_hooks";
-const MS_PER_SECOND = 1000;
+import { MS_PER_SECOND } from "../constants.js";
 const NS_PER_MS = 1e6;
 const perf = performance;
 const proc = process;

package/dist/monitor/stream-content-accumulator.d.ts

@@ -0,0 +1,14 @@
+import type { StreamContentSnapshot } from "./types.js";
+export declare const DEFAULT_MAX_RAW = 131072;
+export declare const DEFAULT_MAX_TEXT = 65536;
+export declare class StreamContentAccumulator {
+    private readonly maxRaw;
+    private readonly maxText;
+    private rawChunks;
+    private textContent;
+    private totalChars;
+    private blocks;
+    constructor(maxRaw?: number, maxText?: number);
+    append(rawLine: string, apiType: "openai" | "anthropic"): void;
+    getSnapshot(): StreamContentSnapshot;
+}

package/dist/monitor/stream-content-accumulator.js

@@ -0,0 +1,58 @@
+import { extractStreamText } from "./stream-extractor.js";
+export const DEFAULT_MAX_RAW = 131072;
+export const DEFAULT_MAX_TEXT = 65536;
+export class StreamContentAccumulator {
+    maxRaw;
+    maxText;
+    rawChunks = "";
+    textContent = "";
+    totalChars = 0;
+    blocks = [];
+    constructor(maxRaw = DEFAULT_MAX_RAW, maxText = DEFAULT_MAX_TEXT) {
+        this.maxRaw = maxRaw;
+        this.maxText = maxText;
+    }
+    append(rawLine, apiType) {
+        this.totalChars += rawLine.length;
+        this.rawChunks += rawLine + "\n";
+        if (this.rawChunks.length > this.maxRaw) {
+            this.rawChunks = this.rawChunks.slice(-this.maxRaw);
+        }
+        const extracted = extractStreamText(rawLine, apiType);
+        if (extracted.text) {
+            this.textContent += extracted.text;
+            if (this.textContent.length > this.maxText) {
+                this.textContent = this.textContent.slice(-this.maxText);
+            }
+        }
+        if (extracted.block) {
+            const { index, type, content, name } = extracted.block;
+            while (this.blocks.length <= index) {
+                this.blocks.push({ type: "text", content: "" });
+            }
+            if (name) {
+                this.blocks[index].name = name;
+            }
+            if (content === "" && type !== "text") {
+                this.blocks[index].type = type;
+            }
+            else if (content) {
+                this.blocks[index].content += content;
+                this.blocks[index].type = type;
+            }
+            for (const block of this.blocks) {
+                if (block.content.length > this.maxText) {
+                    block.content = block.content.slice(-this.maxText);
+                }
+            }
+        }
+    }
+    getSnapshot() {
+        return {
+            rawChunks: this.rawChunks,
+            textContent: this.textContent,
+            totalChars: this.totalChars,
+            blocks: this.blocks.length > 0 ? this.blocks : undefined,
+        };
+    }
+}

package/dist/proxy/anthropic.d.ts

@@ -3,13 +3,14 @@ import type { FastifyPluginCallback } from "fastify";
 import { RetryRuleMatcher } from "./retry-rules.js";
 import { ProviderSemaphoreManager } from "./semaphore.js";
 import type { RequestTracker } from "../monitor/request-tracker.js";
+import type { UsageWindowTracker } from "./usage-window-tracker.js";
 export interface AnthropicProxyOptions {
     db: Database.Database;
     streamTimeoutMs: number;
-    retryMaxAttempts: number;
     retryBaseDelayMs: number;
     matcher?: RetryRuleMatcher;
     semaphoreManager?: ProviderSemaphoreManager;
     tracker?: RequestTracker;
+    usageWindowTracker?: UsageWindowTracker;
 }
 export declare const anthropicProxy: FastifyPluginCallback<AnthropicProxyOptions>;

package/dist/proxy/anthropic.js

@@ -14,14 +14,14 @@ const ANTHROPIC_ERROR_TYPE = {
 };
 const anthropicErrors = createErrorFormatter((kind, message) => ({ type: "error", error: { type: ANTHROPIC_ERROR_TYPE[kind], message } }));
 const anthropicProxyRaw = (app, opts, done) => {
-    const { db, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher, semaphoreManager, tracker } = opts;
+    const { db, streamTimeoutMs, retryBaseDelayMs, matcher, semaphoreManager, tracker, usageWindowTracker } = opts;
     const orchestrator = createOrchestrator(semaphoreManager, tracker);
     app.post(MESSAGES_PATH, async (request, reply) => {
         if (!orchestrator) {
             const e = anthropicErrors.providerUnavailable();
-            return reply.status(e.statusCode).send(e.body);
+            return reply.code(e.statusCode).send(e.body);
         }
-        const deps = { db, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher, tracker, orchestrator };
+        const deps = { db, streamTimeoutMs, retryBaseDelayMs, matcher, tracker, orchestrator, usageWindowTracker };
         return handleProxyRequest(request, reply, "anthropic", MESSAGES_PATH, anthropicErrors, deps);
     });
     done();

package/dist/proxy/enhancement/directive-parser.d.ts

@@ -0,0 +1,18 @@
+/** synthetic tool_use 的 ID 前缀，用于识别我们的 AskUserQuestion 响应 */
+export declare const TOOL_USE_ID_PREFIX = "toolu_router_";
+export interface DirectiveParseResult {
+    modelName: string | null;
+    command: string | null;
+    cleanedBody: Record<string, unknown>;
+    isCommandMessage: boolean;
+}
+export declare function parseDirective(body: Record<string, unknown>): DirectiveParseResult;
+export interface ToolResultParseResult {
+    isRouterToolResult: boolean;
+    selectedModel: string | null;
+}
+/**
+ * 检测请求中是否包含对 router synthetic AskUserQuestion 的 tool_result 回调，
+ * 如果是，从中提取用户选择的模型名。
+ */
+export declare function parseToolResult(body: Record<string, unknown>): ToolResultParseResult;

package/dist/proxy/{directive-parser.js → enhancement/directive-parser.js}

@@ -1,5 +1,12 @@
 const MODEL_MAX_LEN = 128;
 const MODEL_RE = /^[a-zA-Z0-9][a-zA-Z0-9._:-]*$/;
+/** synthetic tool_use 的 ID 前缀，用于识别我们的 AskUserQuestion 响应 */
+export const TOOL_USE_ID_PREFIX = "toolu_router_";
+/**
+ * 从 Claude Code AskUserQuestion 的 tool_result content 文本中提取用户选择。
+ * 格式：User has answered your questions: "question"="answer". ...
+ */
+const RE_TOOL_RESULT_ANSWER = /="([^"]+)"\./;
 function isValidModelName(name) {
     return name.length <= MODEL_MAX_LEN && MODEL_RE.test(name) && !/^\d+$/.test(name);
 }
@@ -68,3 +75,40 @@ export function parseDirective(body) {
     }
     return { modelName, command, cleanedBody, isCommandMessage };
 }
+/**
+ * 检测请求中是否包含对 router synthetic AskUserQuestion 的 tool_result 回调，
+ * 如果是，从中提取用户选择的模型名。
+ */
+export function parseToolResult(body) {
+    const messages = body.messages;
+    if (!messages?.length)
+        return { isRouterToolResult: false, selectedModel: null };
+    let lastUserIdx = -1;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === "user") {
+            lastUserIdx = i;
+            break;
+        }
+    }
+    if (lastUserIdx < 0)
+        return { isRouterToolResult: false, selectedModel: null };
+    const lastUser = messages[lastUserIdx];
+    const blocks = Array.isArray(lastUser.content) ? lastUser.content : [lastUser.content];
+    for (const block of blocks) {
+        if (!block || typeof block !== "object")
+            continue;
+        const b = block;
+        if (b.type !== "tool_result" || typeof b.tool_use_id !== "string")
+            continue;
+        if (!b.tool_use_id.startsWith(TOOL_USE_ID_PREFIX))
+            continue;
+        const text = typeof b.content === "string" ? b.content : "";
+        const match = RE_TOOL_RESULT_ANSWER.exec(text);
+        if (match?.[1]) {
+            return { isRouterToolResult: true, selectedModel: match[1] };
+        }
+        // tool_result 匹配前缀但无法提取模型名
+        return { isRouterToolResult: true, selectedModel: null };
+    }
+    return { isRouterToolResult: false, selectedModel: null };
+}