llm-simple-router 0.6.7 → 0.7.1

package/dist/index.js

@@ -5,42 +5,74 @@ 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, getProxyApiType } from "./constants.js";
+import { HTTP_NOT_FOUND, HTTP_INTERNAL_ERROR, getProxyApiType } from "./core/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;
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-import { getConfig } from "./config.js";
-import { initDatabase, getAllProviders, backfillMetricsFromRequestMetrics } from "./db/index.js";
+import { getConfig, getBaseConfig } from "./config/index.js";
+import { initDatabase, getAllProviders } from "./db/index.js";
 import { loadRecommendedConfig } from "./config/recommended.js";
 import { authMiddleware } from "./middleware/auth.js";
-import { openaiProxy } from "./proxy/openai.js";
-import { anthropicProxy } from "./proxy/anthropic.js";
+import { openaiProxy } from "./proxy/handler/openai.js";
+import { anthropicProxy } from "./proxy/handler/anthropic.js";
 import { adminRoutes } from "./admin/routes.js";
-import { RetryRuleMatcher } from "./proxy/retry-rules.js";
-import { ProviderSemaphoreManager } from "./proxy/semaphore.js";
+import { RetryRuleMatcher } from "./proxy/orchestration/retry-rules.js";
+import { ProviderSemaphoreManager } from "./proxy/orchestration/semaphore.js";
 import { AdaptiveConcurrencyController } from "./proxy/adaptive-controller.js";
+import { loadEnhancementConfig } from "./proxy/routing/enhancement-config.js";
 import { RequestTracker } from "./monitor/request-tracker.js";
-import { modelState } from "./proxy/model-state.js";
-import { UsageWindowTracker } from "./proxy/usage-window-tracker.js";
+import { modelState } from "./proxy/routing/model-state.js";
+import { UsageWindowTracker } from "./proxy/routing/usage-window-tracker.js";
 import { SessionTracker } from "./proxy/loop-prevention/session-tracker.js";
 import { DEFAULT_LOOP_PREVENTION_CONFIG } from "./proxy/loop-prevention/types.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";
+import { ServiceContainer, SERVICE_KEYS } from "./core/container.js";
+import { LogFileWriter } from "./storage/log-file-writer.js";
+import { scheduleLogFileMaintenance } from "./storage/log-file-compressor.js";
+import { getDetailLogEnabled, getLogFileRetentionDays } from "./db/settings.js";
+import { dirname, join } from "node:path";
+/**
+ * 共享初始化逻辑 — 启动时和导入配置后都需要调用。
+ * 从 DB 读取所有 provider，初始化信号量/自适应并发/tracker 缓存。
+ */
+export function initializeProviderState(db, semaphoreManager, adaptiveController, tracker) {
+    const allProviders = getAllProviders(db);
+    for (const p of allProviders) {
+        if (p.adaptive_enabled) {
+            adaptiveController.init(p.id, { max: p.max_concurrency }, {
+                queueTimeoutMs: p.queue_timeout_ms,
+                maxQueueSize: p.max_queue_size,
+            });
+        }
+        else if (p.max_concurrency > 0) {
+            semaphoreManager.updateConfig(p.id, {
+                maxConcurrency: p.max_concurrency,
+                queueTimeoutMs: p.queue_timeout_ms,
+                maxQueueSize: p.max_queue_size,
+            });
+        }
+        tracker.updateProviderConfig(p.id, {
+            name: p.name,
+            maxConcurrency: p.max_concurrency ?? 0,
+            queueTimeoutMs: p.queue_timeout_ms ?? PROVIDER_DEFAULT_QUEUE_TIMEOUT_MS,
+            maxQueueSize: p.max_queue_size ?? PROVIDER_DEFAULT_MAX_QUEUE_SIZE,
+        });
+    }
+}
 export async function buildApp(options) {
     const config = options?.config ?? getBaseConfig();
     // 允许外部传入已初始化的 DB（测试用），否则自行创建
     let db;
-    let shouldBackfill = false;
     if (options?.db) {
         db = options.db;
     }
     else {
         db = initDatabase(config.DB_PATH);
-        shouldBackfill = true;
     }
     const isDev = process.env.NODE_ENV !== "production";
     const MAX_BODY_SIZE_MB = 50;
@@ -96,19 +128,24 @@ export async function buildApp(options) {
                 const body = request.body;
                 const receivedAt = request.receivedAt;
                 const latencyMs = receivedAt ? Date.now() - receivedAt : 0;
-                insertRequestLog(db, {
-                    id: randomUUID(),
-                    api_type: proxyApiType,
-                    model: body?.model || null,
-                    provider_id: null,
-                    status_code: status,
-                    latency_ms: latencyMs,
-                    is_stream: body?.stream === true ? 1 : 0,
-                    error_message: fastifyError.message,
-                    created_at: new Date().toISOString(),
-                    client_request: JSON.stringify({ headers: request.headers, ...(body ? { body } : {}) }),
-                    router_key_id: request.routerKey?.id ?? null,
-                });
+                try {
+                    insertRequestLog(db, {
+                        id: randomUUID(),
+                        api_type: proxyApiType,
+                        model: body?.model || null,
+                        provider_id: null,
+                        status_code: status,
+                        latency_ms: latencyMs,
+                        is_stream: body?.stream === true ? 1 : 0,
+                        error_message: fastifyError.message,
+                        created_at: new Date().toISOString(),
+                        client_request: JSON.stringify({ headers: request.headers, ...(body ? { body } : {}) }),
+                        router_key_id: request.routerKey?.id ?? null,
+                    });
+                }
+                catch (logErr) {
+                    request.log.error({ err: logErr }, "Failed to log proxy error to request_logs");
+                }
             }
             return reply.code(status).send({ error: { message: fastifyError.message } });
         }
