llm-simple-router 0.10.3 → 0.10.5

package/dist/admin/metrics.js

@@ -1,5 +1,5 @@
 import { Type } from "@sinclair/typebox";
-import { getMetricsSummary, getMetricsTimeseries } from "../db/index.js";
+import { getMetricsSummary, getMetricsTimeseries, getClientTypeBreakdown } from "../db/index.js";
 import { resolveTimeRange } from "../utils/time-range.js";
 const LegacyPeriodEnum = Type.Union([
     Type.Literal("1h"), Type.Literal("5h"), Type.Literal("6h"), Type.Literal("24h"),
@@ -21,6 +21,7 @@ const SummaryQuerySchema = Type.Object({
     provider_id: Type.Optional(Type.String()),
     backend_model: Type.Optional(Type.String()),
     router_key_id: Type.Optional(Type.String()),
+    client_type: Type.Optional(Type.String()),
     start_time: Type.Optional(Type.String()),
     end_time: Type.Optional(Type.String()),
 });
@@ -34,6 +35,8 @@ const TimeseriesQuerySchema = Type.Object({
     end_time: Type.Optional(Type.String()),
 });
 const DASHBOARD_PERIODS = new Set(["window", "weekly", "monthly"]);
+const PCT_FACTOR = 100;
+const PCT_ROUND_DIGITS = 10;
 function resolveMetricsTime(query, db, routerKeyId, providerId) {
     if (query.start_time && query.end_time) {
         return { startTime: query.start_time, endTime: query.end_time, legacyPeriod: "30d" };
@@ -50,8 +53,12 @@ export const adminMetricsRoutes = (app, options, done) => {
     app.get("/admin/api/metrics/summary", { schema: { querystring: SummaryQuerySchema } }, async (request, reply) => {
         const query = request.query;
         const { startTime, endTime, legacyPeriod } = resolveMetricsTime(query, db, query.router_key_id, query.provider_id);
-        const summary = getMetricsSummary(db, legacyPeriod, query.provider_id, query.backend_model, query.router_key_id, startTime, endTime);
-        return reply.send(summary);
+        const summary = getMetricsSummary(db, legacyPeriod, query.provider_id, query.backend_model, query.router_key_id, startTime, endTime, query.client_type);
+        const breakdown = getClientTypeBreakdown(db, legacyPeriod, query.provider_id, query.backend_model, query.router_key_id, startTime, endTime);
+        const totalInputTokens = summary.reduce((sum, r) => sum + r.total_input_tokens, 0);
+        const totalCacheHitTokens = summary.reduce((sum, r) => sum + r.total_cache_hit_tokens, 0);
+        const cacheHitRate = totalInputTokens > 0 ? totalCacheHitTokens * PCT_FACTOR / totalInputTokens : 0;
+        return reply.send({ rows: summary, client_type_breakdown: breakdown, cache_hit_rate: Math.round(cacheHitRate * PCT_ROUND_DIGITS) / PCT_ROUND_DIGITS });
     });
     app.get("/admin/api/metrics/timeseries", { schema: { querystring: TimeseriesQuerySchema } }, async (request, reply) => {
         const query = request.query;

package/dist/admin/monitor.d.ts

@@ -1,5 +1,5 @@
 import { FastifyPluginCallback } from "fastify";
-import type { RequestTracker } from "@llm-router/core/monitor";
+import type { RequestTracker } from "../core/monitor/index.js";
 interface MonitorRoutesOptions {
     tracker?: RequestTracker;
 }

package/dist/admin/providers.d.ts

@@ -1,8 +1,8 @@
 import { FastifyPluginCallback } from "fastify";
 import Database from "better-sqlite3";
 import type { StateRegistry } from "../core/registry.js";
-import type { AdaptiveController } from "@llm-router/core/concurrency";
-import type { RequestTracker } from "@llm-router/core/monitor";
+import type { AdaptiveController } from "../core/concurrency/index.js";
+import type { RequestTracker } from "../core/monitor/index.js";
 import type { ProxyAgentFactory } from "../proxy/transport/proxy-agent.js";
 interface ProviderRoutesOptions {
     db: Database.Database;

package/dist/admin/quick-setup.d.ts

@@ -1,8 +1,8 @@
 import { FastifyPluginCallback } from "fastify";
 import Database from "better-sqlite3";
 import type { StateRegistry } from "../core/registry.js";
-import type { RequestTracker } from "@llm-router/core/monitor";
-import type { AdaptiveController } from "@llm-router/core/concurrency";
+import type { RequestTracker } from "../core/monitor/index.js";
+import type { AdaptiveController } from "../core/concurrency/index.js";
 interface QuickSetupRoutesOptions {
     db: Database.Database;
     stateRegistry?: StateRegistry;

package/dist/admin/routes.d.ts

@@ -1,8 +1,8 @@
 import { FastifyPluginCallback } from "fastify";
 import Database from "better-sqlite3";
 import type { StateRegistry } from "../core/registry.js";
-import type { RequestTracker } from "@llm-router/core/monitor";
-import type { AdaptiveController } from "@llm-router/core/concurrency";
+import type { RequestTracker } from "../core/monitor/index.js";
+import type { AdaptiveController } from "../core/concurrency/index.js";
 import type { ProxyAgentFactory } from "../proxy/transport/proxy-agent.js";
 interface AdminRoutesOptions {
     db: Database.Database;

package/dist/admin/settings.js

@@ -1,6 +1,6 @@
 import { statSync, readdirSync } from "node:fs";
 import { join } from "node:path";
-import { getLogRetentionDays, setLogRetentionDays, getDbMaxSizeMb, setDbMaxSizeMb, getLogTableMaxSizeMb, setLogTableMaxSizeMb, getSetting, } from "../db/settings.js";
+import { getLogRetentionDays, setLogRetentionDays, getDbMaxSizeMb, setDbMaxSizeMb, getLogTableMaxSizeMb, setLogTableMaxSizeMb, getSetting, getTokenEstimationEnabled, setTokenEstimationEnabled, getClientSessionHeaders, setClientSessionHeaders, } 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) => {
@@ -63,6 +63,41 @@ export const adminSettingsRoutes = (app, options, done) => {
             logTableMaxSizeMb: getLogTableMaxSizeMb(db),
         };
     });
+    app.get("/admin/api/settings/token-estimation", async () => {
+        return { enabled: getTokenEstimationEnabled(db) };
+    });
+    app.put("/admin/api/settings/token-estimation", async (request, reply) => {
+        const { enabled } = request.body;
+        if (typeof enabled !== "boolean") {
+            return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, "enabled must be a boolean"));
+        }
+        setTokenEstimationEnabled(db, enabled);
+        return { success: true };
+    });
+    app.get("/admin/api/settings/client-session-headers", async () => {
+        const entries = getClientSessionHeaders(db);
+        return { entries };
+    });
+    app.put("/admin/api/settings/client-session-headers", async (request, reply) => {
+        const body = request.body;
+        if (!Array.isArray(body.entries)) {
+            return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, "entries must be a non-empty array"));
+        }
+        const entries = body.entries;
+        if (entries.length === 0) {
+            return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, "entries must be a non-empty array"));
+        }
+        for (const entry of entries) {
+            if (!entry.client_type || typeof entry.client_type !== "string" || entry.client_type.trim() === "") {
+                return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, "each entry must have a non-empty client_type"));
+            }
+            if (!entry.session_header_key || typeof entry.session_header_key !== "string" || entry.session_header_key.trim() === "") {
+                return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, "each entry must have a non-empty session_header_key"));
+            }
+        }
+        setClientSessionHeaders(db, entries);
+        return { success: true };
+    });
     done();
 };
 /** 递归计算目录下所有文件的总大小（字节） */

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

