llm-simple-router 0.6.4 → 0.6.6

package/config/recommended-retry-rules.json

@@ -6,6 +6,5 @@
   { "name": "ZAI 操作失败 (code 500)", "status_code": 400, "body_pattern": "\"type\"\\s*:\\s*\"error\".*\"code\"\\s*:\\s*\"500\"", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 10, "max_delay_ms": 60000 },
   { "name": "ZAI 速率限制 (HTTP 200, code 1302)", "status_code": 200, "body_pattern": "\"error\".*\"code\"\\s*:\\s*\"1302\"", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 10, "max_delay_ms": 60000 },
   { "name": "ZAI SSE 错误 (HTTP 200, code 500)", "status_code": 200, "body_pattern": "\"error\".*\"code\"\\s*:\\s*\"500\"", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 10, "max_delay_ms": 60000 },
-  { "name": "ZAI SSE 错误 (HTTP 200, code 1234)", "status_code": 200, "body_pattern": "\"error\".*\"code\"\\s*:\\s*\"1234\"", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 10, "max_delay_ms": 60000 },
-  { "name": "ZAI 过载限流 (HTTP 200, code 1305)", "status_code": 200, "body_pattern": "\"error\".*\"code\"\\s*:\\s*\"1305\"", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 10, "max_delay_ms": 60000 }
+  { "name": "ZAI SSE 错误 (HTTP 200, code 1234)", "status_code": 200, "body_pattern": "\"error\".*\"code\"\\s*:\\s*\"1234\"", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 10, "max_delay_ms": 60000 }
 ]

package/dist/admin/providers.d.ts

@@ -1,11 +1,13 @@
 import { FastifyPluginCallback } from "fastify";
 import Database from "better-sqlite3";
 import { ProviderSemaphoreManager } from "../proxy/semaphore.js";
+import type { AdaptiveConcurrencyController } from "../proxy/adaptive-controller.js";
 import type { RequestTracker } from "../monitor/request-tracker.js";
 interface ProviderRoutesOptions {
     db: Database.Database;
     semaphoreManager?: ProviderSemaphoreManager;
     tracker?: RequestTracker;
+    adaptiveController?: AdaptiveConcurrencyController;
 }
 export declare const adminProviderRoutes: FastifyPluginCallback<ProviderRoutesOptions>;
 export {};

package/dist/admin/providers.js

