llm-simple-router 0.10.5 → 0.10.7

package/dist/config/model-context.d.ts

@@ -16,5 +16,7 @@ export declare const OVERFLOW_THRESHOLD = 1000000;
 export declare function lookupContextWindow(modelName: string): number;
 /** 标准化 patch 名称：连字符 → 下划线 */
 export declare function normalizePatchName(name: string): string;
+/** 清除缓存（仅供测试使用） */
+export declare function clearModelsCache(): void;
 export declare function parseModels(raw: string): ModelEntry[];
 export declare function buildModelInfoList(modelEntries: ModelEntry[], overrides: Map<string, number>): ModelInfo[];

package/dist/config/model-context.js

@@ -104,14 +104,23 @@ const PATCH_ID_MIGRATION = {
     non_ds_tools: "thinking_consistency",
     cache_control: "thinking_consistency",
 };
+// parseModels 缓存，key 为 raw 字符串引用
+const modelsCache = new Map();
+/** 清除缓存（仅供测试使用） */
+export function clearModelsCache() {
+    modelsCache.clear();
+}
 export function parseModels(raw) {
     if (!raw)
         return [];
+    const cached = modelsCache.get(raw);
+    if (cached)
+        return cached;
     try {
         const parsed = JSON.parse(raw);
         if (!Array.isArray(parsed))
             return [];
-        return parsed.map((item) => {
+        const result = parsed.map((item) => {
             if (typeof item === 'string') {
                 return item ? { name: item, patches: [] } : null;
             }
@@ -124,14 +133,16 @@ export function parseModels(raw) {
             const rawPatches = (obj.patches ?? []).map(normalizePatchName);
             const migrated = rawPatches.map(p => PATCH_ID_MIGRATION[p] ?? p);
             const patches = [...new Set(migrated)];
-            const result = {
+            const entry = {
                 name: modelName,
                 patches,
             };
             if (obj.stream_timeout_ms != null)
-                result.stream_timeout_ms = obj.stream_timeout_ms;
-            return result;
+                entry.stream_timeout_ms = obj.stream_timeout_ms;
+            return entry;
         }).filter((e) => e !== null);
+        modelsCache.set(raw, result);
+        return result;
     }
     catch {
         return [];

package/dist/core/concurrency/adaptive-controller.d.ts

@@ -18,6 +18,8 @@ export declare class AdaptiveController {
     onRequestComplete(providerId: string, result: AdaptiveResult): void;
     getStatus(providerId: string): AdaptiveState | undefined;
     syncProvider(providerId: string, p: ProviderConcurrencyParams): void;
+    /** 根据当前位置和容量推导行为参数，实现水位梯度控制 */
+    private deriveProfile;
     private transitionSuccess;
     private transitionFailure;
     private syncToSemaphore;

package/dist/core/concurrency/adaptive-controller.js

@@ -1,11 +1,18 @@
-const SUCCESS_THRESHOLD = 3;
-const FAILURE_THRESHOLD = 3;
-const DECREASE_STEP = 2;
-const COOLDOWN_MS = 30_000;
 const RATE_LIMIT_STATUS = 429;
-const HALF_DIVISOR = 2;
 const HTTP_SERVER_ERROR_MIN = 500;
 const ADAPTIVE_MIN = 1;
+// deriveProfile 参数常量
+const CAPACITY_LOG_BASE = 7;
+const CLIMB_BASE = 2;
+const CLIMB_CAPACITY_WEIGHT = 2;
+const CLIMB_LEVEL_WEIGHT = 2;
+const DROP_BASE = 5;
+const DROP_CAPACITY_WEIGHT = 2;
+const DROP_LEVEL_WEIGHT = 2;
+const KEEP_RATIO_MIN = 0.5;
+const COOLDOWN_BASE_MS = 10_000;
+const COOLDOWN_LEVEL_MS = 10_000;
+const SAFE_ZONE_DIVISOR = 2;
 export class AdaptiveController {
     semaphoreControl;
     logger;
@@ -19,7 +26,7 @@ export class AdaptiveController {
         this.entries.set(providerId, {
             state: {
                 currentLimit: initialLimit,
-                probeActive: true,
+                limitReached: false,
                 consecutiveSuccesses: 0,
                 consecutiveFailures: 0,
                 cooldownUntil: 0,
@@ -78,26 +85,40 @@ export class AdaptiveController {
             });
         }
     }
+    /** 根据当前位置和容量推导行为参数，实现水位梯度控制 */
+    deriveProfile(currentLimit, max) {
+        const level = Math.min(1, currentLimit / max);
+        const capacity = Math.min(1, Math.log2(max) / CAPACITY_LOG_BASE);
+        return {
+            climbThreshold: Math.max(CLIMB_BASE, Math.round(CLIMB_BASE + capacity * CLIMB_CAPACITY_WEIGHT + level * CLIMB_LEVEL_WEIGHT)),
+            dropThreshold: Math.max(1, Math.round(DROP_BASE - capacity * DROP_CAPACITY_WEIGHT - level * DROP_LEVEL_WEIGHT)),
+            keepRatio: currentLimit > 1 ? 1 - 1 / currentLimit : KEEP_RATIO_MIN,
+            cooldownMs: Math.round(COOLDOWN_BASE_MS + level * COOLDOWN_LEVEL_MS),
+        };
+    }
     transitionSuccess(providerId, entry, result) {
         const s = entry.state;
-        s.consecutiveSuccesses++;
-        s.consecutiveFailures = 0;
+        // 冷却期内不累计成功计数
         if (Date.now() < s.cooldownUntil)
             return;
-        if (s.consecutiveSuccesses >= SUCCESS_THRESHOLD) {
-            if (!s.probeActive) {
-                s.probeActive = true;
-                s.consecutiveSuccesses = 0;
-                const effective = Math.min(Math.max(s.currentLimit + 1, ADAPTIVE_MIN), entry.max);
-                this.logger?.info?.({ providerId, requestId: result.requestId, prevLimit: s.currentLimit, newLimit: s.currentLimit, effectiveLimit: effective, action: "probe_open" }, "Adaptive: probe window opened");
-            }
-            else {
+        s.consecutiveSuccesses++;
+        s.consecutiveFailures = 0;
+        // 利用率信号：请求排过队说明 limit 被实际触及
+        if (result.wasQueued) {
+            s.limitReached = true;
+        }
+        const profile = this.deriveProfile(s.currentLimit, entry.max);
+        if (s.consecutiveSuccesses >= profile.climbThreshold) {
+            // 利用率门控：安全区(limit <= max/2) 或 limitReached 才爬升
+            const safeZone = s.currentLimit <= Math.floor(entry.max / SAFE_ZONE_DIVISOR);
+            if (safeZone || s.limitReached) {
                 const prevLimit = s.currentLimit;
                 s.currentLimit = Math.min(s.currentLimit + 1, entry.max);
-                s.consecutiveSuccesses = 0;
-                const effective = Math.min(Math.max(s.currentLimit + 1, ADAPTIVE_MIN), entry.max);
-                this.logger?.info?.({ providerId, requestId: result.requestId, prevLimit, newLimit: s.currentLimit, effectiveLimit: effective, max: entry.max, action: "limit_increased" }, "Adaptive: limit increased by 1");
+                this.logger?.info?.({ providerId, requestId: result.requestId, prevLimit, newLimit: s.currentLimit, action: "limit_increased" }, "Adaptive: limit increased by 1");
             }
+            // 无论是否爬升，都重置计数周期
+            s.consecutiveSuccesses = 0;
+            s.limitReached = false;
             this.syncToSemaphore(providerId);
         }
     }
@@ -105,10 +126,10 @@ export class AdaptiveController {
         const statusCode = result.statusCode;
         // 过滤非并发相关的错误：
         // - retryRuleMatched=true → resilience 层根据重试规则判断为可重试的失败，计入退避
-        // - 429: 限流，计入退避
+        // - 429: 限流，计入退避（含信号量超时/队列满，orchestrator 统一传入 429）
         // - 5xx: 服务端错误（可能过载），计入退避
         // - undefined: 网络异常，计入退避
-        // - 2xx/4xx 且 retryRuleMatched!=true: 非并发问题（如 upstream 200 body error 但未命中重试规则），不触发退避
+        // - 2xx/4xx 且 retryRuleMatched!=true: 非并发问题，不触发退避
         if (!result.retryRuleMatched && statusCode !== undefined && statusCode !== RATE_LIMIT_STATUS && statusCode < HTTP_SERVER_ERROR_MIN) {
             this.logger?.debug?.({ providerId, statusCode, action: "failure_ignored" }, "Adaptive: non-concurrency failure ignored");
             return;
@@ -117,31 +138,32 @@ export class AdaptiveController {
         s.consecutiveFailures++;
         s.consecutiveSuccesses = 0;
         if (statusCode === RATE_LIMIT_STATUS) {
+            // 429 和信号量错误：丢 1 格 + 冷却
+            const profile = this.deriveProfile(s.currentLimit, entry.max);
             const prevLimit = s.currentLimit;
-            s.currentLimit = Math.max(Math.floor(s.currentLimit / HALF_DIVISOR), ADAPTIVE_MIN);
-            s.probeActive = false;
-            s.cooldownUntil = Date.now() + COOLDOWN_MS;
+            s.currentLimit = Math.max(Math.floor(s.currentLimit * profile.keepRatio), ADAPTIVE_MIN);
+            s.cooldownUntil = Date.now() + profile.cooldownMs;
             s.consecutiveFailures = 0;
             this.syncToSemaphore(providerId);
-            this.logger?.warn?.({ providerId, requestId: result.requestId, prevLimit, newLimit: s.currentLimit, cooldownMs: COOLDOWN_MS, statusCode, action: "rate_limit_backoff" }, "Adaptive: 429 rate limit, halved concurrency and entered cooldown");
+            this.logger?.warn?.({ providerId, requestId: result.requestId, prevLimit, newLimit: s.currentLimit, cooldownMs: profile.cooldownMs, statusCode, action: "rate_limit_backoff" }, "Adaptive: 429/semaphore, lost 1 slot and entered cooldown");
         }
-        else if (s.consecutiveFailures >= FAILURE_THRESHOLD) {
-            const prevLimit = s.currentLimit;
-            s.currentLimit = Math.max(s.currentLimit - DECREASE_STEP, ADAPTIVE_MIN);
-            s.probeActive = false;
-            s.consecutiveFailures = 0;
-            this.syncToSemaphore(providerId);
-            this.logger?.warn?.({ providerId, requestId: result.requestId, prevLimit, newLimit: s.currentLimit, statusCode, retryRuleMatched: result.retryRuleMatched ?? false, action: "failure_backoff" }, "Adaptive: sustained failures, decreased concurrency");
+        else {
+            // 5xx / 网络错误（statusCode=undefined）：连续失败退避
+            const profile = this.deriveProfile(s.currentLimit, entry.max);
+            if (s.consecutiveFailures >= profile.dropThreshold) {
+                const prevLimit = s.currentLimit;
+                s.currentLimit = Math.max(s.currentLimit - 1, ADAPTIVE_MIN);
+                s.consecutiveFailures = 0;
+                this.syncToSemaphore(providerId);
+                this.logger?.warn?.({ providerId, requestId: result.requestId, prevLimit, newLimit: s.currentLimit, statusCode, retryRuleMatched: result.retryRuleMatched ?? false, action: "failure_backoff" }, "Adaptive: sustained failures, decreased concurrency");
+            }
         }
     }
     syncToSemaphore(providerId) {
         const entry = this.entries.get(providerId);
         if (!entry)
             return;
-        // probeActive 时额外加 1 个探针槽位，但不超过 max
-        const effectiveLimit = entry.state.probeActive
-            ? Math.min(Math.max(entry.state.currentLimit + 1, ADAPTIVE_MIN), entry.max)
-            : Math.max(entry.state.currentLimit, ADAPTIVE_MIN);
+        const effectiveLimit = Math.max(entry.state.currentLimit, ADAPTIVE_MIN);
         this.semaphoreControl.updateConfig(providerId, {
             maxConcurrency: effectiveLimit,
             queueTimeoutMs: entry.queueTimeoutMs,

package/dist/core/concurrency/types.d.ts

@@ -7,7 +7,7 @@ export interface ConcurrencyConfig {
 /** Internal state of adaptive concurrency for a provider. */
 export interface AdaptiveState {
     currentLimit: number;
-    probeActive: boolean;
+    limitReached: boolean;
     consecutiveSuccesses: number;
     consecutiveFailures: number;
     cooldownUntil: number;
@@ -18,6 +18,8 @@ export interface AdaptiveResult {
     statusCode?: number;
     /** 重试规则是否匹配（resilience 层判断为可重试的失败），为 true 时忽略 statusCode 过滤 */
     retryRuleMatched?: boolean;
+    /** 此请求是否曾经排过队 */
+    wasQueued?: boolean;
     /** 触发此反馈的请求日志 ID，用于日志关联 */
     requestId?: string;
 }

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

@@ -23,6 +23,7 @@ export declare class RequestTracker {
     private providerConfigCache;
     private pushTimer;
     private tickCount;
+    private requestUpdateDirty;
     private streamAccumulators;
     private streamContentPending;
     private streamContentTimer;

package/dist/core/monitor/request-tracker.js

@@ -15,6 +15,7 @@ export class RequestTracker {
     providerConfigCache = new Map();
     pushTimer = null;
     tickCount = 0;
+    requestUpdateDirty = true;
     streamAccumulators = new Map();
     streamContentPending = new Set();
     streamContentTimer = null;
@@ -38,6 +39,7 @@ export class RequestTracker {
     // --- Core methods ---
     start(req) {
         this.activeMap.set(req.id, { ...req });
+        this.requestUpdateDirty = true;
         this.logger?.debug?.({ reqId: req.id, model: req.model, providerId: req.providerId, activeCount: this.activeMap.size }, "Tracker: start");
         this.broadcast("request_start", req);
     }
@@ -133,6 +135,7 @@ export class RequestTracker {
             this.recentCompleted.length = RECENT_COMPLETED_MAX;
         }
         this.logger?.debug?.({ reqId: id, status: result.status, statusCode, latency, activeCount: this.activeMap.size }, "Tracker: complete");
+        this.requestUpdateDirty = true;
         this.broadcast("request_complete", completed);
     }
     /** Update stream metrics for a completed request (e.g., after cache estimation) */
@@ -278,7 +281,10 @@ export class RequestTracker {
             this.tickCount++;
             this.cleanupRecent();
             this.cleanupStaleActive();
-            this.broadcast("request_update", this.getActive());
+            if (this.requestUpdateDirty) {
+                this.broadcast("request_update", this.getActive());
+                this.requestUpdateDirty = false;
+            }
             this.broadcast("concurrency_update", this.getConcurrency());
             this.broadcast("stats_update", this.getStats());
             // Every 10s (every 2nd tick)

package/dist/core/types.d.ts

@@ -26,6 +26,8 @@ export interface ResolveResult {
     concurrency_override?: ConcurrencyOverride;
     /** 活跃规则（schedule 或 base）中的 target 总数，用于 failover 判断 */
     targetCount: number;
+    /** 排除前的完整 target 列表，用于请求级缓存（BP-H2） */
+    allTargets?: Target[];
 }
 export interface MetricsResult {
     input_tokens: number | null;

package/dist/db/helpers.d.ts

@@ -1,4 +1,5 @@
 import Database from "better-sqlite3";
+export declare function getCachedStmt(db: Database.Database, sql: string): Database.Statement;
 /**
  * 通用 UPDATE 构建器。
  * 用白名单过滤安全字段，拼接 SET 子句。

package/dist/db/helpers.js

@@ -1,3 +1,18 @@
+/** WeakMap 按 db 实例缓存 prepared statements，避免重复 prepare() */
+const stmtCache = new WeakMap();
+export function getCachedStmt(db, sql) {
+    let cache = stmtCache.get(db);
+    if (!cache) {
+        cache = new Map();
+        stmtCache.set(db, cache);
+    }
+    let stmt = cache.get(sql);
+    if (!stmt) {
+        stmt = db.prepare(sql);
+        cache.set(sql, stmt);
+    }
+    return stmt;
+}
 /**
  * 通用 UPDATE 构建器。
  * 用白名单过滤安全字段，拼接 SET 子句。

package/dist/db/index.js

@@ -28,6 +28,12 @@ export function initDatabase(dbPath) {
     db.pragma("journal_mode = WAL");
     db.pragma("auto_vacuum = INCREMENTAL");
     db.pragma("foreign_keys = ON");
+    db.pragma("synchronous = NORMAL");
+    db.pragma("cache_size = -16000");
+    db.pragma("busy_timeout = 5000");
+    db.pragma("temp_store = MEMORY");
+    db.pragma("mmap_size = 67108864");
+    db.pragma("journal_size_limit = 67108864");
     db.exec(`
     CREATE TABLE IF NOT EXISTS migrations (
       name TEXT PRIMARY KEY,

package/dist/db/logs.d.ts

@@ -74,7 +74,7 @@ export declare function updateLogStreamContent(db: Database.Database, logId: str
 /** 当 router 返回给客户端的 status code 与上游不同时，记录实际发送的 status */
 export declare function updateLogClientStatus(db: Database.Database, logId: string, clientStatusCode: number): void;
 export declare function deleteLogsBefore(db: Database.Database, beforeDate: string): number;
-/** 估算 request_logs 表占用字节数 */
+/** 采样估算 request_logs 表占用字节数（避免全表 SUM 扫描） */
 export declare function estimateLogTableSize(db: Database.Database): number;
 /** 删除最旧的日志，保留 keepCount 条，返回实际删除条数。分批删除避免长时间锁表 */
 export declare function deleteOldestLogs(db: Database.Database, keepCount: number): number;

package/dist/db/logs.js

@@ -1,4 +1,5 @@
 import { shouldPreserveDetail } from "../proxy/log-detail-policy.js";
+import { getCachedStmt } from "./helpers.js";
 // --- request_logs ---
 const LOG_LIST_SELECT = `rl.id, rl.api_type, rl.model, rl.provider_id, rl.status_code, rl.client_status_code, rl.latency_ms,
             rl.is_stream, rl.error_message, rl.created_at, rl.is_retry, rl.is_failover, rl.original_request_id, rl.original_model,
@@ -26,7 +27,7 @@ export function insertRequestLog(db, log, writeContext) {
     }
     // 详情保留判定
     const preserveDetail = shouldPreserveDetail(log.status_code, writeContext?.responseBody ?? null, writeContext?.matcher ?? null, !!writeContext?.logFileWriter);
-    db.prepare(`INSERT INTO request_logs (id, api_type, model, provider_id, status_code, client_status_code, latency_ms,
+    getCachedStmt(db, `INSERT INTO request_logs (id, api_type, model, provider_id, status_code, client_status_code, latency_ms,
       is_stream, error_message, created_at, client_request, upstream_request, upstream_response,
       is_retry, is_failover, original_request_id, router_key_id, original_model, session_id, pipeline_snapshot)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(log.id, log.api_type, log.model, log.provider_id, log.status_code, log.client_status_code ?? null, log.latency_ms, log.is_stream, log.error_message, log.created_at, preserveDetail ? (log.client_request ?? null) : null, preserveDetail ? (log.upstream_request ?? null) : null, preserveDetail ? (log.upstream_response ?? null) : null, log.is_retry ?? 0, log.is_failover ?? 0, log.original_request_id ?? null, log.router_key_id ?? null, log.original_model ?? null, log.session_id ?? null, log.pipeline_snapshot ?? null);
@@ -92,11 +93,11 @@ export function getRequestLogById(db, id) {
 }
 /** 流式请求完成后，将 tracker 中累积的文本内容写入 request_logs */
 export function updateLogStreamContent(db, logId, textContent) {
-    db.prepare("UPDATE request_logs SET stream_text_content = ? WHERE id = ?").run(textContent, logId);
+    getCachedStmt(db, "UPDATE request_logs SET stream_text_content = ? WHERE id = ?").run(textContent, logId);
 }
 /** 当 router 返回给客户端的 status code 与上游不同时，记录实际发送的 status */
 export function updateLogClientStatus(db, logId, clientStatusCode) {
-    db.prepare("UPDATE request_logs SET client_status_code = ? WHERE id = ?").run(clientStatusCode, logId);
+    getCachedStmt(db, "UPDATE request_logs SET client_status_code = ? WHERE id = ?").run(clientStatusCode, logId);
 }
 export function deleteLogsBefore(db, beforeDate) {
     const changes = db.prepare("DELETE FROM request_logs WHERE created_at < ?").run(beforeDate).changes;
@@ -107,17 +108,20 @@ export function deleteLogsBefore(db, beforeDate) {
 }
 /** 每行元数据（数字列+索引）的估算字节数 */
 const ROW_METADATA_BYTES = 500;
-/** 估算 request_logs 表占用字节数 */
+/** 采样估算 request_logs 表占用字节数（避免全表 SUM 扫描） */
 export function estimateLogTableSize(db) {
-    const row = db.prepare(`
-    SELECT COALESCE(SUM(
-      COALESCE(length(client_request), 0) + COALESCE(length(upstream_request), 0) +
-      COALESCE(length(upstream_response), 0) + COALESCE(length(stream_text_content), 0) +
-      COALESCE(length(error_message), 0) + COALESCE(length(pipeline_snapshot), 0) + ?
-    ), 0) as size
-    FROM request_logs
-  `).get(ROW_METADATA_BYTES);
-    return row.size;
+    const countRow = db.prepare("SELECT COUNT(*) as cnt FROM request_logs").get();
+    if (countRow.cnt === 0)
+        return 0;
+    // 采样最近 100 行，计算平均行大小
+    const samples = db.prepare(`
+    SELECT COALESCE(length(client_request), 0) + COALESCE(length(upstream_request), 0) +
+           COALESCE(length(upstream_response), 0) + COALESCE(length(stream_text_content), 0) +
+           COALESCE(length(error_message), 0) + COALESCE(length(pipeline_snapshot), 0) + ? AS row_size
+    FROM request_logs ORDER BY created_at DESC LIMIT 100
+  `).all(ROW_METADATA_BYTES);
+    const avgRowSize = samples.reduce((s, r) => s + r.row_size, 0) / samples.length;
+    return Math.round(avgRowSize * countRow.cnt);
 }
 const DELETE_BATCH_SIZE = 1000;
 /** 删除最旧的日志，保留 keepCount 条，返回实际删除条数。分批删除避免长时间锁表 */
@@ -164,15 +168,28 @@ export function getRequestLogsGrouped(db, options) {
     const total = db.prepare(`SELECT COUNT(*) as count FROM request_logs rl WHERE ${where}`).get(...params).count;
     const offset = (options.page - 1) * options.limit;
     const data = db
-        .prepare(`SELECT ${LOG_LIST_SELECT},
-              (SELECT COUNT(*) FROM request_logs c WHERE c.original_request_id = rl.id) AS child_count
-       FROM request_logs rl
+        .prepare(`WITH page_ids AS (
+         SELECT rl.id FROM request_logs rl
+         ${LOG_LIST_JOIN}
+         WHERE ${where}
+         ORDER BY rl.created_at DESC LIMIT ? OFFSET ?
+       )
+       SELECT ${LOG_LIST_SELECT},
+              COALESCE(child.cnt, 0) AS child_count
+       FROM page_ids pg
+       JOIN request_logs rl ON rl.id = pg.id
        ${LOG_LIST_JOIN}
-       WHERE ${where} ORDER BY rl.created_at DESC LIMIT ? OFFSET ?`)
+       LEFT JOIN (
+         SELECT original_request_id, COUNT(*) AS cnt
+         FROM request_logs
+         WHERE original_request_id IN (SELECT id FROM page_ids)
+         GROUP BY original_request_id
+       ) child ON child.original_request_id = rl.id
+       ORDER BY rl.created_at DESC`)
         .all(...params, options.limit, offset);
     return { data, total };
 }
 /** 后续 pipeline 阶段完成后，回写 snapshot 到已有日志 */
 export function updateLogPipelineSnapshot(db, logId, snapshot) {
-    db.prepare("UPDATE request_logs SET pipeline_snapshot = ? WHERE id = ?").run(snapshot, logId);
+    getCachedStmt(db, "UPDATE request_logs SET pipeline_snapshot = ? WHERE id = ?").run(snapshot, logId);
 }

package/dist/db/metrics.js

@@ -1,8 +1,9 @@
 import { randomUUID } from "crypto";
 import { MS_PER_SECOND } from "../core/constants.js";
+import { getCachedStmt } from "./helpers.js";
 export function insertMetrics(db, m) {
     const id = randomUUID();
-    db.prepare(`INSERT INTO request_metrics (id, request_log_id, provider_id, backend_model, api_type, router_key_id, status_code,
+    getCachedStmt(db, `INSERT INTO request_metrics (id, request_log_id, provider_id, backend_model, api_type, router_key_id, status_code,
        input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens, ttft_ms, total_duration_ms, tokens_per_second, stop_reason, is_complete, input_tokens_estimated,
        client_type, cache_read_tokens_estimated,
        thinking_tokens, text_tokens, tool_use_tokens, thinking_duration_ms,

package/dist/db/migrations/044_add_performance_indexes.sql

@@ -0,0 +1,8 @@
+-- 覆盖 provider_id 过滤 + 时间范围分页
+CREATE INDEX IF NOT EXISTS idx_request_logs_provider_id ON request_logs(provider_id);
+CREATE INDEX IF NOT EXISTS idx_request_logs_created_at_provider ON request_logs(created_at DESC, provider_id);
+CREATE INDEX IF NOT EXISTS idx_request_logs_created_at_router_key ON request_logs(created_at DESC, router_key_id);
+
+-- 覆盖按密钥过滤的聚合查询
+CREATE INDEX IF NOT EXISTS idx_metrics_router_key ON request_metrics(router_key_id);
+CREATE INDEX IF NOT EXISTS idx_metrics_created_at_router_key ON request_metrics(created_at, router_key_id);

package/dist/db/settings.js

@@ -1,9 +1,26 @@
+import { getCachedStmt } from "./helpers.js";
+// TTL 缓存：WeakMap 按 db 实例隔离，确保测试中 :memory: db 互不干扰
+const settingsCache = new WeakMap();
+const CACHE_TTL_MS = 30_000;
 export function getSetting(db, key) {
-    const row = db.prepare("SELECT value FROM settings WHERE key = ?").get(key);
-    return row?.value ?? null;
+    let cache = settingsCache.get(db);
+    if (!cache) {
+        cache = new Map();
+        settingsCache.set(db, cache);
+    }
+    const cached = cache.get(key);
+    if (cached && Date.now() < cached.expiresAt)
+        return cached.value;
+    const row = getCachedStmt(db, "SELECT value FROM settings WHERE key = ?").get(key);
+    const value = row?.value ?? null;
+    cache.set(key, { value, expiresAt: Date.now() + CACHE_TTL_MS });
+    return value;
 }
 export function setSetting(db, key, value) {
-    db.prepare("INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)").run(key, value);
+    getCachedStmt(db, "INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)").run(key, value);
+    const cache = settingsCache.get(db);
+    if (cache)
+        cache.delete(key);
 }
 export function isInitialized(db) {
     return getSetting(db, "initialized") === "true";
@@ -40,7 +57,7 @@ export function setConfigSyncSource(db, source) {
     setSetting(db, "config_sync_source", source);
 }
 export function getDetailLogEnabled(db) {
-    const row = db.prepare("SELECT value FROM settings WHERE key = ?").get("detail_log_enabled");
+    const row = getCachedStmt(db, "SELECT value FROM settings WHERE key = ?").get("detail_log_enabled");
     return row ? row.value !== "0" : true;
 }
 export function getTokenEstimationEnabled(db) {
@@ -52,7 +69,7 @@ export function setTokenEstimationEnabled(db, enabled) {
 }
 const DEFAULT_LOG_FILE_RETENTION_DAYS = 3;
 export function getLogFileRetentionDays(db) {
-    const row = db.prepare("SELECT value FROM settings WHERE key = ?").get("log_file_retention_days");
+    const row = getCachedStmt(db, "SELECT value FROM settings WHERE key = ?").get("log_file_retention_days");
     return row ? parseInt(row.value, 10) : DEFAULT_LOG_FILE_RETENTION_DAYS;
 }
 const DEFAULT_CLIENT_SESSION_HEADERS = [

package/dist/index.js

@@ -330,6 +330,8 @@ export async function buildApp(options) {
         proxyAgentFactory.invalidateAll();
         const sessionTracker = container.resolve(SERVICE_KEYS.sessionTracker);
         sessionTracker.stop();
+        // Flush LogFileWriter 的 WriteStream 缓冲数据到磁盘
+        await logFileWriter?.stop();
         // 等待活跃代理请求自然完成，超时后强制关闭所有连接。
         // 先调用 app.close() 停止接受新连接并等待现有连接结束，
         // 如果 2 秒内未完成则调用 closeAllConnections() 强制断开，防止 SSE 长连接导致无限等待。

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

@@ -13,12 +13,17 @@ export declare class MetricsExtractor {
     private stopReason;
     private firstContentReceived;
     private complete;
-    private thinkingContentBuffer;
+    /** Buffer 容量上限，超过后停止 push 避免内存膨胀 */
+    private static readonly MAX_BUFFER_SIZE;
+    private thinkingChunks;
+    private thinkingTotalLength;
     private thinkingStreamStartTime;
     private thinkingStreamEndTime;
-    private textContentBuffer;
+    private textChunks;
+    private textTotalLength;
     private textStreamStartTime;
-    private toolUseContentBuffer;
+    private toolUseChunks;
+    private toolUseTotalLength;
     private toolUseStreamStartTime;
     constructor(apiType: "openai" | "openai-responses" | "anthropic", requestStartTime: number);
     processEvent(event: SSEEvent): void;