llm-simple-router 0.6.6 → 0.7.0

package/dist/admin/constants.d.ts

@@ -1 +1 @@
-export { HTTP_BAD_REQUEST, HTTP_CREATED, HTTP_FORBIDDEN, HTTP_NOT_FOUND, HTTP_CONFLICT, HTTP_INTERNAL_ERROR, HTTP_BAD_GATEWAY, HTTP_SERVICE_UNAVAILABLE, } from "../constants.js";
+export { HTTP_BAD_REQUEST, HTTP_CREATED, HTTP_FORBIDDEN, HTTP_NOT_FOUND, HTTP_CONFLICT, HTTP_INTERNAL_ERROR, HTTP_BAD_GATEWAY, HTTP_SERVICE_UNAVAILABLE, } from "../core/constants.js";

package/dist/admin/constants.js

@@ -1,2 +1,2 @@
-// HTTP 状态码统一从 src/constants.ts 导入，避免重复定义
-export { HTTP_BAD_REQUEST, HTTP_CREATED, HTTP_FORBIDDEN, HTTP_NOT_FOUND, HTTP_CONFLICT, HTTP_INTERNAL_ERROR, HTTP_BAD_GATEWAY, HTTP_SERVICE_UNAVAILABLE, } from "../constants.js";
+// HTTP 状态码统一从 core/constants.ts 导入，避免重复定义
+export { HTTP_BAD_REQUEST, HTTP_CREATED, HTTP_FORBIDDEN, HTTP_NOT_FOUND, HTTP_CONFLICT, HTTP_INTERNAL_ERROR, HTTP_BAD_GATEWAY, HTTP_SERVICE_UNAVAILABLE, } from "../core/constants.js";

package/dist/admin/logs.d.ts

@@ -1,7 +1,9 @@
 import { FastifyPluginCallback } from "fastify";
 import Database from "better-sqlite3";
+import type { LogFileWriter } from "../storage/log-file-writer.js";
 interface LogRoutesOptions {
     db: Database.Database;
+    logFileWriter?: LogFileWriter | null;
 }
 export declare const adminLogRoutes: FastifyPluginCallback<LogRoutesOptions>;
 export {};

package/dist/admin/logs.js