@@ -0,0 +1,24 @@
+import type { ISemaphoreControl, AdaptiveState, AdaptiveResult, ProviderConcurrencyParams } from "./types.js";
+import type { Logger } from "../types.js";
+export declare class AdaptiveController {
+    private semaphoreControl;
+    private logger?;
+    private readonly entries;
+    constructor(semaphoreControl: ISemaphoreControl, logger?: Logger | undefined);
+    init(providerId: string, config: {
+        max: number;
+    }, semParams: {
+        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: ProviderConcurrencyParams): void;
+    private transitionSuccess;
+    private transitionFailure;
+    private syncToSemaphore;
+}

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

@@ -0,0 +1,151 @@
+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;
+export class AdaptiveController {
+    semaphoreControl;
+    logger;
+    entries = new Map();
+    constructor(semaphoreControl, logger) {
+        this.semaphoreControl = semaphoreControl;
+        this.logger = logger;
+    }
+    init(providerId, config, semParams) {
+        const initialLimit = config.max;
+        this.entries.set(providerId, {
+            state: {
+                currentLimit: initialLimit,
+                probeActive: true,
+                consecutiveSuccesses: 0,
+                consecutiveFailures: 0,
+                cooldownUntil: 0,
+            },
+            max: config.max,
+            queueTimeoutMs: semParams.queueTimeoutMs,
+            maxQueueSize: semParams.maxQueueSize,
+        });
+        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)
+            return;
+        if (result.success) {
+            this.transitionSuccess(providerId, entry, result);
+        }
+        else {
+            this.transitionFailure(providerId, entry, result);
+        }
+    }
+    getStatus(providerId) {
+        return this.entries.get(providerId)?.state;
+    }
+    syncProvider(providerId, p) {
+        if (p.adaptive_enabled) {
+            const existing = this.entries.get(providerId);
+            if (existing) {
+                existing.max = p.max_concurrency;
+                existing.queueTimeoutMs = p.queue_timeout_ms;
+                existing.maxQueueSize = p.max_queue_size;
+                existing.state.currentLimit = Math.min(Math.max(existing.state.currentLimit, ADAPTIVE_MIN), existing.max);
+                this.syncToSemaphore(providerId);
+            }
+            else {
+                this.init(providerId, { max: p.max_concurrency }, {
+                    queueTimeoutMs: p.queue_timeout_ms, maxQueueSize: p.max_queue_size,
+                });
+            }
+        }
+        else {
+            this.remove(providerId);
+            // 禁用自适应后恢复信号量到原始 max_concurrency
+            this.semaphoreControl.updateConfig(providerId, {
+                maxConcurrency: p.max_concurrency,
+                queueTimeoutMs: p.queue_timeout_ms,
+                maxQueueSize: p.max_queue_size,
+            });
+        }
+    }
+    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 {
+                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.syncToSemaphore(providerId);
+        }
+    }
+    transitionFailure(providerId, entry, result) {
+        const statusCode = result.statusCode;
+        // 过滤非并发相关的错误：
+        // - retryRuleMatched=true → resilience 层根据重试规则判断为可重试的失败，计入退避
+        // - 429: 限流，计入退避
+        // - 5xx: 服务端错误（可能过载），计入退避
+        // - undefined: 网络异常，计入退避
+        // - 2xx/4xx 且 retryRuleMatched!=true: 非并发问题（如 upstream 200 body error 但未命中重试规则），不触发退避
+        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;
+        }
+        const s = entry.state;
+        s.consecutiveFailures++;
+        s.consecutiveSuccesses = 0;
+        if (statusCode === RATE_LIMIT_STATUS) {
+            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.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");
+        }
+        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");
+        }
+    }
+    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);
+        this.semaphoreControl.updateConfig(providerId, {
+            maxConcurrency: effectiveLimit,
+            queueTimeoutMs: entry.queueTimeoutMs,
+            maxQueueSize: entry.maxQueueSize,
+        });
+    }
+}

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

