llm-simple-router 1.0.22 → 1.0.23

package/dist/admin/providers.d.ts

@@ -21,7 +21,7 @@ export declare function serializeProviders(db: Database.Database, providers: Pro
 }): {
     id: string;
     name: string;
-    api_type: "anthropic" | "openai" | "openai-responses";
+    api_type: "openai" | "openai-responses" | "anthropic";
     base_url: string;
     upstream_path: string | null;
     api_key: string;

package/dist/app/compose-container.d.ts

@@ -0,0 +1,19 @@
+import type { FastifyInstance } from "fastify";
+import type Database from "better-sqlite3";
+import { ServiceContainer } from "../core/container.js";
+import { LogFileWriter } from "../storage/log-file-writer.js";
+import type { Config } from "../config/index.js";
+export interface ComposeContainerResult {
+    container: ServiceContainer;
+    logFileWriter: LogFileWriter | null;
+    logsDir: string;
+    isMemoryDb: boolean;
+}
+export interface ComposeContainerOptions {
+    config: Config;
+}
+/**
+ * 注册所有服务到 ServiceContainer。
+ * 返回 container 及 logFileWriter（close 时需要 flush）。
+ */
+export declare function composeContainer(db: Database.Database, opts: ComposeContainerOptions, app: FastifyInstance): ComposeContainerResult;

package/dist/app/compose-container.js

@@ -0,0 +1,84 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { ServiceContainer, SERVICE_KEYS } from "../core/container.js";
+import { RetryRuleMatcher } from "../proxy/orchestration/retry-rules.js";
+import { PluginRegistry } from "../proxy/transform/plugin-registry.js";
+import { FormatRegistry } from "../proxy/format/registry.js";
+import { openaiAdapter } from "../proxy/format/adapters/openai.js";
+import { anthropicAdapter } from "../proxy/format/adapters/anthropic.js";
+import { responsesAdapter } from "../proxy/format/adapters/responses.js";
+import { openaiToAnthropicConverter } from "../proxy/format/converters/openai-anthropic.js";
+import { anthropicToOpenAIConverter } from "../proxy/format/converters/anthropic-openai.js";
+import { openaiToResponsesConverter } from "../proxy/format/converters/openai-responses.js";
+import { responsesToOpenAIConverter } from "../proxy/format/converters/responses-openai.js";
+import { responsesToAnthropicConverter } from "../proxy/format/converters/responses-anthropic.js";
+import { anthropicToResponsesConverter } from "../proxy/format/converters/anthropic-responses.js";
+import { SemaphoreManager, AdaptiveController } from "../core/concurrency/index.js";
+import { RequestTracker } from "../core/monitor/index.js";
+import { UsageWindowTracker } from "../proxy/routing/usage-window-tracker.js";
+import { SessionTracker, DEFAULT_LOOP_PREVENTION_CONFIG } from "../core/loop-prevention/index.js";
+import { LogFileWriter } from "../storage/log-file-writer.js";
+import { ProxyAgentFactory } from "../proxy/transport/proxy-agent.js";
+import { getDetailLogEnabled } from "../db/settings.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * 注册所有服务到 ServiceContainer。
+ * 返回 container 及 logFileWriter（close 时需要 flush）。
+ */
+export function composeContainer(db, opts, app) {
+    const { config } = opts;
+    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 SemaphoreManager());
+    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");
+    const logFileWriter = isMemoryDb
+        ? null
+        : new LogFileWriter(logsDir, { enabled: getDetailLogEnabled(db) });
+    container.register(SERVICE_KEYS.logFileWriter, () => logFileWriter);
+    // AdaptiveController（依赖已注册的 semaphoreManager）
+    container.register(SERVICE_KEYS.adaptiveController, (c) => {
+        const ac = new AdaptiveController(c.resolve(SERVICE_KEYS.semaphoreManager), app.log);
+        return ac;
+    });
+    // PluginRegistry
+    const pluginRegistry = new PluginRegistry();
+    pluginRegistry.loadFromDB(db);
+    const pluginsDir = path.resolve(__dirname, "../../plugins/transform");
+    pluginRegistry.scanPluginsDir(pluginsDir);
+    container.register(SERVICE_KEYS.pluginRegistry, () => pluginRegistry);
+    // FormatRegistry（3 adapters + 6 converters）
+    const formatRegistry = new FormatRegistry();
+    formatRegistry.registerAdapter(openaiAdapter);
+    formatRegistry.registerAdapter(anthropicAdapter);
+    formatRegistry.registerAdapter(responsesAdapter);
+    formatRegistry.registerConverter(openaiToAnthropicConverter);
+    formatRegistry.registerConverter(anthropicToOpenAIConverter);
+    formatRegistry.registerConverter(openaiToResponsesConverter);
+    formatRegistry.registerConverter(responsesToOpenAIConverter);
+    formatRegistry.registerConverter(responsesToAnthropicConverter);
+    formatRegistry.registerConverter(anthropicToResponsesConverter);
+    container.register(SERVICE_KEYS.formatRegistry, () => formatRegistry);
+    // ProxyAgentFactory
+    container.register(SERVICE_KEYS.proxyAgentFactory, () => new ProxyAgentFactory());
+    return { container, logFileWriter, logsDir, isMemoryDb };
+}