@@ -125,91 +162,89 @@ export async function buildApp(options) {
         if (typeof payload === 'string') {
             try {
                 const parsed = JSON.parse(payload);
-                if ('code' in parsed)
+                if (parsed !== null && typeof parsed === 'object' && 'code' in parsed)
                     return payload; // errorHandler 或路由已手动包装
+                // 复用已解析结果，避免二次 JSON.parse
+                const wrapped = {
+                    code: API_CODE.SUCCESS,
+                    message: 'ok',
+                    data: parsed,
+                };
+                return JSON.stringify(wrapped);
             }
             catch {
                 return payload;
             }
         }
-        // 包装成功响应
-        const wrapped = {
-            code: API_CODE.SUCCESS,
-            message: 'ok',
-            data: typeof payload === 'string' ? JSON.parse(payload) : payload,
-        };
-        return JSON.stringify(wrapped);
+        return payload;
     });
     loadRecommendedConfig();
     startUpgradeChecker(options?.upgradeCheckerOptions);
-    // 启动时回填：补齐回退老版本期间缺失的 metrics 冗余列
-    if (shouldBackfill) {
-        const backfilled = backfillMetricsFromRequestMetrics(db);
-        if (backfilled > 0) {
-            app.log.info({ backfilled }, "Backfilled metrics from request_metrics");
-        }
-    }
+    const container = new ServiceContainer();
+    container.register(SERVICE_KEYS.db, () => db);
+    container.register(SERVICE_KEYS.matcher, (c) => { const m = new RetryRuleMatcher(); m.load(c.resolve(SERVICE_KEYS.db)); return m; });
+    container.register(SERVICE_KEYS.semaphoreManager, () => new ProviderSemaphoreManager());
+    container.register(SERVICE_KEYS.tracker, (c) => {
+        const t = new RequestTracker({ semaphoreManager: c.resolve(SERVICE_KEYS.semaphoreManager), logger: app.log });
+        t.startPushInterval();
+        return t;
+    });
+    container.register(SERVICE_KEYS.usageWindowTracker, (c) => {
+        const uwt = new UsageWindowTracker(c.resolve(SERVICE_KEYS.db));
+        uwt.reconcileOnStartup();
+        return uwt;
+    });
+    container.register(SERVICE_KEYS.sessionTracker, () => new SessionTracker(DEFAULT_LOOP_PREVENTION_CONFIG.sessionTracker));
+    // 文件日志写入器
+    const isMemoryDb = config.DB_PATH === ":memory:";
+    const logsDir = isMemoryDb ? "" : join(dirname(config.DB_PATH), "logs");
+    // :memory: 模式注册 null，避免 DB 日志记录被 isFileWriter 逻辑抑制
+    const logFileWriter = isMemoryDb
+        ? null
+        : new LogFileWriter(logsDir, { enabled: getDetailLogEnabled(db) });
+    container.register(SERVICE_KEYS.logFileWriter, () => logFileWriter);
     // 注入 DB 到 modelState 单例，启用会话级持久化
     modelState.init(db);