@@ -0,0 +1,4 @@
+export { SemaphoreManager } from "./semaphore.js";
+export { AdaptiveController } from "./adaptive-controller.js";
+export type { AcquireToken } from "./semaphore.js";
+export type { ConcurrencyConfig, AdaptiveState, AdaptiveResult, ISemaphoreControl, ProviderConcurrencyParams, } from "./types.js";

package/dist/core/concurrency/index.js

@@ -0,0 +1,2 @@
+export { SemaphoreManager } from "./semaphore.js";
+export { AdaptiveController } from "./adaptive-controller.js";

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

@@ -0,0 +1,29 @@
+import { SemaphoreQueueFullError, SemaphoreTimeoutError } from "../errors.js";
+export { SemaphoreQueueFullError, SemaphoreTimeoutError };
+import type { ConcurrencyConfig } from "./types.js";
+import type { Logger } from "../types.js";
+export interface AcquireToken {
+    readonly generation: number;
+    /** acquire 时 maxConcurrency=0（不计数），release 时跳过递减 */
+    readonly bypassed: boolean;
+}
+export declare class SemaphoreManager {
+    private readonly entries;
+    /** 全局 generation 计数器 — 每次 getOrCreate 分配唯一值，避免 disable+re-enable 后旧 token 匹配新条目 */
+    private nextGeneration;
+    private getOrCreate;
+    updateConfig(providerId: string, config: ConcurrencyConfig): void;
+    acquire(providerId: string, signal?: AbortSignal, onQueued?: () => void, logger?: Logger, override?: {
+        max_concurrency?: number;
+        queue_timeout_ms?: number;
+        max_queue_size?: number;
+    }): Promise<AcquireToken>;
+    release(providerId: string, token: AcquireToken, logger?: Logger): void;
+    getStatus(providerId: string): {
+        active: number;
+        queued: number;
+    };
+    remove(providerId: string): void;
+    /** 清除所有 provider 的信号量配置（导入配置后调用） */
+    removeAll(): void;
+}