package/dist/app/create-app.d.ts

@@ -0,0 +1,14 @@
+import { type FastifyInstance } from "fastify";
+import type { CheckerOptions } from "../upgrade/checker.js";
+import type { Config } from "../config/index.js";
+import type Database from "better-sqlite3";
+export interface CreateAppOptions {
+    config: Config;
+    db: Database.Database;
+    upgradeCheckerOptions?: CheckerOptions;
+}
+/**
+ * 创建 Fastify 实例并注册全局 hooks（errorHandler、onSend 信封包装等）。
+ * 纯基础设施层，不涉及业务容器或路由。
+ */
+export declare function createAppInstance(opts: CreateAppOptions): FastifyInstance;

package/dist/app/create-app.js

@@ -0,0 +1,148 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { randomUUID } from "crypto";
+import Fastify from "fastify";
+import { insertRequestLog } from "../db/logs.js";
+import { HTTP_INTERNAL_ERROR, getProxyApiType } from "../core/constants.js";
+import { loadRecommendedConfig } from "../config/recommended.js";
+import { startUpgradeChecker } from "../admin/upgrade.js";
+import { isAdminApiResponse, statusToApiCode, apiError } from "../admin/api-response.js";
+import { API_CODE } from "../admin/api-response.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const KB = 1024;
+const MB = KB * KB;
+const MAX_BODY_SIZE_MB = 50;
+/**
+ * 创建 Fastify 实例并注册全局 hooks（errorHandler、onSend 信封包装等）。
+ * 纯基础设施层，不涉及业务容器或路由。
+ */
+export function createAppInstance(opts) {
+    const { config, db, upgradeCheckerOptions } = opts;
+    const isDev = process.env.NODE_ENV !== "production";
+    const app = Fastify({
+        bodyLimit: MAX_BODY_SIZE_MB * MB,
+        logger: {
+            level: config.LOG_LEVEL,
+            ...(isDev
+                ? {
+                    transport: {
+                        target: "pino-pretty",
+                        options: {
+                            translateTime: "SYS:yyyy-mm-dd HH:MM:ss.l",
+                            ignore: "pid,hostname",
+                        },
+                    },
+                }
+                : {}),
+        },
+        ajv: {
+            customOptions: {
+                messages: true,
+            },
+        },
+    });
+    app.setSchemaErrorFormatter((errors) => {
+        const message = errors
+            .map((e) => {
+            const field = e.instancePath ? e.instancePath.slice(1) : e.params?.missingProperty ?? "field";
+            return `${field} ${e.message}`;
+        })
+            .join("; ");
+        return new Error(message);
+    });
+    // 记录请求到达时间，供全局错误处理计算延迟
+    app.addHook("onRequest", (request, reply, done) => {
+        request.receivedAt = Date.now();
+        // 全局 EPIPE 防护
+        const sock = request.raw.socket;
+        const socketErrorHandler = (err) => {
+            if (err.code === "EPIPE" || err.code === "ECONNRESET") {
+                request.log.debug({ err }, "client socket error");
+            }
+            else {
+                request.log.warn({ err }, "unexpected socket error");
+            }
+        };
+        sock.on("error", socketErrorHandler);
+        const replyErrorHandler = (err) => {
+            const code = err.code;
+            if (code === "EPIPE") {
+                request.log.debug({ err }, "client disconnected (EPIPE)");
+            }
+            else {
+                request.log.warn({ err }, "response stream error");
+            }
+        };
+        reply.raw.on("error", replyErrorHandler);
+        reply.raw.on("close", () => {
+            sock.removeListener("error", socketErrorHandler);
+            reply.raw.removeListener("error", replyErrorHandler);
+        });
+        done();
+    });
+    // 统一错误处理
+    app.setErrorHandler((error, request, reply) => {
+        const fastifyError = error;
+        const status = fastifyError.statusCode ?? HTTP_INTERNAL_ERROR;
+        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;
+                const receivedAt = request.receivedAt;
+                const latencyMs = receivedAt ? Date.now() - receivedAt : 0;
+                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 } });
+        }
+        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;
+        }
+        if (typeof payload === "string") {
+            try {
+                const parsed = JSON.parse(payload);
+                if (parsed !== null && typeof parsed === "object" && "code" in parsed)
+                    return payload;
+                const wrapped = {
+                    code: API_CODE.SUCCESS,
+                    message: "ok",
+                    data: parsed,
+                };
+                return JSON.stringify(wrapped);
+            }
+            catch {
+                return payload;
+            }
+        }
+        return payload;
+    });
+    loadRecommendedConfig(path.resolve(__dirname, "../../config"));
+    startUpgradeChecker({
+        ...upgradeCheckerOptions,
+        configDir: path.resolve(__dirname, "../../config"),
+    });
+    return app;
+}

