llm-simple-router 0.6.5 → 0.6.6

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/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/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,6 +20,7 @@ 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";
@@ -155,6 +156,8 @@ 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();
@@ -163,7 +166,13 @@ export async function buildApp(options) {
     // 从 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,
@@ -187,6 +196,7 @@ export async function buildApp(options) {
         tracker,
         usageWindowTracker,
         sessionTracker,
+        adaptiveController,
     });
     app.register(anthropicProxy, {
         db,
@@ -197,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/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/openai.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 OpenaiProxyOptions {
     db: Database.Database;
     streamTimeoutMs: number;
@@ -13,5 +14,6 @@ export interface OpenaiProxyOptions {
     tracker?: RequestTracker;
     usageWindowTracker?: UsageWindowTracker;
     sessionTracker?: import("./loop-prevention/session-tracker.js").SessionTracker;
+    adaptiveController?: AdaptiveConcurrencyController;
 }
 export declare const openaiProxy: FastifyPluginCallback<OpenaiProxyOptions>;

package/dist/proxy/openai.js

@@ -24,8 +24,8 @@ function sendError(reply, e) {
     return reply.code(e.statusCode).send(e.body);
 }
 const openaiProxyRaw = (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(CHAT_COMPLETIONS_PATH, async (request, reply) => {
         if (!orchestrator) {
             const body = request.body;

package/dist/proxy/orchestrator.d.ts

@@ -7,6 +7,7 @@ import type { SemaphoreScope } from "./scope.js";
 import type { TrackerScope } from "./scope.js";
 import type { ProviderSemaphoreManager } from "./semaphore.js";
 import type { RequestTracker } from "../monitor/request-tracker.js";
+import type { AdaptiveConcurrencyController } from "./adaptive-controller.js";
 export interface OrchestratorConfig {
     resolved: Target;
     provider: {
@@ -40,13 +41,14 @@ export interface HandleContext {
  * 工厂函数，消除 openai/anthropic 创建 orchestrator 的重复代码。
  * 两个 provider 的创建逻辑完全一致。
  */
-export declare function createOrchestrator(semaphoreManager?: ProviderSemaphoreManager, tracker?: RequestTracker): ProxyOrchestrator | undefined;
+export declare function createOrchestrator(semaphoreManager?: ProviderSemaphoreManager, tracker?: RequestTracker, adaptiveController?: AdaptiveConcurrencyController): ProxyOrchestrator | undefined;
 export declare class ProxyOrchestrator {
     private deps;
     constructor(deps: {
         semaphoreScope: SemaphoreScope;
         trackerScope: TrackerScope;
         resilience: ResilienceLayer;
+        adaptiveController?: AdaptiveConcurrencyController;
     });
     handle(request: FastifyRequest, reply: FastifyReply, apiType: "openai" | "anthropic", config: OrchestratorConfig, ctx?: HandleContext): Promise<ResilienceResult>;
     private buildActiveRequest;

package/dist/proxy/orchestrator.js

@@ -1,3 +1,4 @@
+import { ProviderSwitchNeeded } from "./types.js";
 import { ResilienceLayer as ResilienceLayerClass } from "./resilience.js";
 import { SemaphoreScope as SemaphoreScopeClass } from "./scope.js";
 import { TrackerScope as TrackerScopeClass } from "./scope.js";
@@ -7,12 +8,12 @@ const DEFAULT_FAILOVER_THRESHOLD = 400;
  * 工厂函数，消除 openai/anthropic 创建 orchestrator 的重复代码。
  * 两个 provider 的创建逻辑完全一致。
  */
-export function createOrchestrator(semaphoreManager, tracker) {
+export function createOrchestrator(semaphoreManager, tracker, adaptiveController) {
     const semaphoreScope = semaphoreManager ? new SemaphoreScopeClass(semaphoreManager) : undefined;
     const trackerScope = tracker ? new TrackerScopeClass(tracker) : undefined;
     if (!semaphoreScope || !trackerScope)
         return undefined;
-    return new ProxyOrchestrator({ semaphoreScope, trackerScope, resilience: new ResilienceLayerClass() });
+    return new ProxyOrchestrator({ semaphoreScope, trackerScope, resilience: new ResilienceLayerClass(), adaptiveController });
 }
 export class ProxyOrchestrator {
     deps;
@@ -20,24 +21,37 @@ export class ProxyOrchestrator {
         this.deps = deps;
     }
     async handle(request, reply, apiType, config, ctx) {
+        const providerId = config.provider.id;
         const trackerReq = this.buildActiveRequest(request, config, apiType);
-        const result = await this.deps.trackerScope.track(trackerReq, () => this.deps.semaphoreScope.withSlot(config.provider.id, this.createAbortSignal(request), () => {
-            trackerReq.queued = true;
-            this.deps.trackerScope.markQueued(trackerReq.id, true);
-        }, () => {
-            if (trackerReq.queued) {
-                trackerReq.queued = false;
-                this.deps.trackerScope.markQueued(trackerReq.id, false);
+        try {
+            const result = await this.deps.trackerScope.track(trackerReq, () => this.deps.semaphoreScope.withSlot(providerId, this.createAbortSignal(request), () => {
+                trackerReq.queued = true;
+                this.deps.trackerScope.markQueued(trackerReq.id, true);
+            }, () => {
+                if (trackerReq.queued) {
+                    trackerReq.queued = false;
+                    this.deps.trackerScope.markQueued(trackerReq.id, false);
+                }
+                return this.executeResilience(config, ctx);
+            }, config.concurrencyOverride), (result) => this.extractTrackStatus(result), (result) => result.attempts.map(a => ({
+                statusCode: a.statusCode,
+                error: a.error,
+                latencyMs: a.latencyMs,
+                providerId: a.target.provider_id,
+            })));
+            const { status, statusCode } = this.extractTrackStatus(result);
+            this.deps.adaptiveController?.onRequestComplete(providerId, { success: status === "completed", statusCode });
+            this.sendResponse(reply, result.result, ctx);
+            return result;
+        }
+        catch (e) {
+            if (e instanceof ProviderSwitchNeeded) {
+                const lastResult = e.lastResult;
+                const statusCode = lastResult && "statusCode" in lastResult ? lastResult.statusCode : undefined;
+                this.deps.adaptiveController?.onRequestComplete(providerId, { success: false, statusCode });
             }
-            return this.executeResilience(config, ctx);
-        }, config.concurrencyOverride), (result) => this.extractTrackStatus(result), (result) => result.attempts.map(a => ({
-            statusCode: a.statusCode,
-            error: a.error,
-            latencyMs: a.latencyMs,
-            providerId: a.target.provider_id,
-        })));
-        this.sendResponse(reply, result.result, ctx);
-        return result;
+            throw e;
+        }
     }
     buildActiveRequest(request, config, apiType) {
         return {

package/frontend-dist/assets/{CardContent-DG1NiXMU.js → CardContent-jQcfCC7J.js}

@@ -1 +1 @@
-import{G as e,It as t,J as n,Pt as r,lt as i,ot as a,r as o}from"./button-D4qBQ0nA.js";var s=[`data-size`],c=n({__name:`Card`,props:{class:{type:[Boolean,null,String,Object,Array]},size:{default:`default`}},setup(n){let c=n;return(l,u)=>(a(),e(`div`,{"data-slot":`card`,"data-size":n.size,class:t(r(o)(`ring-foreground/10 bg-card text-card-foreground gap-4 overflow-hidden rounded-lg py-4 text-sm ring-1 has-data-[slot=card-footer]:pb-0 has-[>img:first-child]:pt-0 data-[size=sm]:gap-3 data-[size=sm]:py-3 data-[size=sm]:has-data-[slot=card-footer]:pb-0 *:[img:first-child]:rounded-t-lg *:[img:last-child]:rounded-b-lg group/card flex flex-col`,c.class))},[i(l.$slots,`default`)],10,s))}}),l=n({__name:`CardContent`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(n){let s=n;return(n,c)=>(a(),e(`div`,{"data-slot":`card-content`,class:t(r(o)(`px-4 group-data-[size=sm]/card:px-3`,s.class))},[i(n.$slots,`default`)],2))}});export{c as n,l as t};
+import{G as e,It as t,J as n,Pt as r,lt as i,ot as a,r as o}from"./button-N59D1BGa.js";var s=[`data-size`],c=n({__name:`Card`,props:{class:{type:[Boolean,null,String,Object,Array]},size:{default:`default`}},setup(n){let c=n;return(l,u)=>(a(),e(`div`,{"data-slot":`card`,"data-size":n.size,class:t(r(o)(`ring-foreground/10 bg-card text-card-foreground gap-4 overflow-hidden rounded-lg py-4 text-sm ring-1 has-data-[slot=card-footer]:pb-0 has-[>img:first-child]:pt-0 data-[size=sm]:gap-3 data-[size=sm]:py-3 data-[size=sm]:has-data-[slot=card-footer]:pb-0 *:[img:first-child]:rounded-t-lg *:[img:last-child]:rounded-b-lg group/card flex flex-col`,c.class))},[i(l.$slots,`default`)],10,s))}}),l=n({__name:`CardContent`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(n){let s=n;return(n,c)=>(a(),e(`div`,{"data-slot":`card-content`,class:t(r(o)(`px-4 group-data-[size=sm]/card:px-3`,s.class))},[i(n.$slots,`default`)],2))}});export{c as n,l as t};

package/frontend-dist/assets/{CardTitle-6JvqGNd9.js → CardTitle-BrCTvULL.js}

@@ -1 +1 @@
-import{G as e,It as t,J as n,Pt as r,lt as i,ot as a,r as o}from"./button-D4qBQ0nA.js";var s=n({__name:`CardHeader`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(n){let s=n;return(n,c)=>(a(),e(`div`,{"data-slot":`card-header`,class:t(r(o)(`gap-1 rounded-t-xl px-4 group-data-[size=sm]/card:px-3 [.border-b]:pb-4 group-data-[size=sm]/card:[.border-b]:pb-3 group/card-header @container/card-header grid auto-rows-min items-start has-data-[slot=card-action]:grid-cols-[1fr_auto] has-data-[slot=card-description]:grid-rows-[auto_auto]`,s.class))},[i(n.$slots,`default`)],2))}}),c=n({__name:`CardTitle`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(n){let s=n;return(n,c)=>(a(),e(`div`,{"data-slot":`card-title`,class:t(r(o)(`text-base leading-snug font-medium group-data-[size=sm]/card:text-sm cn-font-heading`,s.class))},[i(n.$slots,`default`)],2))}});export{s as n,c as t};
+import{G as e,It as t,J as n,Pt as r,lt as i,ot as a,r as o}from"./button-N59D1BGa.js";var s=n({__name:`CardHeader`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(n){let s=n;return(n,c)=>(a(),e(`div`,{"data-slot":`card-header`,class:t(r(o)(`gap-1 rounded-t-xl px-4 group-data-[size=sm]/card:px-3 [.border-b]:pb-4 group-data-[size=sm]/card:[.border-b]:pb-3 group/card-header @container/card-header grid auto-rows-min items-start has-data-[slot=card-action]:grid-cols-[1fr_auto] has-data-[slot=card-description]:grid-rows-[auto_auto]`,s.class))},[i(n.$slots,`default`)],2))}}),c=n({__name:`CardTitle`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(n){let s=n;return(n,c)=>(a(),e(`div`,{"data-slot":`card-title`,class:t(r(o)(`text-base leading-snug font-medium group-data-[size=sm]/card:text-sm cn-font-heading`,s.class))},[i(n.$slots,`default`)],2))}});export{s as n,c as t};