package/dist/core/concurrency/semaphore.js

@@ -0,0 +1,161 @@
+import { SemaphoreQueueFullError, SemaphoreTimeoutError } from "../errors.js";
+export { SemaphoreQueueFullError, SemaphoreTimeoutError };
+export class SemaphoreManager {
+    entries = new Map();
+    /** 全局 generation 计数器 — 每次 getOrCreate 分配唯一值，避免 disable+re-enable 后旧 token 匹配新条目 */
+    nextGeneration = 0;
+    getOrCreate(providerId) {
+        let entry = this.entries.get(providerId);
+        if (!entry) {
+            entry = {
+                config: { maxConcurrency: 0, queueTimeoutMs: 0, maxQueueSize: 0 },
+                current: 0,
+                queue: [],
+                generation: ++this.nextGeneration,
+            };
+            this.entries.set(providerId, entry);
+        }
+        return entry;
+    }
+    updateConfig(providerId, config) {
+        const entry = this.getOrCreate(providerId);
+        entry.config = config;
+        if (config.maxConcurrency === 0) {
+            while (entry.queue.length > 0) {
+                const e = entry.queue.shift();
+                if (e.timer)
+                    clearTimeout(e.timer);
+                e.resolve();
+            }
+            // 递增 generation（全局唯一），使当前所有持有旧 token 的 release() 调用失效
+            entry.generation = ++this.nextGeneration;
+            entry.current = 0;
+            return;
+        }
+        if (entry.current < 0)
+            entry.current = 0;
+        // maxConcurrency 降低时**不截断 current**、**不递增 generation**。
+        //
+        // 原因：截断 current + 递增 generation 会导致所有旧请求的 release() 失效，
+        // current 永远停留在截断值（即使旧请求全部完成也无法回落），信号量卡死。
+        //
+        // 不截断的代价：current 可能暂时超过 maxConcurrency，但旧请求完成后
+        // release() 会正常递减 current，自然回落到 maxConcurrency 以下。
+        // 新请求在 current >= maxConcurrency 时仍会排队，不会被超限放行。
+        //
+        // 唯一的例外是 maxConcurrency=0（关闭信号量），在上面单独处理。
+        while (entry.current < config.maxConcurrency &&
+            entry.queue.length > 0) {
+            entry.current++;
+            const e = entry.queue.shift();
+            if (e.timer)
+                clearTimeout(e.timer);
+            e.resolve();
+        }
+    }
+    async acquire(providerId, signal, onQueued, logger, override) {
+        const entry = this.getOrCreate(providerId);
+        const maxConcurrency = override?.max_concurrency ?? entry.config.maxConcurrency;
+        const queueTimeoutMs = Math.max(0, override?.queue_timeout_ms ?? entry.config.queueTimeoutMs);
+        const maxQueueSize = Math.max(0, override?.max_queue_size ?? entry.config.maxQueueSize);
+        if (maxConcurrency === 0)
+            return { generation: entry.generation, bypassed: true };
+        if (entry.current < maxConcurrency) {
+            entry.current++;
+            logger?.debug?.({ providerId, current: entry.current, maxConcurrency, action: "acquire_direct" }, "Semaphore: acquired directly");
+            return { generation: entry.generation, bypassed: false };
+        }
+        if (entry.queue.length >= maxQueueSize) {
+            logger?.debug?.({ providerId, queueLength: entry.queue.length, maxQueueSize, action: "acquire_rejected" }, "Semaphore: queue full, rejecting");
+            throw new SemaphoreQueueFullError(providerId);
+        }
+        logger?.debug?.({ providerId, current: entry.current, maxConcurrency, queueLength: entry.queue.length, action: "acquire_queued" }, "Semaphore: entering wait queue");
+        onQueued?.();
+        return new Promise((resolve, reject) => {
+            const token = { generation: entry.generation, bypassed: false };
+            const qe = {
+                resolve: () => {
+                    logger?.debug?.({ providerId, current: entry.current, maxConcurrency, queueLength: entry.queue.length, action: "acquire_resolved" }, "Semaphore: left wait queue, acquired");
+                    resolve(token);
+                },
+                reject: (err) => {
+                    logger?.debug?.({ providerId, action: "acquire_rejected_internal", error: err.message }, "Semaphore: wait queue entry rejected");
+                    reject(err);
+                },
+                timer: null,
+            };
+            if (queueTimeoutMs > 0) {
+                qe.timer = setTimeout(() => {
+                    const idx = entry.queue.indexOf(qe);
+                    if (idx !== -1)
+                        entry.queue.splice(idx, 1);
+                    reject(new SemaphoreTimeoutError(providerId, queueTimeoutMs));
+                }, queueTimeoutMs);
+            }
+            if (signal) {
+                const onAbort = () => {
+                    const idx = entry.queue.indexOf(qe);
+                    if (idx !== -1)
+                        entry.queue.splice(idx, 1);
+                    if (qe.timer)
+                        clearTimeout(qe.timer);
+                    reject(new DOMException("Aborted", "AbortError"));
+                };
+                signal.addEventListener("abort", onAbort, { once: true });
+            }
+            entry.queue.push(qe);
+        });
+    }
+    release(providerId, token, logger) {
+        const entry = this.entries.get(providerId);
+        if (!entry)
+            return;
+        // bypassed: acquire 时 maxConcurrency=0（不计数），release 跳过递减
+        if (token.bypassed)
+            return;
+        // generation 不匹配说明此请求在 updateConfig 重置前 acquire，其槽位已被回收
+        if (token.generation !== entry.generation) {
+            logger?.debug?.({ providerId, tokenGen: token.generation, currentGen: entry.generation, action: "release_stale" }, "Semaphore: stale token, skipping release");
+            return;
+        }
+        if (entry.queue.length > 0) {
+            const e = entry.queue.shift();
+            logger?.debug?.({ providerId, current: entry.current, maxConcurrency: entry.config.maxConcurrency, queueRemaining: entry.queue.length, action: "release_dequeue" }, "Semaphore: released, dequeued next waiter");
+            if (e.timer)
+                clearTimeout(e.timer);
+            e.resolve();
+        }
+        else {
+            entry.current--;
+            logger?.debug?.({ providerId, current: entry.current, maxConcurrency: entry.config.maxConcurrency, action: "release_decrement" }, "Semaphore: released slot");
+        }
+    }
+    getStatus(providerId) {
+        const entry = this.entries.get(providerId);
+        if (!entry)
+            return { active: 0, queued: 0 };
+        return { active: entry.current, queued: entry.queue.length };
+    }
+    remove(providerId) {
+        const entry = this.entries.get(providerId);
+        if (!entry)
+            return;
+        for (const e of entry.queue) {
+            if (e.timer)
+                clearTimeout(e.timer);
+            e.reject(new Error("Provider removed"));
+        }
+        this.entries.delete(providerId);
+    }
+    /** 清除所有 provider 的信号量配置（导入配置后调用） */
+    removeAll() {
+        for (const [, entry] of this.entries) {
+            for (const e of entry.queue) {
+                if (e.timer)
+                    clearTimeout(e.timer);
+                e.reject(new Error("Provider removed"));
+            }
+        }
+        this.entries.clear();
+    }
+}

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