package/dist/app/register-hooks.d.ts

@@ -0,0 +1,20 @@
+import type { FastifyInstance } from "fastify";
+import type Database from "better-sqlite3";
+import { ServiceContainer } from "../core/container.js";
+import type { StateRegistry } from "../core/registry.js";
+import { RetryRuleMatcher } from "../proxy/orchestration/retry-rules.js";
+import { SemaphoreManager } from "../core/concurrency/index.js";
+import { AdaptiveController } from "../core/concurrency/index.js";
+export interface RegisterHooksResult {
+    stateRegistry: StateRegistry;
+}
+export interface RegisterHooksDeps {
+    matcher: RetryRuleMatcher;
+    semaphoreManager: SemaphoreManager;
+    adaptiveController: AdaptiveController;
+}
+/**
+ * 注册 auth middleware、内置 hooks、proxy handlers，构建 StateRegistry。
+ * 返回 stateRegistry 供 admin 路由使用。
+ */
+export declare function registerAppHooks(app: FastifyInstance, db: Database.Database, container: ServiceContainer, deps: RegisterHooksDeps): RegisterHooksResult;

package/dist/app/register-hooks.js

@@ -0,0 +1,50 @@
+import { authMiddleware } from "../middleware/auth.js";
+import { createProxyHandler } from "../proxy/handler/create-proxy-handler.js";
+import { registerBuiltinHooks } from "../proxy/pipeline/register-hooks.js";
+import { proxyPipeline } from "../proxy/pipeline/pipeline.js";
+import { clearEnhancementConfigCache } from "../proxy/routing/enhancement-config.js";
+/**
+ * 注册 auth middleware、内置 hooks、proxy handlers，构建 StateRegistry。
+ * 返回 stateRegistry 供 admin 路由使用。
+ */
+export function registerAppHooks(app, db, container, deps) {
+    const { matcher, semaphoreManager, adaptiveController } = deps;
+    app.register(authMiddleware, { db });
+    // 注册内置 hooks 到 ProxyPipeline（供 emit 执行 + Admin API 查询）
+    registerBuiltinHooks();
+    // --- Proxy handlers (Phase 3 pipeline) ---
+    const openaiHandler = createProxyHandler({
+        apiType: "openai",
+        paths: ["/v1/chat/completions", "/chat/completions"],
+    });
+    const anthropicHandler = createProxyHandler({
+        apiType: "anthropic",
+        paths: ["/v1/messages"],
+    });
+    const responsesHandler = createProxyHandler({
+        apiType: "openai-responses",
+        paths: ["/v1/responses", "/responses"],
+    });
+    app.register(openaiHandler, { db, container });
+    app.register(anthropicHandler, { db, container });
+    app.register(responsesHandler, { db, container });
+    // StateRegistry — 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),
+        syncAdaptiveProvider: (providerId, cfg) => adaptiveController.syncProvider(providerId, cfg),
+        removeAdaptiveProvider: (providerId) => adaptiveController.remove(providerId),
+        getAdaptiveStatus: (providerId) => adaptiveController.getStatus(providerId),
+        reinitializeProviders: () => {
+            adaptiveController.removeAll();
+            // reinitializeProviders 的完整实现在 buildApp 层通过 initializeProviderState 完成
+            // StateRegistry 只重置 adaptive 状态，实际的重新初始化由调用方负责
+        },
+        clearEnhancementCache: () => clearEnhancementConfigCache(),
+        getPipelineHooks: () => proxyPipeline.getAllHooks(),
+    };
+    return { stateRegistry };
+}