@@ -19,7 +19,7 @@ const DeleteLogsBeforeSchema = Type.Object({
 });
 const DEFAULT_LOG_VIEW = "flat";
 export const adminLogRoutes = (app, options, done) => {
-    const { db } = options;
+    const { db, logFileWriter } = options;
     app.get("/admin/api/logs", { schema: { querystring: LogQuerySchema } }, async (request, reply) => {
         const query = request.query;
         const page = parseInt(query.page || "1", 10);
@@ -47,6 +47,22 @@ export const adminLogRoutes = (app, options, done) => {
         if (!log) {
             return reply.code(HTTP_NOT_FOUND).send(apiError(API_CODE.NOT_FOUND, "Log not found"));
         }
+        // DB 字段为 null 时，从 JSONL 文件回填详情
+        const needsBackfill = log.client_request === null || log.upstream_request === null || log.upstream_response === null;
+        if (needsBackfill && logFileWriter && logFileWriter.isEnabled && log.created_at) {
+            const fileEntry = logFileWriter.read(log.id, log.created_at);
+            if (fileEntry) {
+                if (log.client_request === null && fileEntry.client_request !== null) {
+                    log.client_request = fileEntry.client_request;
+                }
+                if (log.upstream_request === null && fileEntry.upstream_request !== null) {
+                    log.upstream_request = fileEntry.upstream_request;
+                }
+                if (log.upstream_response === null && fileEntry.upstream_response !== null) {
+                    log.upstream_response = fileEntry.upstream_response;
+                }
+            }
+        }
         return reply.send(log);
     });
     app.get("/admin/api/logs/:id/children", async (request, reply) => {

package/dist/admin/providers.d.ts

@@ -1,11 +1,11 @@
 import { FastifyPluginCallback } from "fastify";
 import Database from "better-sqlite3";
-import { ProviderSemaphoreManager } from "../proxy/semaphore.js";
+import type { StateRegistry } from "../core/registry.js";
 import type { AdaptiveConcurrencyController } from "../proxy/adaptive-controller.js";
 import type { RequestTracker } from "../monitor/request-tracker.js";
 interface ProviderRoutesOptions {
     db: Database.Database;
-    semaphoreManager?: ProviderSemaphoreManager;
+    stateRegistry?: StateRegistry;
     tracker?: RequestTracker;
     adaptiveController?: AdaptiveConcurrencyController;
 }

package/dist/admin/providers.js

@@ -95,7 +95,7 @@ const UpdateProviderSchema = Type.Object({
     adaptive_enabled: Type.Optional(Type.Integer({ minimum: 0, maximum: 1 })),
 });
 export const adminProviderRoutes = (app, options, done) => {
-    const { db, semaphoreManager, tracker, adaptiveController } = options;
+    const { db, stateRegistry, tracker, adaptiveController } = options;
     app.get("/admin/api/providers", async (_request, reply) => {
         const encryptionKey = getSetting(db, "encryption_key");
         const providers = getAllProviders(db);
@@ -114,7 +114,7 @@ export const adminProviderRoutes = (app, options, done) => {
                 queue_timeout_ms: s.queue_timeout_ms,
                 max_queue_size: s.max_queue_size,
                 adaptive_enabled: s.adaptive_enabled,
-                concurrency_status: semaphoreManager?.getStatus(s.id) ?? { active: 0, queued: 0 },
+                concurrency_status: stateRegistry?.getProviderStatus(s.id) ?? { active: 0, queued: 0 },
                 created_at: s.created_at,
                 updated_at: s.updated_at,
             };
@@ -148,11 +148,14 @@ export const adminProviderRoutes = (app, options, done) => {
         if (contextOverrides.length > 0) {
             setModelInfoForProvider(db, id, contextOverrides.map(o => ({ model_name: o.name, context_window: o.context_window })));
         }
-        semaphoreManager?.updateConfig(id, {
-            maxConcurrency: body.max_concurrency ?? PROVIDER_CONCURRENCY_DEFAULTS.max_concurrency,
-            queueTimeoutMs: body.queue_timeout_ms ?? PROVIDER_CONCURRENCY_DEFAULTS.queue_timeout_ms,
-            maxQueueSize: body.max_queue_size ?? PROVIDER_CONCURRENCY_DEFAULTS.max_queue_size,
-        });
+        // 当 adaptive 启用时，由 syncProvider 全权管理信号量（避免重复调用 updateConfig）
+        if (!isAdaptiveEnabled) {
+            stateRegistry?.updateProviderConcurrency(id, {
+                maxConcurrency: body.max_concurrency ?? PROVIDER_CONCURRENCY_DEFAULTS.max_concurrency,
+                queueTimeoutMs: body.queue_timeout_ms ?? PROVIDER_CONCURRENCY_DEFAULTS.queue_timeout_ms,
+                maxQueueSize: body.max_queue_size ?? PROVIDER_CONCURRENCY_DEFAULTS.max_queue_size,
+            });
+        }
         adaptiveController?.syncProvider(id, {
             adaptive_enabled: isAdaptiveEnabled,
             max_concurrency: body.max_concurrency ?? PROVIDER_CONCURRENCY_DEFAULTS.max_concurrency,
@@ -213,21 +216,31 @@ export const adminProviderRoutes = (app, options, done) => {
         let cascade;
         if (existing.is_active === 1 && body.is_active === 0) {
             cascade = cascadeProviderDisable(db, id);
+            // 禁用时清理信号量和自适应并发，避免排队请求悬挂
+            stateRegistry?.removeProvider(id);
+            adaptiveController?.remove(id);
         }
-        if (body.max_concurrency !== undefined || body.queue_timeout_ms !== undefined || body.max_queue_size !== undefined) {
-            semaphoreManager?.updateConfig(id, {
-                maxConcurrency: updated.max_concurrency,
-                queueTimeoutMs: updated.queue_timeout_ms,
-                maxQueueSize: updated.max_queue_size,
-            });
-        }
-        if (body.adaptive_enabled !== undefined || body.max_concurrency !== undefined || body.queue_timeout_ms !== undefined || body.max_queue_size !== undefined) {
+        // 重新启用时重建信号量和自适应并发
+        const concurrencyChanged = body.max_concurrency !== undefined || body.queue_timeout_ms !== undefined || body.max_queue_size !== undefined;
+        const adaptiveChanged = body.adaptive_enabled !== undefined;
+        const reenabled = existing.is_active === 0 && body.is_active === 1;
+        const needsSync = concurrencyChanged || adaptiveChanged || reenabled;
+        if (needsSync) {
+            // adaptive 同步：syncProvider 内部根据 adaptive_enabled 决定是 init+syncToSemaphore 还是 remove+updateConfig
             adaptiveController?.syncProvider(id, {
                 adaptive_enabled: updated.adaptive_enabled,
                 max_concurrency: updated.max_concurrency,
                 queue_timeout_ms: updated.queue_timeout_ms,
                 max_queue_size: updated.max_queue_size,
             });
+            // 非 adaptive 模式下手动同步信号量（adaptive 启用时由 syncProvider 内部管理）
+            if (!updated.adaptive_enabled) {
+                stateRegistry?.updateProviderConcurrency(id, {
+                    maxConcurrency: updated.max_concurrency,
+                    queueTimeoutMs: updated.queue_timeout_ms,
+                    maxQueueSize: updated.max_queue_size,
+                });
+            }
         }
         tracker?.updateProviderConfig(id, {
             name: body.name ?? existing.name,
@@ -292,7 +305,7 @@ export const adminProviderRoutes = (app, options, done) => {
             }
         }
         deleteProvider(db, id);
-        semaphoreManager?.remove(id);
+        stateRegistry?.removeProvider(id);
         adaptiveController?.remove(id);
         tracker?.removeProviderConfig(id);
         return reply.send({ success: true });

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

@@ -1,7 +1,9 @@
 import { FastifyPluginCallback } from "fastify";
 import Database from "better-sqlite3";
+import type { StateRegistry } from "../core/registry.js";
 interface ProxyEnhancementOptions {
     db: Database.Database;
+    stateRegistry?: StateRegistry;
 }
 export declare const adminProxyEnhancementRoutes: FastifyPluginCallback<ProxyEnhancementOptions>;
 export {};

package/dist/admin/proxy-enhancement.js

@@ -1,6 +1,5 @@
 import { Type } from "@sinclair/typebox";
 import { setSetting } from "../db/settings.js";
-import { loadEnhancementConfig } from "../proxy/enhancement-config.js";
 const UpdateProxyEnhancementSchema = Type.Object({
     claude_code_enabled: Type.Boolean(),
     tool_call_loop_enabled: Type.Boolean(),
@@ -11,16 +10,11 @@ const SessionParamsSchema = Type.Object({
     sessionId: Type.String(),
 });
 import { getSessionStates, getSessionHistory, } from "../db/session-states.js";
-import { modelState } from "../proxy/model-state.js";
 export const adminProxyEnhancementRoutes = (app, options, done) => {
-    const { db } = options;
+    const { db, stateRegistry } = options;
     app.get("/admin/api/proxy-enhancement", async (_request, reply) => {
-        const config = loadEnhancementConfig(db);
-        return reply.send({
-            claude_code_enabled: config.claude_code_enabled,
-            tool_call_loop_enabled: config.tool_call_loop_enabled,
-            stream_loop_enabled: config.stream_loop_enabled,
-        });
+        const config = stateRegistry?.getEnhancementConfig() ?? { claude_code_enabled: false, tool_call_loop_enabled: false, stream_loop_enabled: false };
+        return reply.send(config);
     });
     app.put("/admin/api/proxy-enhancement", { schema: { body: UpdateProxyEnhancementSchema } }, async (request, reply) => {
         const body = request.body;
@@ -43,7 +37,7 @@ export const adminProxyEnhancementRoutes = (app, options, done) => {
     });
     app.delete("/admin/api/session-states/:keyId/:sessionId", { schema: { params: SessionParamsSchema } }, async (req, reply) => {
         const { keyId, sessionId } = req.params;
-        modelState.delete(keyId, sessionId);
+        stateRegistry?.deleteModelState(keyId, sessionId);
         return reply.send({ success: true });
     });
     done();

package/dist/admin/retry-rules.d.ts

@@ -1,9 +1,9 @@
 import { FastifyPluginCallback } from "fastify";
 import Database from "better-sqlite3";
-import { RetryRuleMatcher } from "../proxy/retry-rules.js";
+import type { StateRegistry } from "../core/registry.js";
 interface RetryRuleRoutesOptions {
     db: Database.Database;
-    matcher: RetryRuleMatcher | null;
+    stateRegistry?: StateRegistry;
 }
 export declare const adminRetryRuleRoutes: FastifyPluginCallback<RetryRuleRoutesOptions>;
 export {};

package/dist/admin/retry-rules.js

@@ -34,12 +34,8 @@ function validateBodyPattern(pattern) {
         return "Invalid body_pattern regex";
     }
 }
-function refreshMatcher(matcher, db) {
-    if (matcher)
-        matcher.load(db);
-}
 export const adminRetryRuleRoutes = (app, options, done) => {
-    const { db, matcher } = options;
+    const { db, stateRegistry } = options;
     app.get("/admin/api/retry-rules", async (_request, reply) => {
         const rules = getAllRetryRules(db);
         return reply.send(rules);
@@ -60,7 +56,7 @@ export const adminRetryRuleRoutes = (app, options, done) => {
             max_retries: body.max_retries ?? DEFAULT_MAX_RETRIES,
             max_delay_ms: body.max_delay_ms ?? DEFAULT_MAX_DELAY_MS,
         });
-        refreshMatcher(matcher, db);
+        stateRegistry?.refreshRetryRules();
         return reply.code(HTTP_CREATED).send({ id });
     });
     app.put("/admin/api/retry-rules/:id", { schema: { body: UpdateRetryRuleSchema } }, async (request, reply) => {
@@ -89,7 +85,7 @@ export const adminRetryRuleRoutes = (app, options, done) => {
         if (body.max_delay_ms !== undefined)
             fields.max_delay_ms = body.max_delay_ms;
         updateRetryRule(db, id, fields);
-        refreshMatcher(matcher, db);
+        stateRegistry?.refreshRetryRules();
         return reply.send({ success: true });
     });
     app.delete("/admin/api/retry-rules/:id", async (request, reply) => {
@@ -98,7 +94,7 @@ export const adminRetryRuleRoutes = (app, options, done) => {
         if (!existing)
             return reply.code(HTTP_NOT_FOUND).send(apiError(API_CODE.NOT_FOUND, "Retry rule not found"));
         deleteRetryRule(db, id);
-        refreshMatcher(matcher, db);
+        stateRegistry?.refreshRetryRules();
         return reply.send({ success: true });
     });
     done();

package/dist/admin/routes.d.ts

@@ -1,15 +1,15 @@
 import { FastifyPluginCallback } from "fastify";
 import Database from "better-sqlite3";
-import { RetryRuleMatcher } from "../proxy/retry-rules.js";
+import type { StateRegistry } from "../core/registry.js";
 import type { RequestTracker } from "../monitor/request-tracker.js";
-import { ProviderSemaphoreManager } from "../proxy/semaphore.js";
 import type { AdaptiveConcurrencyController } from "../proxy/adaptive-controller.js";
 interface AdminRoutesOptions {
     db: Database.Database;
-    matcher: RetryRuleMatcher | null;
+    stateRegistry: StateRegistry;
     tracker?: RequestTracker;
-    semaphoreManager?: ProviderSemaphoreManager;
     adaptiveController?: AdaptiveConcurrencyController;
+    logFileWriter?: import("../storage/log-file-writer.js").LogFileWriter | null;
+    logsDir?: string;
 }
 export declare const adminRoutes: FastifyPluginCallback<AdminRoutesOptions>;
 export {};

package/dist/admin/routes.js

@@ -21,19 +21,19 @@ export const adminRoutes = (app, options, done) => {
     app.register(adminSetupRoutes, { db: options.db });
     app.register(adminAuthPlugin, { db: options.db });
     app.register(adminLoginRoutes, { db: options.db });
-    app.register(adminProviderRoutes, { db: options.db, semaphoreManager: options.semaphoreManager, tracker: options.tracker, adaptiveController: options.adaptiveController });
+    app.register(adminProviderRoutes, { db: options.db, stateRegistry: options.stateRegistry, tracker: options.tracker, adaptiveController: options.adaptiveController });
     app.register(adminMappingRoutes, { db: options.db });
     app.register(adminGroupRoutes, { db: options.db });
     app.register(adminScheduleRoutes, { db: options.db });
-    app.register(adminRetryRuleRoutes, { db: options.db, matcher: options.matcher });
-    app.register(adminLogRoutes, { db: options.db });
+    app.register(adminRetryRuleRoutes, { db: options.db, stateRegistry: options.stateRegistry });
+    app.register(adminLogRoutes, { db: options.db, logFileWriter: options.logFileWriter });
     app.register(adminRouterKeyRoutes, { db: options.db });
     app.register(adminStatsRoutes, { db: options.db });
     app.register(adminMetricsRoutes, { db: options.db });
-    app.register(adminProxyEnhancementRoutes, { db: options.db });
+    app.register(adminProxyEnhancementRoutes, { db: options.db, stateRegistry: options.stateRegistry });
     app.register(adminMonitorRoutes, { tracker: options.tracker });
-    app.register(adminSettingsRoutes, { db: options.db });
-    app.register(adminImportExportRoutes, { db: options.db, matcher: options.matcher, semaphoreManager: options.semaphoreManager });
+    app.register(adminSettingsRoutes, { db: options.db, logsDir: options.logsDir });
+    app.register(adminImportExportRoutes, { db: options.db, stateRegistry: options.stateRegistry });
     app.register(adminRecommendedRoutes, { db: options.db });
     app.register(adminUsageRoutes, { db: options.db });
     app.register(adminUpgradeRoutes, { db: options.db });

package/dist/admin/settings-import-export.d.ts

@@ -1,11 +1,9 @@
 import { FastifyPluginCallback } from "fastify";
 import Database from "better-sqlite3";
-import { RetryRuleMatcher } from "../proxy/retry-rules.js";
-import { ProviderSemaphoreManager } from "../proxy/semaphore.js";
+import type { StateRegistry } from "../core/registry.js";
 interface ImportExportOptions {
     db: Database.Database;
-    matcher: RetryRuleMatcher | null;
-    semaphoreManager?: ProviderSemaphoreManager;
+    stateRegistry: StateRegistry;
 }
 export declare const adminImportExportRoutes: FastifyPluginCallback<ImportExportOptions>;
 export {};

package/dist/admin/settings-import-export.js

@@ -1,8 +1,6 @@
 import { createHash } from "crypto";
-import { getAllProviders, PROVIDER_CONCURRENCY_DEFAULTS } from "../db/index.js";
 import { encrypt, decrypt } from "../utils/crypto.js";
 import { getSetting } from "../db/settings.js";
-import { modelState } from "../proxy/model-state.js";
 import { API_CODE, apiError } from "./api-response.js";
 const CONFIG_TABLES = [
     "providers",
@@ -11,6 +9,9 @@ const CONFIG_TABLES = [
     "router_keys",
     "settings",
     "session_model_states",
+    "schedules",
+    "provider_model_info",
+    "session_model_history",
 ];
 // settings 表按 key 列的值过滤，不覆盖本地安全敏感配置
 const PROTECTED_SETTING_KEYS = new Set(["admin_password_hash", "jwt_secret", "encryption_key"]);
@@ -19,7 +20,7 @@ const ISO_DATE_LENGTH = 10;
 const BAD_REQUEST = 400;
 const KEY_PREFIX_LENGTH = 8;
 export const adminImportExportRoutes = (app, options, done) => {
-    const { db, matcher, semaphoreManager } = options;
+    const { db, stateRegistry } = options;
     app.get("/admin/api/settings/export", async (_request, reply) => {
         const encryptionKey = getSetting(db, "encryption_key");
         const data = {};
@@ -123,22 +124,11 @@ export const adminImportExportRoutes = (app, options, done) => {
             db.pragma(`foreign_keys = ${prevFk}`);
         })();
         // 导入成功后刷新内存缓存
-        if (matcher)
-            matcher.load(db);
-        if (semaphoreManager) {
-            // 清除旧的 semaphore 配置，按导入后的 providers 表重建
-            semaphoreManager.removeAll();
-            const providers = getAllProviders(db);
-            for (const p of providers) {
-                semaphoreManager.updateConfig(p.id, {
-                    maxConcurrency: p.max_concurrency ?? PROVIDER_CONCURRENCY_DEFAULTS.max_concurrency,
-                    queueTimeoutMs: p.queue_timeout_ms ?? PROVIDER_CONCURRENCY_DEFAULTS.queue_timeout_ms,
-                    maxQueueSize: p.max_queue_size ?? PROVIDER_CONCURRENCY_DEFAULTS.max_queue_size,
-                });
-            }
-        }
-        // session_model_states 已通过 DB 导入，内存缓存会在读取时自然回填
-        modelState.clearAll();
+        stateRegistry.refreshRetryRules();
+        // 清除旧的 semaphore/adaptive/tracker 配置，按导入后的 DB 数据全量重建
+        stateRegistry.removeAllProviders();
+        stateRegistry.clearModelState();
+        stateRegistry.reinitializeProviders();
         return reply.send(counts);
     });
     done();

package/dist/admin/settings.d.ts

@@ -2,6 +2,7 @@ import { FastifyPluginCallback } from "fastify";
 import Database from "better-sqlite3";
 interface SettingsOptions {
     db: Database.Database;
+    logsDir?: string;
 }
 export declare const adminSettingsRoutes: FastifyPluginCallback<SettingsOptions>;
 export {};

package/dist/admin/settings.js

@@ -1,8 +1,10 @@
+import { statSync, readdirSync } from "node:fs";
+import { join } from "node:path";
 import { getLogRetentionDays, setLogRetentionDays, getDbMaxSizeMb, setDbMaxSizeMb, getLogTableMaxSizeMb, setLogTableMaxSizeMb, getSetting, } from "../db/settings.js";
 import { HTTP_BAD_REQUEST } from "./constants.js";
 import { API_CODE, apiError } from "./api-response.js";
 export const adminSettingsRoutes = (app, options, done) => {
-    const { db } = options;
+    const { db, logsDir } = options;
     app.get("/admin/api/settings/log-retention", async () => {
         return { days: getLogRetentionDays(db) };
     });
@@ -25,8 +27,17 @@ export const adminSettingsRoutes = (app, options, done) => {
             }
             catch { /* eslint-disable-line taste/no-silent-catch -- 损坏的缓存值，回退默认 */ }
         }
+        // 计算日志文件目录大小
+        let logFileBytes = 0;
+        if (logsDir) {
+            try {
+                logFileBytes = calcDirSize(logsDir);
+            }
+            catch { /* eslint-disable-line taste/no-silent-catch -- 目录可能不存在 */ }
+        }
         return {
             ...sizeInfo,
+            logFileBytes,
             thresholds: {
                 dbMaxSizeMb: getDbMaxSizeMb(db),
                 logTableMaxSizeMb: getLogTableMaxSizeMb(db),
@@ -54,3 +65,20 @@ export const adminSettingsRoutes = (app, options, done) => {
     });
     done();
 };
+/** 递归计算目录下所有文件的总大小（字节） */
+function calcDirSize(dirPath) {
+    let total = 0;
+    for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
+        const fullPath = join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            total += calcDirSize(fullPath);
+        }
+        else if (entry.isFile()) {
+            try {
+                total += statSync(fullPath).size;
+            }
+            catch { /* 文件可能刚被删除 */ }
+        }
+    }
+    return total;
+}

package/dist/admin/upgrade.js

@@ -5,7 +5,7 @@ import { reloadConfig } from '../config/recommended.js';
 import { execSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import { HTTP_BAD_REQUEST, HTTP_INTERNAL_ERROR } from '../constants.js';
+import { HTTP_BAD_REQUEST, HTTP_INTERNAL_ERROR } from '../core/constants.js';
 import { API_CODE, apiError } from './api-response.js';
 const GITHUB_CONFIG_BASE = 'https://raw.githubusercontent.com/zhushanwen321/llm-simple-router/main/config';
 const GITEE_CONFIG_BASE = 'https://gitee.com/zzzzswszzzz/llm-simple-router/raw/main/config';

package/dist/{constants.d.ts → core/constants.d.ts}

@@ -3,10 +3,13 @@ export declare const HTTP_CREATED = 201;
 export declare const HTTP_FORBIDDEN = 403;
 export declare const HTTP_NOT_FOUND = 404;
 export declare const HTTP_CONFLICT = 409;
+export declare const HTTP_UNPROCESSABLE_ENTITY = 422;
 export declare const HTTP_INTERNAL_ERROR = 500;
 export declare const HTTP_BAD_GATEWAY = 502;
-export declare const HTTP_UNPROCESSABLE_ENTITY = 422;
 export declare const HTTP_SERVICE_UNAVAILABLE = 503;
 export declare const PROXY_API_TYPES: Record<string, string>;
 export declare function getProxyApiType(url: string): string | null;
 export declare const MS_PER_SECOND = 1000;
+export declare const UPSTREAM_SUCCESS = 200;
+/** 过滤掉不应转发给下游的 hop-by-hop headers */
+export declare function filterHeaders(raw: import("./types.js").RawHeaders): Record<string, string>;

package/dist/{constants.js → core/constants.js}

@@ -1,12 +1,13 @@
+// src/core/constants.ts
 // HTTP 状态码常量 — 全局唯一来源
 export const HTTP_BAD_REQUEST = 400;
 export const HTTP_CREATED = 201;
 export const HTTP_FORBIDDEN = 403;
 export const HTTP_NOT_FOUND = 404;
 export const HTTP_CONFLICT = 409;
+export const HTTP_UNPROCESSABLE_ENTITY = 422;
 export const HTTP_INTERNAL_ERROR = 500;
 export const HTTP_BAD_GATEWAY = 502;
-export const HTTP_UNPROCESSABLE_ENTITY = 422;
 export const HTTP_SERVICE_UNAVAILABLE = 503;
 // api_type 路由映射：proxy path → api type，用于全局 hook/errorHandler 中识别代理请求
 export const PROXY_API_TYPES = {
@@ -19,3 +20,22 @@ export function getProxyApiType(url) {
     return PROXY_API_TYPES[path] ?? null;
 }
 export const MS_PER_SECOND = 1000;
+// 上游成功状态码
+export const UPSTREAM_SUCCESS = 200;
+/** 过滤掉不应转发给下游的 hop-by-hop headers */
+const SKIP_DOWNSTREAM = new Set([
+    "content-length",
+    "transfer-encoding",
+    "connection",
+    "keep-alive",
+]);
+/** 过滤掉不应转发给下游的 hop-by-hop headers */
+export 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/core/container.d.ts

@@ -0,0 +1,31 @@
+/** 服务键常量 — 避免魔法字符串，编译期类型保护 */
+export declare const SERVICE_KEYS: {
+    readonly db: "db";
+    readonly matcher: "matcher";
+    readonly semaphoreManager: "semaphoreManager";
+    readonly tracker: "tracker";
+    readonly usageWindowTracker: "usageWindowTracker";
+    readonly sessionTracker: "sessionTracker";
+    readonly adaptiveController: "adaptiveController";
+    readonly logFileWriter: "logFileWriter";
+};
+export type ServiceKey = (typeof SERVICE_KEYS)[keyof typeof SERVICE_KEYS];
+/**
+ * 轻量服务容器 — 懒加载单例工厂注册表。
+ *
+ * 用法：
+ *   const c = new ServiceContainer();
+ *   c.register(SERVICE_KEYS.db, () => db);
+ *   c.register(SERVICE_KEYS.tracker, (c) => new RequestTracker(c.resolve(SERVICE_KEYS.db)));
+ *   const tracker = c.resolve<RequestTracker>(SERVICE_KEYS.tracker);
+ *
+ * 注册的工厂最多执行一次（惰性求值 + 缓存）。
+ */
+export declare class ServiceContainer {
+    private readonly factories;
+    private readonly cache;
+    /** 注册服务工厂。重复注册同一 key 会覆盖（但已缓存的实例不会被清除）。 */
+    register<T>(key: string, factory: (c: ServiceContainer) => T): void;
+    /** 获取服务实例。首次调用时执行工厂并缓存。 */
+    resolve<T>(key: string): T;
+}

package/dist/core/container.js

@@ -0,0 +1,41 @@
+/** 服务键常量 — 避免魔法字符串，编译期类型保护 */
+export const SERVICE_KEYS = {
+    db: "db",
+    matcher: "matcher",
+    semaphoreManager: "semaphoreManager",
+    tracker: "tracker",
+    usageWindowTracker: "usageWindowTracker",
+    sessionTracker: "sessionTracker",
+    adaptiveController: "adaptiveController",
+    logFileWriter: "logFileWriter",
+};
+/**
+ * 轻量服务容器 — 懒加载单例工厂注册表。
+ *
+ * 用法：
+ *   const c = new ServiceContainer();
+ *   c.register(SERVICE_KEYS.db, () => db);
+ *   c.register(SERVICE_KEYS.tracker, (c) => new RequestTracker(c.resolve(SERVICE_KEYS.db)));
+ *   const tracker = c.resolve<RequestTracker>(SERVICE_KEYS.tracker);
+ *
+ * 注册的工厂最多执行一次（惰性求值 + 缓存）。
+ */
+export class ServiceContainer {
+    factories = new Map();
+    cache = new Map();
+    /** 注册服务工厂。重复注册同一 key 会覆盖（但已缓存的实例不会被清除）。 */
+    register(key, factory) {
+        this.factories.set(key, factory);
+    }
+    /** 获取服务实例。首次调用时执行工厂并缓存。 */
+    resolve(key) {
+        if (this.cache.has(key))
+            return this.cache.get(key);
+        const factory = this.factories.get(key);
+        if (!factory)
+            throw new Error(`Service not registered: "${key}"`);
+        const instance = factory(this);
+        this.cache.set(key, instance);
+        return instance;
+    }
+}

package/dist/core/errors.d.ts

@@ -0,0 +1,26 @@
+import type { TransportResult, ResilienceAttempt } from "./types.js";
+/**
+ * Provider 并发队列已满时抛出。
+ */
+export declare class SemaphoreQueueFullError extends Error {
+    readonly providerId: string;
+    constructor(providerId: string);
+}
+/**
+ * Provider 并发等待超时时抛出。
+ */
+export declare class SemaphoreTimeoutError extends Error {
+    readonly providerId: string;
+    readonly timeoutMs: number;
+    constructor(providerId: string, timeoutMs: number);
+}
+/**
+ * 跨 provider failover 时由 ResilienceLayer 抛出，
+ * orchestrator 捕获后释放当前信号量并获取新 provider 的信号量。
+ */
+export declare class ProviderSwitchNeeded extends Error {
+    readonly targetProviderId: string;
+    readonly attempts?: ResilienceAttempt[] | undefined;
+    readonly lastResult?: TransportResult | undefined;
+    constructor(targetProviderId: string, attempts?: ResilienceAttempt[] | undefined, lastResult?: TransportResult | undefined);
+}

package/dist/core/errors.js

@@ -0,0 +1,42 @@
+// src/core/errors.ts
+// 被多目录共享的错误类型（从 proxy/semaphore.ts 和 proxy/types.ts 移出）
+/**
+ * Provider 并发队列已满时抛出。
+ */
+export class SemaphoreQueueFullError extends Error {
+    providerId;
+    constructor(providerId) {
+        super(`Provider '${providerId}' concurrency queue is full`);
+        this.providerId = providerId;
+        this.name = "SemaphoreQueueFullError";
+    }
+}
+/**
+ * Provider 并发等待超时时抛出。
+ */
+export class SemaphoreTimeoutError extends Error {
+    providerId;
+    timeoutMs;
+    constructor(providerId, timeoutMs) {
+        super(`Provider '${providerId}' concurrency wait timeout (${timeoutMs}ms)`);
+        this.providerId = providerId;
+        this.timeoutMs = timeoutMs;
+        this.name = "SemaphoreTimeoutError";
+    }
+}
+/**
+ * 跨 provider failover 时由 ResilienceLayer 抛出，
+ * orchestrator 捕获后释放当前信号量并获取新 provider 的信号量。
+ */
+export class ProviderSwitchNeeded extends Error {
+    targetProviderId;
+    attempts;
+    lastResult;
+    constructor(targetProviderId, attempts, lastResult) {
+        super(`Provider switch needed: ${targetProviderId}`);
+        this.targetProviderId = targetProviderId;
+        this.attempts = attempts;
+        this.lastResult = lastResult;
+        this.name = "ProviderSwitchNeeded";
+    }
+}