@@ -0,0 +1,34 @@
+/** Provider-level concurrency control configuration. */
+export interface ConcurrencyConfig {
+    maxConcurrency: number;
+    queueTimeoutMs: number;
+    maxQueueSize: number;
+}
+/** Internal state of adaptive concurrency for a provider. */
+export interface AdaptiveState {
+    currentLimit: number;
+    probeActive: boolean;
+    consecutiveSuccesses: number;
+    consecutiveFailures: number;
+    cooldownUntil: number;
+}
+/** Result of a request for adaptive concurrency feedback. */
+export interface AdaptiveResult {
+    success: boolean;
+    statusCode?: number;
+    /** 重试规则是否匹配（resilience 层判断为可重试的失败），为 true 时忽略 statusCode 过滤 */
+    retryRuleMatched?: boolean;
+    /** 触发此反馈的请求日志 ID，用于日志关联 */
+    requestId?: string;
+}
+/** Abstraction for semaphore operations (decouples AdaptiveController). */
+export interface ISemaphoreControl {
+    updateConfig(providerId: string, config: ConcurrencyConfig): void;
+}
+/** Provider DB fields for adaptive/manual concurrency. */
+export interface ProviderConcurrencyParams {
+    adaptive_enabled: number;
+    max_concurrency: number;
+    queue_timeout_ms: number;
+    max_queue_size: number;
+}