package/dist/app/register-routes.d.ts

@@ -0,0 +1,33 @@
+import type { FastifyInstance } from "fastify";
+import type Database from "better-sqlite3";
+import { ServiceContainer } from "../core/container.js";
+import { RequestTracker } from "../core/monitor/index.js";
+import { AdaptiveController } from "../core/concurrency/index.js";
+import { SemaphoreManager } from "../core/concurrency/index.js";
+import { LogFileWriter } from "../storage/log-file-writer.js";
+import { ProxyAgentFactory } from "../proxy/transport/proxy-agent.js";
+import { ProxyConnectivityChecker } from "../proxy/transport/provider-connectivity.js";
+import { PluginRegistry } from "../proxy/transform/plugin-registry.js";
+import type { StateRegistry } from "../core/registry.js";
+import type { Config } from "../config/index.js";
+export interface RegisterRoutesOptions {
+    db: Database.Database;
+    config: Config;
+    container: ServiceContainer;
+    tracker: RequestTracker;
+    semaphoreManager: SemaphoreManager;
+    adaptiveController: AdaptiveController;
+    stateRegistry: StateRegistry;
+    logFileWriter: LogFileWriter | null;
+    logsDir: string;
+    isMemoryDb: boolean;
+    pluginRegistry: PluginRegistry;
+    proxyAgentFactory: ProxyAgentFactory;
+    connectivityChecker: ProxyConnectivityChecker;
+    initializeProviderStateFn: () => void;
+}
+/**
+ * 注册 admin routes、静态文件、/health 端点、定时任务，组装 close 函数。
+ * 返回 close 函数供 buildApp 消费。
+ */
+export declare function registerRoutes(app: FastifyInstance, opts: RegisterRoutesOptions): () => Promise<void>;

package/dist/app/register-routes.js