-    const matcher = new RetryRuleMatcher();
-    matcher.load(db);
-    const semaphoreManager = new ProviderSemaphoreManager();
-    const tracker = new RequestTracker({ semaphoreManager, logger: app.log });
-    tracker.startPushInterval();
-    const adaptiveController = new AdaptiveConcurrencyController(semaphoreManager, app.log);
+    // 注册 AdaptiveConcurrencyController（依赖已注册的 semaphoreManager）
+    container.register(SERVICE_KEYS.adaptiveController, (c) => {
+        const ac = new AdaptiveConcurrencyController(c.resolve(SERVICE_KEYS.semaphoreManager), app.log);
+        return ac;
+    });
+    // 从容器解析所有服务
+    const matcher = container.resolve(SERVICE_KEYS.matcher);
+    const semaphoreManager = container.resolve(SERVICE_KEYS.semaphoreManager);
+    const tracker = container.resolve(SERVICE_KEYS.tracker);
+    const usageWindowTracker = container.resolve(SERVICE_KEYS.usageWindowTracker);
+    const adaptiveController = container.resolve(SERVICE_KEYS.adaptiveController);
+    // Wire adaptive controller to tracker
     tracker.setAdaptiveController(adaptiveController);
-    // 5h 用量窗口追踪器，启动时自动补齐缺失窗口
-    const usageWindowTracker = new UsageWindowTracker(db);
-    usageWindowTracker.reconcileOnStartup();
-    // Session tracker（工具调用循环检测用），始终创建但检测受 proxy_enhancement 配置控制
-    const sessionTracker = new SessionTracker(DEFAULT_LOOP_PREVENTION_CONFIG.sessionTracker);
-    // 从 DB 读取已有 provider 的并发配置，初始化信号量管理器和 tracker
-    const allProviders = getAllProviders(db);
-    for (const p of allProviders) {
-        if (p.adaptive_enabled) {
-            adaptiveController.init(p.id, { max: p.max_concurrency }, {
-                queueTimeoutMs: p.queue_timeout_ms,
-                maxQueueSize: p.max_queue_size,
-            });
-        }
-        else if (p.max_concurrency > 0) {
-            semaphoreManager.updateConfig(p.id, {
-                maxConcurrency: p.max_concurrency,
-                queueTimeoutMs: p.queue_timeout_ms,
-                maxQueueSize: p.max_queue_size,
-            });
-        }
-        tracker.updateProviderConfig(p.id, {
-            name: p.name,
-            maxConcurrency: p.max_concurrency ?? 0,
-            queueTimeoutMs: p.queue_timeout_ms ?? PROVIDER_DEFAULT_QUEUE_TIMEOUT_MS,
-            maxQueueSize: p.max_queue_size ?? PROVIDER_DEFAULT_MAX_QUEUE_SIZE,
-        });
-    }
+    // 从 DB 读取已有 provider 的并发配置，初始化信号量/adaptive/tracker（共享逻辑）
+    initializeProviderState(db, semaphoreManager, adaptiveController, tracker);
     app.register(authMiddleware, { db });