package/dist/core/concurrency/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/errors.d.ts

@@ -1,4 +1,18 @@
-export { SemaphoreQueueFullError, SemaphoreTimeoutError } from "@llm-router/core";
+/**
+ * Thrown when a provider's concurrency queue is full.
+ */
+export declare class SemaphoreQueueFullError extends Error {
+    readonly providerId: string;
+    constructor(providerId: string);
+}
+/**
+ * Thrown when a provider's concurrency wait times out.
+ */
+export declare class SemaphoreTimeoutError extends Error {
+    readonly providerId: string;
+    readonly timeoutMs: number;
+    constructor(providerId: string, timeoutMs: number);
+}
 import type { TransportResult, ResilienceAttempt } from "./types.js";
 /**
  * 跨 provider failover 时由 ResilienceLayer 抛出，

package/dist/core/errors.js

@@ -1,7 +1,29 @@
 // src/core/errors.ts
 // Re-export core errors + router-specific errors
-// Re-export errors that have been migrated to @llm-router/core
-export { SemaphoreQueueFullError, SemaphoreTimeoutError } from "@llm-router/core";
+/**
+ * Thrown when a provider's concurrency queue is full.
+ */
+export class SemaphoreQueueFullError extends Error {
+    providerId;
+    constructor(providerId) {
+        super(`Provider '${providerId}' concurrency queue is full`);
+        this.providerId = providerId;
+        this.name = "SemaphoreQueueFullError";
+    }
+}
+/**
+ * Thrown when a provider's concurrency wait times out.
+ */
+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 的信号量。