@@ -0,0 +1,111 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
+import fastifyStatic from "@fastify/static";
+import { SERVICE_KEYS } from "../core/container.js";
+import { HTTP_NOT_FOUND } from "../core/constants.js";
+import { adminRoutes } from "../admin/routes.js";
+import { scheduleLogCleanup } from "../db/log-cleaner.js";
+import { scheduleDbSizeMonitor } from "../db/db-size-monitor.js";
+import { scheduleMetricsAggregator } from "../db/metrics-aggregator.js";
+import { scheduleLogFileMaintenance } from "../storage/log-file-compressor.js";
+import { stopUpgradeChecker } from "../admin/upgrade.js";
+import { getLogFileRetentionDays } from "../db/settings.js";
+/**
+ * 注册 admin routes、静态文件、/health 端点、定时任务，组装 close 函数。
+ * 返回 close 函数供 buildApp 消费。
+ */
+export function registerRoutes(app, opts) {
+    const { db, config, container, tracker, semaphoreManager, logFileWriter, logsDir, isMemoryDb, proxyAgentFactory, stateRegistry, pluginRegistry, connectivityChecker, } = opts;
+    // Override reinitializeProviders to use the full implementation
+    const fullStateRegistry = {
+        ...stateRegistry,
+        reinitializeProviders: () => {
+            stateRegistry.reinitializeProviders();
+            opts.initializeProviderStateFn();
+        },
+    };
+    // Late-bound close ref — close 函数在 adminRoutes 注册之后才定义
+    const closeRef = { fn: async () => { } };
+    app.register(adminRoutes, {
+        db,
+        stateRegistry: fullStateRegistry,
+        tracker,
+        adaptiveController: opts.adaptiveController,
+        logFileWriter,
+        logsDir,
+        closeFn: () => closeRef.fn(),
+        pluginRegistry,
+        proxyAgentFactory,
+        connectivityChecker,
+    });
+    // 前端静态文件服务（生产环境）
+    const __filename = fileURLToPath(import.meta.url);
+    const frontendDist = path.resolve(process.env.FRONTEND_DIST || path.join(path.dirname(__filename), "../../frontend-dist"));
+    if (existsSync(frontendDist)) {
+        app.register(fastifyStatic, {
+            root: frontendDist,
+            prefix: "/admin/",
+            wildcard: false,
+        });
+        // SPA fallback
+        app.setNotFoundHandler((request, reply) => {
+            if ((request.url.startsWith("/admin/") || request.url === "/admin") &&
+                !request.url.startsWith("/admin/api")) {
+                return reply.sendFile("index.html");
+            }
+            reply.code(HTTP_NOT_FOUND).send({ error: { message: "Not Found" } });
+        });
+    }
+    else {
+        app.log.debug(`Frontend dist not found at ${frontendDist}, skipping static serving`);
+    }
+    app.get("/health", async () => {
+        return { status: "ok" };
+    });
+    const logCleanup = scheduleLogCleanup(db, app.log);
+    const metricsAggregator = scheduleMetricsAggregator(db, app.log);
+    const dbSizeMonitor = scheduleDbSizeMonitor(db, config.DB_PATH, { log: app.log });
+    let closed = false;
+    let close = async () => {
+        if (closed)
+            return;
+        closed = true;
+        stopUpgradeChecker();
+        logCleanup.stop();
+        metricsAggregator.stop();
+        dbSizeMonitor.stop();
+        tracker.stopPushInterval();
+        tracker.closeAllClients();
+        semaphoreManager.removeAll();
+        proxyAgentFactory.invalidateAll();
+        const sessionTracker = container.resolve(SERVICE_KEYS.sessionTracker);
+        sessionTracker.stop();
+        await logFileWriter?.stop();
+        const CLOSE_GRACE_PERIOD_MS = 2_000;
+        const forceClose = typeof app.server.closeAllConnections === "function"
+            ? setTimeout(() => app.server.closeAllConnections(), CLOSE_GRACE_PERIOD_MS)
+            : null;
+        if (forceClose)
+            forceClose.unref();
+        await app.close();
+        if (forceClose)
+            clearTimeout(forceClose);
+        db.close();
+    };
+    // 文件压缩和清理任务（仅非 :memory: 模式）
+    if (!isMemoryDb) {
+        const logFileMaintenance = scheduleLogFileMaintenance(logsDir, {
+            retentionDays: getLogFileRetentionDays(db),
+            log: app.log,
+        });
+        const prevClose = close;
+        close = async () => {
+            logFileMaintenance.stop();
+            await prevClose();
+        };
+    }
+    // 绑定到 late-bound ref（供 restart API 运行时调用）
+    closeRef.fn = close;
+    return close;
+}

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
-import { FastifyInstance } from "fastify";
-import { Config } from "./config/index.js";
+import { type Config } from "./config/index.js";
 import { SemaphoreManager, AdaptiveController } from "./core/concurrency/index.js";
 import { RequestTracker } from "./core/monitor/index.js";
 import { UsageWindowTracker } from "./proxy/routing/usage-window-tracker.js";
@@ -17,7 +16,7 @@ export interface AppOptions {
  */
 export declare function initializeProviderState(db: Database.Database, semaphoreManager: SemaphoreManager, adaptiveController: AdaptiveController, tracker: RequestTracker): void;
 export declare function buildApp(options?: AppOptions): Promise<{
-    app: FastifyInstance;
+    app: import("fastify").FastifyInstance;
     db: Database.Database;
     usageWindowTracker: UsageWindowTracker;
     tracker: RequestTracker;