-    app.register(openaiProxy, {
-        db,
-        streamTimeoutMs: config.STREAM_TIMEOUT_MS,
-        retryBaseDelayMs: config.RETRY_BASE_DELAY_MS,
-        matcher,
-        semaphoreManager,
-        tracker,
-        usageWindowTracker,
-        sessionTracker,
-        adaptiveController,
-    });
-    app.register(anthropicProxy, {
-        db,
-        streamTimeoutMs: config.STREAM_TIMEOUT_MS,
-        retryBaseDelayMs: config.RETRY_BASE_DELAY_MS,
-        matcher,
-        semaphoreManager,
-        tracker,
-        usageWindowTracker,
-        sessionTracker,
-        adaptiveController,
-    });
-    app.register(adminRoutes, { db, matcher, tracker, semaphoreManager, adaptiveController });
+    app.register(openaiProxy, { db, container });
+    app.register(anthropicProxy, { db, container });
+    // StateRegistry — Admin 层通过此接口触发 proxy 层状态刷新，消除 admin→proxy 依赖
+    const stateRegistry = {
+        refreshRetryRules: () => matcher.load(db),
+        updateProviderConcurrency: (providerId, cfg) => semaphoreManager.updateConfig(providerId, cfg),
+        removeProvider: (providerId) => semaphoreManager.remove(providerId),
+        removeAllProviders: () => semaphoreManager.removeAll(),
+        getProviderStatus: (providerId) => semaphoreManager.getStatus(providerId),
+        clearModelState: () => modelState.clearAll(),
+        deleteModelState: (keyId, sessionId) => modelState.delete(keyId, sessionId),
+        getEnhancementConfig: () => loadEnhancementConfig(db),
+        syncAdaptiveProvider: (providerId, cfg) => adaptiveController.syncProvider(providerId, cfg),
+        removeAdaptiveProvider: (providerId) => adaptiveController.remove(providerId),
+        getAdaptiveStatus: (providerId) => adaptiveController.getStatus(providerId),
+        reinitializeProviders: () => {
+            adaptiveController.removeAll();
+            initializeProviderState(db, semaphoreManager, adaptiveController, tracker);
+        },
+    };
+    // Late-bound close ref — close 函数在 adminRoutes 注册之后才定义，
+    // 但 restart API 需要在运行时调用它
+    const closeRef = { fn: async () => { } };
+    app.register(adminRoutes, { db, stateRegistry, tracker, adaptiveController, logFileWriter, logsDir, closeFn: () => closeRef.fn() });
     // 前端静态文件服务（生产环境）
     const frontendDist = path.resolve(process.env.FRONTEND_DIST || path.join(__dirname, "../frontend-dist"));
     if (existsSync(frontendDist)) {
@@ -237,26 +272,79 @@ export async function buildApp(options) {
     const dbSizeMonitor = scheduleDbSizeMonitor(db, config.DB_PATH, {
         log: app.log,
     });
+    let close = async () => {
+        stopUpgradeChecker();
+        logCleanup.stop();
+        dbSizeMonitor.stop();
+        tracker.stopPushInterval();
+        modelState.clearAll();
+        semaphoreManager.removeAll();
+        const sessionTracker = container.resolve(SERVICE_KEYS.sessionTracker);
+        sessionTracker.stop();
+        await app.close();
+        db.close();
+    };
+    // 文件压缩和清理任务（仅非 :memory: 模式）
+    if (!isMemoryDb) {
+        const logFileMaintenance = scheduleLogFileMaintenance(logsDir, {
+            retentionDays: getLogFileRetentionDays(db),
+            log: app.log,
+        });
+        // 注册到 close
+        const prevClose = close;
+        close = async () => {
+            logFileMaintenance.stop();
+            await prevClose();
+        };
+    }
+    // 将最终版 close 函数绑定到 late-bound ref（供 restart API 运行时调用）
+    closeRef.fn = close;
     return {
         app,
         db,
         usageWindowTracker,
-        close: async () => {
-            stopUpgradeChecker();
-            logCleanup.stop();
-            dbSizeMonitor.stop();
-            tracker.stopPushInterval();
-            sessionTracker.stop();
-            await app.close();
-            db.close();
-        },
+        close,
     };
 }
-// index.ts 自身也需要 getBaseConfig，避免循环依赖
-import { getBaseConfig } from "./config.js";
 export async function main() {
-    const { app } = await buildApp();
+    const { app, close } = await buildApp();
     const config = getConfig();
+    // 全局兜底：防止未捕获异常导致进程崩溃
+    process.on("uncaughtException", (err) => {
+        try {
+            app.log.fatal({ err }, "Uncaught exception");
+            /* eslint-disable taste/no-silent-catch -- app.log 可能已崩溃，console 是最后手段 */
+        }
+        catch {
+            console.error("FATAL: Uncaught exception:", err);
+        }
+        /* eslint-enable taste/no-silent-catch */
+        close().finally(() => process.exit(1));
+    });
+    process.on("unhandledRejection", (reason) => {
+        try {
+            app.log.error({ err: reason instanceof Error ? reason : new Error(String(reason)) }, "Unhandled rejection");
+            /* eslint-disable taste/no-silent-catch -- app.log 可能已崩溃，console 是最后手段 */
+        }
+        catch {
+            console.error("Unhandled rejection:", reason);
+        }
+        /* eslint-enable taste/no-silent-catch */
+    });
+    // 优雅关闭：SIGTERM（systemd/docker stop）和 SIGINT（Ctrl+C）
+    const shutdown = async (signal) => {
+        try {
+            app.log.info(`Received ${signal}, shutting down gracefully...`);
+            await close();
+            app.log.info("Shutdown complete");
+        }
+        catch (err) {
+            app.log.error({ err }, "Error during shutdown");
+        }
+        process.exit(0);
+    };
+    process.on("SIGTERM", () => shutdown("SIGTERM"));
+    process.on("SIGINT", () => shutdown("SIGINT"));
     try {
         await app.listen({ port: config.PORT, host: "0.0.0.0" });
         app.log.info(`Server listening on port ${config.PORT}`);

package/dist/metrics/metrics-extractor.d.ts

@@ -1,28 +1,5 @@
+import type { MetricsResult } from "../core/types.js";
 import type { SSEEvent } from "./sse-parser.js";
-export interface MetricsResult {
-    input_tokens: number | null;
-    output_tokens: number | null;
-    cache_creation_tokens: number | null;
-    cache_read_tokens: number | null;
-    ttft_ms: number | null;
-    /** T6 - T0: proxy end-to-end streaming duration */
-    total_duration_ms: number | null;
-    /** @deprecated Use total_tps instead */
-    tokens_per_second: number | null;
-    stop_reason: string | null;
-    is_complete: number;
-    input_tokens_estimated?: number;
-    thinking_tokens: number | null;
-    /** T3 - T0: request start to last thinking delta */
-    thinking_duration_ms: number | null;
-    thinking_tps: number | null;
-    /** T6 - T3 (thinking) or T6 - T0 (non-thinking) */
-    non_thinking_duration_ms: number | null;
-    non_thinking_tps: number | null;
-    total_tps: number | null;
-    text_tokens: number | null;
-    tool_use_tokens: number | null;
-}
 export declare class MetricsExtractor {
     private apiType;
     private requestStartTime;

package/dist/metrics/metrics-extractor.js

@@ -1,5 +1,5 @@
 // TODO: 当文件超过 400 行时拆分为 metrics-streaming.ts（流式事件处理 + TPS 计算）和 metrics-extractor.ts（非流式 + 类型）
-import { MS_PER_SECOND } from "../constants.js";
+import { MS_PER_SECOND } from "../core/constants.js";
 import { encode } from "gpt-tokenizer";
 export class MetricsExtractor {
     apiType;

package/dist/metrics/sse-metrics-transform.d.ts

@@ -1,6 +1,6 @@
 import { Transform, TransformCallback } from "stream";
 import { MetricsExtractor } from "./metrics-extractor.js";
-import type { MetricsResult } from "./metrics-extractor.js";
+import type { MetricsResult } from "../core/types.js";
 export interface MetricsTransformOptions {
     /** 每次处理 SSE 事件后触发的回调，附带当前指标快照 */
     onMetrics?: (metrics: MetricsResult) => void;

package/dist/middleware/admin-auth.js

@@ -53,6 +53,10 @@ export const adminLoginRoutes = (app, options, done) => {
             return reply.code(HTTP_UNAUTHORIZED).send(apiError(API_CODE.WRONG_PASSWORD, "Invalid password"));
         }
         const secret = getSetting(options.db, "jwt_secret");
+        if (!secret) {
+            request.log.error("JWT secret not configured, cannot issue token");
+            return reply.code(HTTP_UNAUTHORIZED).send(apiError(API_CODE.TOKEN_INVALID, "JWT secret not configured"));
+        }
         const token = jwt.sign({ role: "admin" }, secret, { expiresIn: TOKEN_EXPIRY_SECONDS });
         reply.setCookie("admin_token", token, {
             path: "/admin",

package/dist/middleware/auth.js

@@ -2,10 +2,9 @@ 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";
+import { getProxyApiType, HTTP_SERVICE_UNAVAILABLE } from "../core/constants.js";
 const SKIP_PATHS = ["/health", "/admin"];
 const HTTP_UNAUTHORIZED = 401;
-const HTTP_SERVICE_UNAVAILABLE = 503;
 const BEARER_PREFIX_LENGTH = "Bearer ".length;
 function shouldSkipAuth(url) {
     const path = url.split("?")[0];

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

@@ -1,9 +1,8 @@
 import type { ServerResponse } from "node:http";
 import { StatsAggregator } from "./stats-aggregator.js";
 import { RuntimeCollector } from "./runtime-collector.js";
-import type { ProviderSemaphoreManager } from "../proxy/semaphore.js";
 import type { AdaptiveConcurrencyController } from "../proxy/adaptive-controller.js";
-import type { ActiveRequest, AttemptSnapshot, ProviderConcurrencySnapshot, RuntimeMetrics, StatsSnapshot } from "./types.js";
+import type { ActiveRequest, AttemptSnapshot, ISemaphoreStatus, ProviderConcurrencySnapshot, RuntimeMetrics, StatsSnapshot } from "./types.js";
 export interface TrackerLogger {
     debug(obj: Record<string, unknown>, msg: string): void;
     warn(obj: Record<string, unknown>, msg: string): void;
@@ -25,7 +24,7 @@ export declare class RequestTracker {
     private readonly semaphoreManager?;
     private adaptiveController?;
     constructor(deps?: {
-        semaphoreManager?: ProviderSemaphoreManager;
+        semaphoreManager?: ISemaphoreStatus;
         runtimeCollector?: RuntimeCollector;
         logger?: TrackerLogger;
     });
@@ -50,7 +49,7 @@ export declare class RequestTracker {
     getConcurrency(): ProviderConcurrencySnapshot[];
     getRuntime(): RuntimeMetrics;
     addClient(res: ServerResponse): void;
-    /** 向单个客户端发送当前活跃请求快照 */
+    /** 向单个客户端发送当前活跃请求快照（保留 clientRequest 以便前端即时展示） */
     private sendInitialSnapshot;
     removeClient(res: ServerResponse): void;
     startPushInterval(): void;

package/dist/monitor/request-tracker.js

@@ -173,13 +173,9 @@ export class RequestTracker {
             this.clients.delete(res);
         });
     }
-    /** 向单个客户端发送当前活跃请求快照 */
+    /** 向单个客户端发送当前活跃请求快照（保留 clientRequest 以便前端即时展示） */
     sendInitialSnapshot(res) {
-        const active = this.getActive().map((req) => {
-            const copy = { ...req };
-            delete copy.clientRequest;
-            return copy;
-        });
+        const active = this.getActive();
         const msg = `event: request_update\ndata: ${JSON.stringify(active)}\n\n`;
         try {
             if (!res.writableEnded)
@@ -224,17 +220,11 @@ export class RequestTracker {
         this.runtimeCollector.stop();
     }
     broadcast(event, data) {
-        // Strip clientRequest from broadcasts to reduce bandwidth;
-        // full data available on-demand via API endpoint
+        // request_update: 保留 clientRequest，前端 pending 请求需要即时展示内容
+        // request_start: 无需处理，已是原始数据
+        // request_complete: strip clientRequest（完成后从 DB 加载详情）
         let payload = data;
-        if (event === "request_update" && Array.isArray(data)) {
-            payload = data.map((req) => {
-                const copy = { ...req };
-                delete copy.clientRequest;
-                return copy;
-            });
-        }
-        else if (event === "request_complete" && data && typeof data === "object") {
+        if (event === "request_complete" && data && typeof data === "object") {
             const copy = { ...data };
             delete copy.clientRequest;
             payload = copy;

package/dist/monitor/runtime-collector.js

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

package/dist/monitor/types.d.ts

@@ -29,6 +29,7 @@ export interface ActiveRequest {
     clientIp?: string;
     sessionId?: string;
     clientRequest?: string;
+    upstreamRequest?: string;
     completedAt?: number;
 }
 export interface AttemptSnapshot {
@@ -89,6 +90,13 @@ export interface ProviderStats {
         count: number;
     }>;
 }
+/** request-tracker 需要的信号量状态查询接口 */
+export interface ISemaphoreStatus {
+    getStatus(providerId: string): {
+        active: number;
+        queued: number;
+    };
+}
 export interface RuntimeMetrics {
     uptimeMs: number;
     memoryUsage: NodeJS.MemoryUsage;

package/dist/proxy/adaptive-controller.d.ts

@@ -1,4 +1,4 @@
-import type { ProviderSemaphoreManager } from "./semaphore.js";
+import type { ProviderSemaphoreManager } from "./orchestration/semaphore.js";
 export interface AdaptiveState {
     currentLimit: number;
     probeActive: boolean;
@@ -31,7 +31,10 @@ export declare class AdaptiveConcurrencyController {
         queueTimeoutMs: number;
         maxQueueSize: number;
     }): void;
+    /** 移除 provider 的自适应并发状态。调用方还需调用 semaphoreManager.remove() 或 updateConfig() 清理信号量配置。 */
     remove(providerId: string): void;
+    /** 清除所有 provider 的自适应并发状态（导入配置后重建前调用） */
+    removeAll(): void;
     onRequestComplete(providerId: string, result: AdaptiveResult): void;
     getStatus(providerId: string): AdaptiveState | undefined;
     syncProvider(providerId: string, p: ProviderAdaptiveConfig): void;

package/dist/proxy/adaptive-controller.js

@@ -29,9 +29,14 @@ export class AdaptiveConcurrencyController {
         });
         this.syncToSemaphore(providerId);
     }
+    /** 移除 provider 的自适应并发状态。调用方还需调用 semaphoreManager.remove() 或 updateConfig() 清理信号量配置。 */
     remove(providerId) {
         this.entries.delete(providerId);
     }
+    /** 清除所有 provider 的自适应并发状态（导入配置后重建前调用） */
+    removeAll() {
+        this.entries.clear();
+    }
     onRequestComplete(providerId, result) {
         const entry = this.entries.get(providerId);
         if (!entry)

package/dist/proxy/enhancement/enhancement-handler.d.ts

@@ -1,6 +1,5 @@
-import type { FastifyRequest } from "fastify";
 import Database from "better-sqlite3";
-import { type EnhancementConfig } from "../enhancement-config.js";
+import { type EnhancementConfig } from "../routing/enhancement-config.js";
 export interface InterceptResponse {
     statusCode: number;
     body: unknown;
@@ -10,15 +9,32 @@ export interface InterceptResponse {
         detail?: string;
     };
 }
+export interface EnhancementMeta {
+    router_tags_stripped: number;
+    directive: {
+        type: "select_model" | "router_model" | "router_command";
+        value: string;
+    } | null;
+}
 export interface EnhancementResult {
+    body: Record<string, unknown>;
     effectiveModel: string;
     originalModel: string | null;
     interceptResponse: InterceptResponse | null;
+    meta: EnhancementMeta;
+}
+/** 调用方传入的 routerKey 信息，从 FastifyRequest.routerKey 解耦 */
+export interface RouterKeyInfo {
+    id: string;
+    name: string;
+    allowed_models: string | null;
 }
 /**
  * 在代理转发前应用代理增强逻辑（指令解析 + 会话记忆 + 模型替换 + 命令拦截）。
  * 仅当 proxy_enhancement.claude_code_enabled 开启时生效。
+ *
+ * 纯函数：不修改输入 body，返回变换后的新 body + 元数据。
  */
-export declare function applyEnhancement(db: Database.Database, request: FastifyRequest, clientModel: string, sessionId?: string, enhancementConfig?: EnhancementConfig): EnhancementResult;
+export declare function applyEnhancement(db: Database.Database, body: Record<string, unknown>, clientModel: string, sessionId: string | undefined, routerKey: RouterKeyInfo | undefined, enhancementConfig?: EnhancementConfig): EnhancementResult;
 /** 生成注入到非流式响应中的模型信息标签 */
 export declare function buildModelInfoTag(effectiveModel: string): string;