@@ -77,6 +77,7 @@ const CreateProviderSchema = Type.Object({
     max_concurrency: Type.Optional(Type.Integer({ minimum: 0 })),
     queue_timeout_ms: Type.Optional(Type.Integer({ minimum: 0 })),
     max_queue_size: Type.Optional(Type.Integer({ minimum: 1 })),
+    adaptive_enabled: Type.Optional(Type.Integer({ minimum: 0, maximum: 1 })),
 });
 const UpdateProviderSchema = Type.Object({
     name: Type.Optional(Type.String({ minLength: 1 })),
@@ -91,9 +92,10 @@ const UpdateProviderSchema = Type.Object({
     max_concurrency: Type.Optional(Type.Integer({ minimum: 0 })),
     queue_timeout_ms: Type.Optional(Type.Integer({ minimum: 0 })),
     max_queue_size: Type.Optional(Type.Integer({ minimum: 1 })),
+    adaptive_enabled: Type.Optional(Type.Integer({ minimum: 0, maximum: 1 })),
 });
 export const adminProviderRoutes = (app, options, done) => {
-    const { db, semaphoreManager, tracker } = options;
+    const { db, semaphoreManager, tracker, adaptiveController } = options;
     app.get("/admin/api/providers", async (_request, reply) => {
         const encryptionKey = getSetting(db, "encryption_key");
         const providers = getAllProviders(db);
@@ -111,6 +113,7 @@ export const adminProviderRoutes = (app, options, done) => {
                 max_concurrency: s.max_concurrency,
                 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 },
                 created_at: s.created_at,
                 updated_at: s.updated_at,
@@ -128,6 +131,7 @@ export const adminProviderRoutes = (app, options, done) => {
         }
         const encryptedKey = encrypt(body.api_key, getSetting(db, "encryption_key"));
         const { names: normalizedModels, overrides: contextOverrides } = extractModelOverrides((body.models ?? []));
+        const isAdaptiveEnabled = body.adaptive_enabled ?? 0;
         const id = createProvider(db, {
             name: body.name,
             api_type: body.api_type,
@@ -139,6 +143,7 @@ export const adminProviderRoutes = (app, options, done) => {
             max_concurrency: body.max_concurrency ?? PROVIDER_CONCURRENCY_DEFAULTS.max_concurrency,
             queue_timeout_ms: body.queue_timeout_ms ?? PROVIDER_CONCURRENCY_DEFAULTS.queue_timeout_ms,
             max_queue_size: body.max_queue_size ?? PROVIDER_CONCURRENCY_DEFAULTS.max_queue_size,
+            adaptive_enabled: isAdaptiveEnabled,
         });
         if (contextOverrides.length > 0) {
             setModelInfoForProvider(db, id, contextOverrides.map(o => ({ model_name: o.name, context_window: o.context_window })));
@@ -148,6 +153,12 @@ export const adminProviderRoutes = (app, options, done) => {
             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,
+            queue_timeout_ms: body.queue_timeout_ms ?? PROVIDER_CONCURRENCY_DEFAULTS.queue_timeout_ms,
+            max_queue_size: body.max_queue_size ?? PROVIDER_CONCURRENCY_DEFAULTS.max_queue_size,
+        });
         tracker?.updateProviderConfig(id, {
             name: body.name,
             maxConcurrency: body.max_concurrency ?? PROVIDER_CONCURRENCY_DEFAULTS.max_concurrency,
@@ -191,6 +202,8 @@ export const adminProviderRoutes = (app, options, done) => {
             fields.queue_timeout_ms = body.queue_timeout_ms;
         if (body.max_queue_size !== undefined)
             fields.max_queue_size = body.max_queue_size;
+        if (body.adaptive_enabled !== undefined)
+            fields.adaptive_enabled = body.adaptive_enabled;
         if (body.api_key) {
             fields.api_key = encrypt(body.api_key, getSetting(db, "encryption_key"));
             fields.api_key_preview = body.api_key.length > API_KEY_PREVIEW_MIN_LENGTH ? `${body.api_key.slice(0, API_KEY_PREVIEW_PREFIX_LEN)}...${body.api_key.slice(-API_KEY_PREVIEW_PREFIX_LEN)}` : "****";
@@ -208,6 +221,14 @@ export const adminProviderRoutes = (app, options, done) => {
                 maxQueueSize: updated.max_queue_size,
             });
         }
+        if (body.adaptive_enabled !== undefined || body.max_concurrency !== undefined || body.queue_timeout_ms !== undefined || body.max_queue_size !== undefined) {
+            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,
+            });
+        }
         tracker?.updateProviderConfig(id, {
             name: body.name ?? existing.name,
             maxConcurrency: updated.max_concurrency,
@@ -272,8 +293,16 @@ export const adminProviderRoutes = (app, options, done) => {
         }
         deleteProvider(db, id);
         semaphoreManager?.remove(id);
+        adaptiveController?.remove(id);
         tracker?.removeProviderConfig(id);
         return reply.send({ success: true });
     });
+    app.get("/admin/api/providers/:id/adaptive-status", async (request, reply) => {
+        const { id } = request.params;
+        const status = adaptiveController?.getStatus(id);
+        if (!status)
+            return reply.code(HTTP_NOT_FOUND).send({ error: "Not found or adaptive not enabled" });
+        return status;
+    });
     done();
 };

package/dist/admin/proxy-enhancement.js

@@ -3,6 +3,8 @@ 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(),
+    stream_loop_enabled: Type.Boolean(),
 });
 const SessionParamsSchema = Type.Object({
     keyId: Type.String(),
@@ -16,12 +18,16 @@ export const adminProxyEnhancementRoutes = (app, options, done) => {
         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,
         });
     });
     app.put("/admin/api/proxy-enhancement", { schema: { body: UpdateProxyEnhancementSchema } }, async (request, reply) => {
         const body = request.body;
         const config = {
             claude_code_enabled: body.claude_code_enabled,
+            tool_call_loop_enabled: body.tool_call_loop_enabled,
+            stream_loop_enabled: body.stream_loop_enabled,
         };
         setSetting(db, "proxy_enhancement", JSON.stringify(config));
         return reply.send({ success: true });

package/dist/admin/routes.d.ts

@@ -3,11 +3,13 @@ import Database from "better-sqlite3";
 import { RetryRuleMatcher } from "../proxy/retry-rules.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;
     tracker?: RequestTracker;
     semaphoreManager?: ProviderSemaphoreManager;
+    adaptiveController?: AdaptiveConcurrencyController;
 }
 export declare const adminRoutes: FastifyPluginCallback<AdminRoutesOptions>;
 export {};

package/dist/admin/routes.js

@@ -21,7 +21,7 @@ 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 });
+    app.register(adminProviderRoutes, { db: options.db, semaphoreManager: options.semaphoreManager, tracker: options.tracker, adaptiveController: options.adaptiveController });
     app.register(adminMappingRoutes, { db: options.db });
     app.register(adminGroupRoutes, { db: options.db });
     app.register(adminScheduleRoutes, { db: options.db });

package/dist/config.d.ts

@@ -1,4 +1,3 @@
-import type { LoopPreventionConfig } from "./proxy/loop-prevention/types.js";
 export interface Config {
     PORT: number;
     DB_PATH: string;
@@ -6,7 +5,6 @@ export interface Config {
     TZ: string;
     STREAM_TIMEOUT_MS: number;
     RETRY_BASE_DELAY_MS: number;
-    LOOP_PREVENTION: LoopPreventionConfig;
 }
 export declare function resetConfig(): void;
 export declare function getBaseConfig(): Config;

package/dist/config.js

@@ -1,6 +1,5 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { DEFAULT_LOOP_PREVENTION_CONFIG } from "./proxy/loop-prevention/types.js";
 let cachedConfig = null;
 function getDefaultDbPath() {
     if (process.env.DB_PATH)
@@ -20,10 +19,6 @@ export function getBaseConfig() {
         TZ: process.env.TZ || "Asia/Shanghai",
         STREAM_TIMEOUT_MS: parseInt(process.env.STREAM_TIMEOUT_MS || "3000000", 10),
         RETRY_BASE_DELAY_MS: parseInt(process.env.RETRY_BASE_DELAY_MS || "1000", 10),
-        LOOP_PREVENTION: {
-            ...DEFAULT_LOOP_PREVENTION_CONFIG,
-            ...(process.env.LOOP_PREVENTION ? JSON.parse(process.env.LOOP_PREVENTION) : {}),
-        },
     };
     return cachedConfig;
 }

package/dist/db/migrations/033_add_adaptive_concurrency.sql

@@ -0,0 +1,3 @@
+-- 033_add_adaptive_concurrency.sql
+ALTER TABLE providers ADD COLUMN adaptive_enabled INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE providers ADD COLUMN adaptive_min INTEGER NOT NULL DEFAULT 1;

package/dist/db/providers.d.ts

@@ -11,6 +11,7 @@ export interface Provider {
     max_concurrency: number;
     queue_timeout_ms: number;
     max_queue_size: number;
+    adaptive_enabled: number;
     created_at: string;
     updated_at: string;
 }
@@ -33,8 +34,9 @@ export declare function createProvider(db: Database.Database, provider: {
     max_concurrency?: number;
     queue_timeout_ms?: number;
     max_queue_size?: number;
+    adaptive_enabled?: number;
 }): string;
-export declare function updateProvider(db: Database.Database, id: string, fields: Partial<Pick<Provider, "name" | "api_type" | "base_url" | "api_key" | "api_key_preview" | "models" | "is_active" | "max_concurrency" | "queue_timeout_ms" | "max_queue_size">>): void;
+export declare function updateProvider(db: Database.Database, id: string, fields: Partial<Pick<Provider, "name" | "api_type" | "base_url" | "api_key" | "api_key_preview" | "models" | "is_active" | "max_concurrency" | "queue_timeout_ms" | "max_queue_size" | "adaptive_enabled">>): void;
 export declare function deleteProvider(db: Database.Database, id: string): void;
 export declare function getActiveProviderByName(db: Database.Database, name: string): {
     id: string;

package/dist/db/providers.js

@@ -6,7 +6,7 @@ export const PROVIDER_CONCURRENCY_DEFAULTS = {
     max_queue_size: 100,
 };
 const PROVIDER_FIELDS = new Set([
-    "name", "api_type", "base_url", "api_key", "api_key_preview", "models", "is_active", "max_concurrency", "queue_timeout_ms", "max_queue_size",
+    "name", "api_type", "base_url", "api_key", "api_key_preview", "models", "is_active", "max_concurrency", "queue_timeout_ms", "max_queue_size", "adaptive_enabled",
 ]);
 export function getActiveProviders(db, apiType) {
     return db
@@ -22,8 +22,8 @@ export function getProviderById(db, id) {
 export function createProvider(db, provider) {
     const id = randomUUID();
     const now = new Date().toISOString();
-    db.prepare(`INSERT INTO providers (id, name, api_type, base_url, api_key, api_key_preview, models, is_active, max_concurrency, queue_timeout_ms, max_queue_size, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, provider.name, provider.api_type, provider.base_url, provider.api_key, provider.api_key_preview ?? null, provider.models ?? "[]", provider.is_active ?? 1, provider.max_concurrency ?? PROVIDER_CONCURRENCY_DEFAULTS.max_concurrency, provider.queue_timeout_ms ?? PROVIDER_CONCURRENCY_DEFAULTS.queue_timeout_ms, provider.max_queue_size ?? PROVIDER_CONCURRENCY_DEFAULTS.max_queue_size, now, now);
+    db.prepare(`INSERT INTO providers (id, name, api_type, base_url, api_key, api_key_preview, models, is_active, max_concurrency, queue_timeout_ms, max_queue_size, adaptive_enabled, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, provider.name, provider.api_type, provider.base_url, provider.api_key, provider.api_key_preview ?? null, provider.models ?? "[]", provider.is_active ?? 1, provider.max_concurrency ?? PROVIDER_CONCURRENCY_DEFAULTS.max_concurrency, provider.queue_timeout_ms ?? PROVIDER_CONCURRENCY_DEFAULTS.queue_timeout_ms, provider.max_queue_size ?? PROVIDER_CONCURRENCY_DEFAULTS.max_queue_size, provider.adaptive_enabled ?? 0, now, now);
     return id;
 }
 export function updateProvider(db, id, fields) {

package/dist/index.js

@@ -20,12 +20,12 @@ import { anthropicProxy } from "./proxy/anthropic.js";
 import { adminRoutes } from "./admin/routes.js";
 import { RetryRuleMatcher } from "./proxy/retry-rules.js";
 import { ProviderSemaphoreManager } from "./proxy/semaphore.js";
+import { AdaptiveConcurrencyController } from "./proxy/adaptive-controller.js";
 import { RequestTracker } from "./monitor/request-tracker.js";
 import { modelState } from "./proxy/model-state.js";
 import { UsageWindowTracker } from "./proxy/usage-window-tracker.js";
 import { SessionTracker } from "./proxy/loop-prevention/session-tracker.js";
 import { DEFAULT_LOOP_PREVENTION_CONFIG } from "./proxy/loop-prevention/types.js";
-import { setLoopPreventionConfig } from "./proxy/transport-fn.js";
 import { scheduleLogCleanup } from "./db/log-cleaner.js";
 import { scheduleDbSizeMonitor } from "./db/db-size-monitor.js";
 import { startUpgradeChecker, stopUpgradeChecker } from "./admin/upgrade.js";
@@ -156,21 +156,23 @@ export async function buildApp(options) {
     const semaphoreManager = new ProviderSemaphoreManager();
     const tracker = new RequestTracker({ semaphoreManager, logger: app.log });
     tracker.startPushInterval();
+    const adaptiveController = new AdaptiveConcurrencyController(semaphoreManager, app.log);
+    tracker.setAdaptiveController(adaptiveController);
     // 5h 用量窗口追踪器，启动时自动补齐缺失窗口
     const usageWindowTracker = new UsageWindowTracker(db);
     usageWindowTracker.reconcileOnStartup();
-    const loopConfig = config.LOOP_PREVENTION ?? DEFAULT_LOOP_PREVENTION_CONFIG;
-    const sessionTracker = new SessionTracker(loopConfig.sessionTracker);
-    // buildApp() 默认启用循环预防。
-    // 用户可通过环境变量 LOOP_PREVENTION='{"enabled":false}' 关闭。
-    // 直接注册插件的测试不使用 buildApp()，不受此影响。
-    setLoopPreventionConfig(process.env.LOOP_PREVENTION
-        ? loopConfig
-        : { ...loopConfig, enabled: true });
+    // Session tracker（工具调用循环检测用），始终创建但检测受 proxy_enhancement 配置控制
+    const sessionTracker = new SessionTracker(DEFAULT_LOOP_PREVENTION_CONFIG.sessionTracker);
     // 从 DB 读取已有 provider 的并发配置，初始化信号量管理器和 tracker
     const allProviders = getAllProviders(db);
     for (const p of allProviders) {
-        if (p.max_concurrency > 0) {
+        if (p.adaptive_enabled) {
+            adaptiveController.init(p.id, { max: p.max_concurrency }, {
+                queueTimeoutMs: p.queue_timeout_ms,
+                maxQueueSize: p.max_queue_size,
+            });
+        }
+        else if (p.max_concurrency > 0) {
             semaphoreManager.updateConfig(p.id, {
                 maxConcurrency: p.max_concurrency,
                 queueTimeoutMs: p.queue_timeout_ms,
@@ -194,6 +196,7 @@ export async function buildApp(options) {
         tracker,
         usageWindowTracker,
         sessionTracker,
+        adaptiveController,
     });
     app.register(anthropicProxy, {
         db,
@@ -204,8 +207,9 @@ export async function buildApp(options) {
         tracker,
         usageWindowTracker,
         sessionTracker,
+        adaptiveController,
     });
-    app.register(adminRoutes, { db, matcher, tracker, semaphoreManager });
+    app.register(adminRoutes, { db, matcher, tracker, semaphoreManager, adaptiveController });
     // 前端静态文件服务（生产环境）
     const frontendDist = path.resolve(process.env.FRONTEND_DIST || path.join(__dirname, "../frontend-dist"));
     if (existsSync(frontendDist)) {

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

@@ -31,7 +31,7 @@ export declare class SSEMetricsTransform extends Transform {
     _transform(chunk: Buffer, _encoding: BufferEncoding, callback: TransformCallback): void;
     _flush(callback: TransformCallback): void;
     getExtractor(): MetricsExtractor;
-    /** 提取 SSE 事件中的内容文本，触发 onContentDelta 回调 */
+    /** 从 SSE 事件中提取内容文本，触发 onContentDelta 回调 */
     private emitContentDelta;
     /**
      * 从 SSE data 字段中提取实际内容文本（thinking / text / tool JSON delta）。

package/dist/metrics/sse-metrics-transform.js

@@ -47,7 +47,6 @@ export class SSEMetricsTransform extends Transform {
             this.extractor.processEvent(event);
             this.emitContentDelta(event);
         }
-        // flush 无条件推送最终状态，确保消费者能拿到完整指标
         if (this.onMetrics && !this.flushed) {
             this.flushed = true;
             this.lastCallbackTime = Date.now();
@@ -58,7 +57,7 @@ export class SSEMetricsTransform extends Transform {
     getExtractor() {
         return this.extractor;
     }
-    /** 提取 SSE 事件中的内容文本，触发 onContentDelta 回调 */
+    /** 从 SSE 事件中提取内容文本，触发 onContentDelta 回调 */
     emitContentDelta(event) {
         if (!this.onContentDelta || !event.data)
             return;

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

@@ -2,6 +2,7 @@ import type { ServerResponse } from "node:http";
 import { StatsAggregator } from "./stats-aggregator.js";
 import { RuntimeCollector } from "./runtime-collector.js";
 import type { ProviderSemaphoreManager } from "../proxy/semaphore.js";
+import type { AdaptiveConcurrencyController } from "../proxy/adaptive-controller.js";
 import type { ActiveRequest, AttemptSnapshot, ProviderConcurrencySnapshot, RuntimeMetrics, StatsSnapshot } from "./types.js";
 export interface TrackerLogger {
     debug(obj: Record<string, unknown>, msg: string): void;
@@ -22,11 +23,13 @@ export declare class RequestTracker {
     readonly statsAggregator: StatsAggregator;
     readonly runtimeCollector: RuntimeCollector;
     private readonly semaphoreManager?;
+    private adaptiveController?;
     constructor(deps?: {
         semaphoreManager?: ProviderSemaphoreManager;
         runtimeCollector?: RuntimeCollector;
         logger?: TrackerLogger;
     });
+    setAdaptiveController(ctrl: AdaptiveConcurrencyController): void;
     start(req: ActiveRequest): void;
     /** 轻量级节流推送：流式内容变更后 500ms 内批量广播 */
     private scheduleStreamContentPush;

package/dist/monitor/request-tracker.js

@@ -22,12 +22,16 @@ export class RequestTracker {
     statsAggregator;
     runtimeCollector;
     semaphoreManager;
+    adaptiveController;
     constructor(deps) {
         this.semaphoreManager = deps?.semaphoreManager;
         this.runtimeCollector = deps?.runtimeCollector ?? new RuntimeCollector();
         this.statsAggregator = new StatsAggregator();
         this.logger = deps?.logger;
     }
+    setAdaptiveController(ctrl) {
+        this.adaptiveController = ctrl;
+    }
     // --- Core methods ---
     start(req) {
         this.activeMap.set(req.id, { ...req });
@@ -142,6 +146,7 @@ export class RequestTracker {
         const result = [];
         for (const [providerId, config] of this.providerConfigCache) {
             const status = this.semaphoreManager.getStatus(providerId);
+            const adaptiveState = this.adaptiveController?.getStatus(providerId);
             result.push({
                 providerId,
                 providerName: config.name,
@@ -150,6 +155,8 @@ export class RequestTracker {
                 queued: status.queued,
                 queueTimeoutMs: config.queueTimeoutMs,
                 maxQueueSize: config.maxQueueSize,
+                adaptiveEnabled: adaptiveState !== undefined,
+                adaptiveLimit: adaptiveState?.currentLimit,
             });
         }
         return result;

package/dist/monitor/types.d.ts

@@ -62,6 +62,8 @@ export interface ProviderConcurrencySnapshot {
     queued: number;
     queueTimeoutMs: number;
     maxQueueSize: number;
+    adaptiveEnabled?: boolean;
+    adaptiveLimit?: number;
 }
 export interface StatsSnapshot {
     totalRequests: number;

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

@@ -0,0 +1,42 @@
+import type { ProviderSemaphoreManager } from "./semaphore.js";
+export interface AdaptiveState {
+    currentLimit: number;
+    probeActive: boolean;
+    consecutiveSuccesses: number;
+    consecutiveFailures: number;
+    cooldownUntil: number;
+}
+interface AdaptiveResult {
+    success: boolean;
+    statusCode?: number;
+}
+export interface ProviderAdaptiveConfig {
+    adaptive_enabled: number;
+    max_concurrency: number;
+    queue_timeout_ms: number;
+    max_queue_size: number;
+}
+export interface ControllerLogger {
+    debug(obj: Record<string, unknown>, msg: string): void;
+    warn(obj: Record<string, unknown>, msg: string): void;
+}
+export declare class AdaptiveConcurrencyController {
+    private semaphoreManager;
+    private logger?;
+    private readonly entries;
+    constructor(semaphoreManager: ProviderSemaphoreManager, logger?: ControllerLogger | undefined);
+    init(providerId: string, config: {
+        max: number;
+    }, semParams: {
+        queueTimeoutMs: number;
+        maxQueueSize: number;
+    }): void;
+    remove(providerId: string): void;
+    onRequestComplete(providerId: string, result: AdaptiveResult): void;
+    getStatus(providerId: string): AdaptiveState | undefined;
+    syncProvider(providerId: string, p: ProviderAdaptiveConfig): void;
+    private transitionSuccess;
+    private transitionFailure;
+    private syncToSemaphore;
+}
+export {};

package/dist/proxy/adaptive-controller.js

@@ -0,0 +1,130 @@
+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 ADAPTIVE_MIN = 1;
+export class AdaptiveConcurrencyController {
+    semaphoreManager;
+    logger;
+    entries = new Map();
+    constructor(semaphoreManager, logger) {
+        this.semaphoreManager = semaphoreManager;
+        this.logger = logger;
+    }
+    init(providerId, config, semParams) {
+        this.entries.set(providerId, {
+            state: {
+                currentLimit: ADAPTIVE_MIN,
+                probeActive: false,
+                consecutiveSuccesses: 0,
+                consecutiveFailures: 0,
+                cooldownUntil: 0,
+            },
+            max: config.max,
+            queueTimeoutMs: semParams.queueTimeoutMs,
+            maxQueueSize: semParams.maxQueueSize,
+        });
+        this.syncToSemaphore(providerId);
+    }
+    remove(providerId) {
+        this.entries.delete(providerId);
+    }
+    onRequestComplete(providerId, result) {
+        const entry = this.entries.get(providerId);
+        if (!entry)
+            return;
+        if (result.success) {
+            this.transitionSuccess(providerId, entry);
+        }
+        else {
+            this.transitionFailure(providerId, entry, result.statusCode);
+        }
+    }
+    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.semaphoreManager.updateConfig(providerId, {
+                maxConcurrency: p.max_concurrency,
+                queueTimeoutMs: p.queue_timeout_ms,
+                maxQueueSize: p.max_queue_size,
+            });
+        }
+    }
+    transitionSuccess(providerId, entry) {
+        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;
+                this.logger?.debug({ providerId, currentLimit: s.currentLimit, action: "probe_open" }, "Adaptive: probe window opened");
+            }
+            else {
+                s.currentLimit = Math.min(s.currentLimit + 1, entry.max);
+                s.consecutiveSuccesses = 0;
+                this.logger?.debug({ providerId, currentLimit: s.currentLimit, max: entry.max, action: "limit_increased" }, "Adaptive: limit increased by 1");
+            }
+            this.syncToSemaphore(providerId);
+        }
+    }
+    transitionFailure(providerId, entry, statusCode) {
+        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, prevLimit, newLimit: s.currentLimit, cooldownMs: COOLDOWN_MS, 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, prevLimit, newLimit: s.currentLimit, 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.semaphoreManager.updateConfig(providerId, {
+            maxConcurrency: effectiveLimit,
+            queueTimeoutMs: entry.queueTimeoutMs,
+            maxQueueSize: entry.maxQueueSize,
+        });
+    }
+}

package/dist/proxy/anthropic.d.ts

@@ -4,6 +4,7 @@ import { RetryRuleMatcher } from "./retry-rules.js";
 import { ProviderSemaphoreManager } from "./semaphore.js";
 import type { RequestTracker } from "../monitor/request-tracker.js";
 import type { UsageWindowTracker } from "./usage-window-tracker.js";
+import type { AdaptiveConcurrencyController } from "./adaptive-controller.js";
 export interface AnthropicProxyOptions {
     db: Database.Database;
     streamTimeoutMs: number;
@@ -13,5 +14,6 @@ export interface AnthropicProxyOptions {
     tracker?: RequestTracker;
     usageWindowTracker?: UsageWindowTracker;
     sessionTracker?: import("./loop-prevention/session-tracker.js").SessionTracker;
+    adaptiveController?: AdaptiveConcurrencyController;
 }
 export declare const anthropicProxy: FastifyPluginCallback<AnthropicProxyOptions>;

package/dist/proxy/anthropic.js

@@ -18,8 +18,8 @@ const ANTHROPIC_ERROR_TYPE = {
 };
 const anthropicErrors = createErrorFormatter((kind, message) => ({ type: "error", error: { type: ANTHROPIC_ERROR_TYPE[kind], message } }));
 const anthropicProxyRaw = (app, opts, done) => {
-    const { db, streamTimeoutMs, retryBaseDelayMs, matcher, semaphoreManager, tracker, usageWindowTracker, sessionTracker } = opts;
-    const orchestrator = createOrchestrator(semaphoreManager, tracker);
+    const { db, streamTimeoutMs, retryBaseDelayMs, matcher, semaphoreManager, tracker, usageWindowTracker, sessionTracker, adaptiveController } = opts;
+    const orchestrator = createOrchestrator(semaphoreManager, tracker, adaptiveController);
     app.post(MESSAGES_PATH, async (request, reply) => {
         if (!orchestrator) {
             const body = request.body;

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

@@ -1,5 +1,6 @@
 import type { FastifyRequest } from "fastify";
 import Database from "better-sqlite3";
+import { type EnhancementConfig } from "../enhancement-config.js";
 export interface InterceptResponse {
     statusCode: number;
     body: unknown;
@@ -18,6 +19,6 @@ export interface EnhancementResult {
  * 在代理转发前应用代理增强逻辑（指令解析 + 会话记忆 + 模型替换 + 命令拦截）。
  * 仅当 proxy_enhancement.claude_code_enabled 开启时生效。
  */
-export declare function applyEnhancement(db: Database.Database, request: FastifyRequest, clientModel: string, sessionId?: string): EnhancementResult;
+export declare function applyEnhancement(db: Database.Database, request: FastifyRequest, clientModel: string, sessionId?: string, enhancementConfig?: EnhancementConfig): EnhancementResult;
 /** 生成注入到非流式响应中的模型信息标签 */
 export declare function buildModelInfoTag(effectiveModel: string): string;

package/dist/proxy/enhancement/enhancement-handler.js

@@ -60,9 +60,9 @@ function buildDisplayModels(db, allowedModelsRaw) {
  * 在代理转发前应用代理增强逻辑（指令解析 + 会话记忆 + 模型替换 + 命令拦截）。
  * 仅当 proxy_enhancement.claude_code_enabled 开启时生效。
  */
-export function applyEnhancement(db, request, clientModel, sessionId) {
+export function applyEnhancement(db, request, clientModel, sessionId, enhancementConfig) {
     const nullResult = { effectiveModel: clientModel, originalModel: null, interceptResponse: null };
-    const enhancement = loadEnhancementConfig(db);
+    const enhancement = enhancementConfig ?? loadEnhancementConfig(db);
     if (!enhancement.claude_code_enabled) {
         return nullResult;
     }