package/dist/core/index.d.ts

@@ -0,0 +1,9 @@
+export { SemaphoreQueueFullError, SemaphoreTimeoutError } from "./errors.js";
+export type { Logger } from "./types.js";
+export { SemaphoreManager, AdaptiveController } from "./concurrency/index.js";
+export type { AcquireToken, ConcurrencyConfig, AdaptiveState, AdaptiveResult, ISemaphoreControl, ProviderConcurrencyParams } from "./concurrency/index.js";
+export { SessionTracker, StreamLoopGuard, ToolLoopGuard, NGramLoopDetector, DEFAULT_LOOP_PREVENTION_CONFIG, } from "./loop-prevention/index.js";
+export type { LoopPreventionConfig, StreamLoopGuardConfig, ToolLoopGuardConfig, SessionTrackerConfig, NGramDetectorConfig, ToolCallRecord, LoopCheckResult, LoopDetector, LoopDetectorStatus, } from "./loop-prevention/index.js";
+export { RequestTracker, StatsAggregator, RuntimeCollector } from "./monitor/index.js";
+export type { ISemaphoreStatus, IAdaptiveStatus } from "./monitor/index.js";
+export type { ActiveRequest, AttemptSnapshot, ContentBlock, ProviderConcurrencySnapshot, ProviderStats, RuntimeMetrics, SSEClient, StatsSnapshot, StreamContentSnapshot, StreamMetricsSnapshot, } from "./monitor/index.js";

package/dist/core/index.js

@@ -0,0 +1,12 @@
+// src/core/index.ts — unified re-export
+// Individual sub-path imports also available:
+//   ./concurrency
+//   ./loop-prevention
+//   ./monitor
+export { SemaphoreQueueFullError, SemaphoreTimeoutError } from "./errors.js";
+// Concurrency
+export { SemaphoreManager, AdaptiveController } from "./concurrency/index.js";
+// Loop prevention
+export { SessionTracker, StreamLoopGuard, ToolLoopGuard, NGramLoopDetector, DEFAULT_LOOP_PREVENTION_CONFIG, } from "./loop-prevention/index.js";
+// Monitor
+export { RequestTracker, StatsAggregator, RuntimeCollector } from "./monitor/index.js";

package/dist/core/loop-prevention/detector.d.ts

@@ -0,0 +1,10 @@
+export interface LoopDetectorStatus {
+    detected: boolean;
+    reason?: string;
+    details?: Record<string, unknown>;
+}
+export interface LoopDetector {
+    feed(text: string): boolean;
+    reset(): void;
+    getStatus(): LoopDetectorStatus;
+}

package/dist/core/loop-prevention/detector.js

@@ -0,0 +1 @@
+export {};

package/dist/core/loop-prevention/index.d.ts

@@ -0,0 +1,7 @@
+export { SessionTracker } from "./session-tracker.js";
+export { StreamLoopGuard } from "./stream-loop-guard.js";
+export { ToolLoopGuard } from "./tool-loop-guard.js";
+export { NGramLoopDetector } from "./ngram-detector.js";
+export { DEFAULT_LOOP_PREVENTION_CONFIG, } from "./types.js";
+export type { LoopPreventionConfig, StreamLoopGuardConfig, ToolLoopGuardConfig, SessionTrackerConfig, NGramDetectorConfig, ToolCallRecord, LoopCheckResult, } from "./types.js";
+export type { LoopDetector, LoopDetectorStatus } from "./detector.js";