llm-simple-router 0.2.0 → 0.3.5

package/dist/proxy/anthropic.d.ts

@@ -1,11 +1,15 @@
 import Database from "better-sqlite3";
 import type { FastifyPluginCallback } from "fastify";
 import { RetryRuleMatcher } from "./retry-rules.js";
+import { ProviderSemaphoreManager } from "./semaphore.js";
+import type { RequestTracker } from "../monitor/request-tracker.js";
 export interface AnthropicProxyOptions {
     db: Database.Database;
     streamTimeoutMs: number;
     retryMaxAttempts: number;
     retryBaseDelayMs: number;
     matcher?: RetryRuleMatcher;
+    semaphoreManager?: ProviderSemaphoreManager;
+    tracker?: RequestTracker;
 }
 export declare const anthropicProxy: FastifyPluginCallback<AnthropicProxyOptions>;

package/dist/proxy/anthropic.js

@@ -22,11 +22,19 @@ const anthropicErrors = {
         statusCode: 502,
         body: { type: "error", error: { type: "upstream_error", message: "Failed to connect to upstream service" } },
     }),
+    concurrencyQueueFull: (providerId) => ({
+        statusCode: 503,
+        body: { type: "error", error: { type: "api_error", message: `Provider '${providerId}' concurrency queue is full` } },
+    }),
+    concurrencyTimeout: (providerId, timeoutMs) => ({
+        statusCode: 504,
+        body: { type: "error", error: { type: "api_error", message: `Provider '${providerId}' concurrency wait timeout (${timeoutMs}ms)` } },
+    }),
 };
 const anthropicProxyRaw = (app, opts, done) => {
-    const { db, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher } = opts;
+    const { db, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher, semaphoreManager, tracker } = opts;
     app.post(MESSAGES_PATH, async (request, reply) => {
-        const deps = { db, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher };
+        const deps = { db, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher, semaphoreManager, tracker };
         return handleProxyPost(request, reply, "anthropic", MESSAGES_PATH, anthropicErrors, deps);
     });
     done();

package/dist/proxy/enhancement-handler.js

@@ -130,7 +130,9 @@ function buildSelectModelResponse(db, allowedModelsRaw, selectedModel) {
             if (parsed.length > 0)
                 allowedSet = new Set(parsed);
         }
-        catch { /* 忽略解析失败 */ }
+        catch {
+            return buildTextResponse("model-list", "（解析 allowed_models 失败）");
+        }
     }
     const filtered = allowedSet
         ? providerModels.filter(m => allowedSet.has(m.backend_model))

package/dist/proxy/mapping-resolver.js

@@ -29,7 +29,9 @@ export function resolveMapping(db, clientModel, context) {
                     return { backend_model: backendModel, provider_id: provider.id };
                 }
             }
-            catch { /* 忽略解析失败 */ }
+            catch {
+                return null;
+            }
         }
         // 明确的 provider/model 格式解析失败，不再 fallback 到 mapping group
         return null;
@@ -45,7 +47,9 @@ export function resolveMapping(db, clientModel, context) {
                     return { backend_model: clientModel, provider_id: p.id };
                 }
             }
-            catch { /* 忽略解析失败 */ }
+            catch {
+                break;
+            }
         }
         return null;
     }

package/dist/proxy/openai.d.ts

@@ -1,11 +1,15 @@
 import type { FastifyPluginCallback } from "fastify";
 import Database from "better-sqlite3";
 import { RetryRuleMatcher } from "./retry-rules.js";
+import { ProviderSemaphoreManager } from "./semaphore.js";
+import type { RequestTracker } from "../monitor/request-tracker.js";
 export interface OpenaiProxyOptions {
     db: Database.Database;
     streamTimeoutMs: number;
     retryMaxAttempts: number;
     retryBaseDelayMs: number;
     matcher?: RetryRuleMatcher;
+    semaphoreManager?: ProviderSemaphoreManager;
+    tracker?: RequestTracker;
 }
 export declare const openaiProxy: FastifyPluginCallback<OpenaiProxyOptions>;

package/dist/proxy/openai.js

@@ -28,14 +28,22 @@ const openaiErrors = {
         statusCode: 502,
         body: { error: { message: "Failed to connect to upstream service", type: "upstream_error", code: "upstream_connection_failed" } },
     }),
+    concurrencyQueueFull: (providerId) => ({
+        statusCode: 503,
+        body: { error: { message: `Provider '${providerId}' concurrency queue is full`, type: "server_error", code: "concurrency_queue_full" } },
+    }),
+    concurrencyTimeout: (providerId, timeoutMs) => ({
+        statusCode: 504,
+        body: { error: { message: `Provider '${providerId}' concurrency wait timeout (${timeoutMs}ms)`, type: "server_error", code: "concurrency_timeout" } },
+    }),
 };
 function sendError(reply, e) {
     return reply.status(e.statusCode).send(e.body);
 }
 const openaiProxyRaw = (app, opts, done) => {
-    const { db, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher } = opts;
+    const { db, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher, semaphoreManager, tracker } = opts;
     app.post(CHAT_COMPLETIONS_PATH, async (request, reply) => {
-        const deps = { db, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher };
+        const deps = { db, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher, semaphoreManager, tracker };
         return handleProxyPost(request, reply, "openai", CHAT_COMPLETIONS_PATH, openaiErrors, deps, {
             beforeSendProxy: (body, isStream) => {
                 if (isStream && !body.stream_options) {

package/dist/proxy/proxy-core.d.ts

@@ -3,6 +3,8 @@ import Database from "better-sqlite3";
 import type { Provider } from "../db/index.js";
 import type { RetryRuleMatcher } from "./retry-rules.js";
 import { type ProxyResult, type StreamProxyResult, type GetProxyResult } from "./upstream-call.js";
+import { ProviderSemaphoreManager } from "./semaphore.js";
+import type { RequestTracker } from "../monitor/request-tracker.js";
 export type RawHeaders = Record<string, string | string[] | undefined>;
 export interface ProxyErrorResponse {
     statusCode: number;
@@ -14,6 +16,8 @@ export interface ProxyErrorFormatter {
     providerUnavailable(): ProxyErrorResponse;
     providerTypeMismatch(): ProxyErrorResponse;
     upstreamConnectionFailed(): ProxyErrorResponse;
+    concurrencyQueueFull(providerId: string): ProxyErrorResponse;
+    concurrencyTimeout(providerId: string, timeoutMs: number): ProxyErrorResponse;
 }
 export interface ProxyHandlerDeps {
     db: Database.Database;
@@ -21,6 +25,8 @@ export interface ProxyHandlerDeps {
     retryMaxAttempts: number;
     retryBaseDelayMs: number;
     matcher?: RetryRuleMatcher;
+    semaphoreManager?: ProviderSemaphoreManager;
+    tracker?: RequestTracker;
 }
 export type { ProxyResult, StreamProxyResult, GetProxyResult };
 export declare const SKIP_UPSTREAM: Set<string>;

package/dist/proxy/proxy-core.js

@@ -10,9 +10,12 @@ import { SSEMetricsTransform } from "../metrics/sse-metrics-transform.js";
 import { proxyNonStream as upstreamNonStream, proxyStream as upstreamStream, proxyGetRequest as upstreamGet, } from "./upstream-call.js";
 import { insertSuccessLog, insertRejectedLog } from "./log-helpers.js";
 import { applyEnhancement, buildModelInfoTag } from "./enhancement-handler.js";
+import { SemaphoreQueueFullError, SemaphoreTimeoutError } from "./semaphore.js";
 // ---------- Constants ----------
 const UPSTREAM_SUCCESS = 200;
 const FAILOVER_FAIL_THRESHOLD = 400;
+const STREAM_CONTENT_MAX_RAW = 8192;
+const STREAM_CONTENT_MAX_TEXT = 4096;
 // ---------- Header utilities ----------
 export const SKIP_UPSTREAM = new Set([
     "host",
@@ -48,8 +51,95 @@ export function buildUpstreamHeaders(clientHeaders, apiKey, payloadBytes) {
 export function proxyGetRequest(backend, apiKey, clientHeaders, upstreamPath) {
     return upstreamGet(backend, apiKey, clientHeaders, upstreamPath, buildUpstreamHeaders);
 }
+// ---------- Helper functions for handleProxyPost ----------
+function handleIntercept(db, apiType, request, reply, interceptResponse, clientModel) {
+    const logId = randomUUID();
+    const isStream = request.body.stream === true;
+    const respBody = JSON.stringify(interceptResponse.body);
+    insertRequestLog(db, {
+        id: logId, api_type: apiType, model: clientModel, provider_id: "router",
+        status_code: interceptResponse.statusCode, latency_ms: 0,
+        is_stream: isStream ? 1 : 0, error_message: null,
+        created_at: new Date().toISOString(),
+        request_body: JSON.stringify(request.body),
+        response_body: respBody,
+        client_request: JSON.stringify({ headers: request.headers, body: request.body }),
+        upstream_request: interceptResponse.meta ? JSON.stringify(interceptResponse.meta) : null,
+        client_response: JSON.stringify({ statusCode: interceptResponse.statusCode, body: respBody }),
+        is_retry: 0, original_request_id: null,
+        router_key_id: request.routerKey?.id ?? null, original_model: null,
+    });
+    return reply.status(interceptResponse.statusCode).send(interceptResponse.body);
+}
+function logRetryAttempts(db, params, attempts, result, startTime) {
+    let lastSuccessLogId = params.logId;
+    for (const attempt of attempts) {
+        const isOriginal = attempt.attemptIndex === 0;
+        const attemptLogId = isOriginal ? params.logId : randomUUID();
+        if (attempt.error) {
+            insertRequestLog(db, {
+                id: attemptLogId, api_type: params.apiType, model: params.model, provider_id: params.providerId,
+                status_code: HTTP_BAD_GATEWAY, latency_ms: attempt.latencyMs,
+                is_stream: params.isStream ? 1 : 0, error_message: attempt.error,
+                created_at: new Date().toISOString(), request_body: params.reqBodyStr,
+                client_request: params.clientReq, upstream_request: params.upstreamReqBase,
+                is_retry: isOriginal ? 0 : 1, original_request_id: isOriginal ? null : params.logId,
+                router_key_id: params.routerKeyId, original_model: params.originalModel,
+            });
+        }
+        else if (attempt.statusCode !== UPSTREAM_SUCCESS) {
+            insertRequestLog(db, {
+                id: attemptLogId, api_type: params.apiType, model: params.model, provider_id: params.providerId,
+                status_code: attempt.statusCode, latency_ms: attempt.latencyMs,
+                is_stream: params.isStream ? 1 : 0, error_message: null,
+                created_at: new Date().toISOString(), request_body: params.reqBodyStr,
+                response_body: attempt.responseBody, client_request: params.clientReq, upstream_request: params.upstreamReqBase,
+                upstream_response: JSON.stringify({ statusCode: attempt.statusCode, body: attempt.responseBody }),
+                client_response: JSON.stringify({ statusCode: attempt.statusCode, body: attempt.responseBody }),
+                is_retry: isOriginal ? 0 : 1, original_request_id: isOriginal ? null : params.logId,
+                router_key_id: params.routerKeyId, original_model: params.originalModel,
+            });
+        }
+        else {
+            const h = params.isStream
+                ? (result.upstreamResponseHeaders ?? {})
+                : (result.headers);
+            insertSuccessLog(db, { apiType: params.apiType, model: params.model, provider: { id: params.providerId }, isStream: params.isStream, startTime,
+                reqBody: params.reqBodyStr, clientReq: params.clientReq, upstreamReq: params.upstreamReqBase, id: attemptLogId,
+                status: result.statusCode, respBody: attempt.responseBody, upHdrs: h, cliHdrs: h,
+                isRetry: !isOriginal, originalRequestId: isOriginal ? null : params.logId,
+                routerKeyId: params.routerKeyId, originalModel: params.originalModel });
+            lastSuccessLogId = attemptLogId;
+        }
+    }
+    return lastSuccessLogId;
+}
+function collectMetrics(db, apiType, result, isStream, lastSuccessLogId, providerId, backendModel, request) {
+    if (isStream) {
+        const streamResult = result;
+        if (streamResult.metricsResult) {
+            try {
+                insertMetrics(db, { ...streamResult.metricsResult, request_log_id: lastSuccessLogId, provider_id: providerId, backend_model: backendModel, api_type: apiType });
+            }
+            catch (err) {
+                request.log.error({ err }, "Failed to insert metrics");
+            }
+        }
+    }
+    else {
+        try {
+            const mr = MetricsExtractor.fromNonStreamResponse(apiType, result.body);
+            if (mr)
+                insertMetrics(db, { ...mr, request_log_id: lastSuccessLogId, provider_id: providerId, backend_model: backendModel, api_type: apiType });
+        }
+        catch (err) {
+            request.log.error({ err }, "Failed to insert metrics");
+        }
+    }
+}
 // ---------- Shared proxy handler ----------
 const HTTP_BAD_GATEWAY = 502;
+const HTTP_BAD_REQUEST = 400;
 /**
  * 共享 POST handler，参数化 apiType/errorFormat/upstreamPath 等差异。
  * 当分组策略为 failover 时，在 while 循环中依次尝试不同 target，
@@ -62,26 +152,8 @@ export async function handleProxyPost(request, reply, apiType, upstreamPath, err
     // 代理增强：指令解析 + 模型替换 + 命令拦截
     const sessionId = request.headers["x-claude-code-session-id"];
     const { effectiveModel, originalModel, interceptResponse } = applyEnhancement(db, request, clientModel, sessionId);
-    // 命令拦截（如 select-model）：直接返回，不转发上游
-    if (interceptResponse) {
-        const logId = randomUUID();
-        const isStream = request.body.stream === true;
-        const interceptRespBody = JSON.stringify(interceptResponse.body);
-        insertRequestLog(db, {
-            id: logId, api_type: apiType, model: clientModel, provider_id: "router",
-            status_code: interceptResponse.statusCode, latency_ms: 0,
-            is_stream: isStream ? 1 : 0, error_message: null,
-            created_at: new Date().toISOString(),
-            request_body: JSON.stringify(request.body),
-            response_body: interceptRespBody,
-            client_request: JSON.stringify({ headers: request.headers, body: request.body }),
-            upstream_request: interceptResponse.meta ? JSON.stringify(interceptResponse.meta) : null,
-            client_response: JSON.stringify({ statusCode: interceptResponse.statusCode, body: interceptRespBody }),
-            is_retry: 0, original_request_id: null,
-            router_key_id: request.routerKey?.id ?? null, original_model: null,
-        });
-        return reply.status(interceptResponse.statusCode).send(interceptResponse.body);
-    }
+    if (interceptResponse)
+        return handleIntercept(db, apiType, request, reply, interceptResponse, clientModel);
     // 查询分组策略（只查一次）
     const group = getMappingGroup(db, effectiveModel);
     const isFailover = group?.strategy === "failover";
@@ -142,6 +214,11 @@ export async function handleProxyPost(request, reply, apiType, upstreamPath, err
                 providerId: resolved.provider_id, originalModel });
             return reply.status(e.statusCode).send(e.body);
         }
+        deps.tracker?.start({
+            id: logId, apiType, model: effectiveModel, providerId: provider.id,
+            providerName: provider.name, isStream, startTime, status: "pending",
+            retryCount: 0, attempts: [], clientIp: request.ip,
+        });
         body.model = resolved.backend_model;
         const apiKey = decrypt(provider.api_key, getSetting(db, "encryption_key"));
         options?.beforeSendProxy?.(body, isStream);
@@ -149,56 +226,85 @@ export async function handleProxyPost(request, reply, apiType, upstreamPath, err
         const clientReq = JSON.stringify({ headers: cliHdrs, body: originalBody });
         const retryConfig = buildRetryConfig(retryMaxAttempts, retryBaseDelayMs, matcher);
         const upstreamReqBase = JSON.stringify({ url: `${provider.base_url}${upstreamPath}`, headers: buildUpstreamHeaders(cliHdrs, apiKey, Buffer.byteLength(reqBodyStr)), body: reqBodyStr });
+        // === Semaphore acquire ===
+        const semaphoreManager = deps.semaphoreManager;
+        let semaphoreReleased = false;
+        const releaseSemaphore = () => {
+            if (!semaphoreReleased) {
+                semaphoreReleased = true;
+                semaphoreManager?.release(provider.id);
+            }
+        };
+        if (semaphoreManager) {
+            const ac = new AbortController();
+            request.raw.on("close", () => ac.abort());
+            try {
+                await semaphoreManager.acquire(provider.id, ac.signal, () => {
+                    deps.tracker?.update(logId, { queued: true });
+                });
+                deps.tracker?.update(logId, { queued: false });
+            }
+            catch (err) {
+                if (err instanceof DOMException && err.name === "AbortError") {
+                    deps.tracker?.complete(logId, { status: "failed" });
+                    return reply;
+                }
+                if (err instanceof SemaphoreQueueFullError) {
+                    request.log.warn({ providerId: provider.id }, "Concurrency queue full, rejecting request");
+                    const e = errors.concurrencyQueueFull(provider.id);
+                    deps.tracker?.complete(logId, { status: "failed", statusCode: e.statusCode });
+                    return reply.status(e.statusCode).send(e.body);
+                }
+                if (err instanceof SemaphoreTimeoutError) {
+                    request.log.warn({ providerId: provider.id, timeoutMs: err.timeoutMs }, "Concurrency wait timed out");
+                    const e = errors.concurrencyTimeout(provider.id, err.timeoutMs);
+                    deps.tracker?.complete(logId, { status: "failed", statusCode: e.statusCode });
+                    return reply.status(e.statusCode).send(e.body);
+                }
+                throw err;
+            }
+        }
         try {
             const { result: r, attempts } = isStream
                 ? await retryableCall(() => {
-                    const metricsTransform = new SSEMetricsTransform(apiType, startTime);
+                    const metricsTransform = new SSEMetricsTransform(apiType, startTime, {
+                        onMetrics: (m) => {
+                            deps.tracker?.update(logId, {
+                                streamMetrics: {
+                                    inputTokens: m.input_tokens,
+                                    outputTokens: m.output_tokens,
+                                    ttftMs: m.ttft_ms,
+                                    stopReason: m.stop_reason,
+                                    isComplete: m.is_complete === 1,
+                                },
+                            });
+                        },
+                        onChunk: (rawLine) => {
+                            deps.tracker?.appendStreamChunk(logId, rawLine, apiType, STREAM_CONTENT_MAX_RAW, STREAM_CONTENT_MAX_TEXT);
+                        },
+                    });
                     return upstreamStream(provider, apiKey, body, cliHdrs, reply, streamTimeoutMs, upstreamPath, buildUpstreamHeaders, metricsTransform);
                 }, retryConfig, reply)
                 : await retryableCall(() => upstreamNonStream(provider, apiKey, body, cliHdrs, upstreamPath, buildUpstreamHeaders), retryConfig, reply);
-            // 记录所有尝试的日志
-            let lastSuccessLogId = logId;
-            for (const attempt of attempts) {
-                const isOriginal = attempt.attemptIndex === 0;
-                const attemptLogId = isOriginal ? logId : randomUUID();
-                if (attempt.error) {
-                    insertRequestLog(db, {
-                        id: attemptLogId, api_type: apiType, model: effectiveModel, provider_id: provider.id,
-                        status_code: HTTP_BAD_GATEWAY, latency_ms: attempt.latencyMs,
-                        is_stream: isStream ? 1 : 0, error_message: attempt.error,
-                        created_at: new Date().toISOString(), request_body: reqBodyStr,
-                        client_request: clientReq, upstream_request: upstreamReqBase,
-                        is_retry: isOriginal ? 0 : 1, original_request_id: isOriginal ? null : logId,
-                        router_key_id: routerKeyId, original_model: originalModel,
-                    });
-                }
-                else if (attempt.statusCode !== UPSTREAM_SUCCESS) {
-                    insertRequestLog(db, {
-                        id: attemptLogId, api_type: apiType, model: effectiveModel, provider_id: provider.id,
-                        status_code: attempt.statusCode, latency_ms: attempt.latencyMs,
-                        is_stream: isStream ? 1 : 0, error_message: null,
-                        created_at: new Date().toISOString(), request_body: reqBodyStr,
-                        response_body: attempt.responseBody, client_request: clientReq, upstream_request: upstreamReqBase,
-                        upstream_response: JSON.stringify({ statusCode: attempt.statusCode, body: attempt.responseBody }),
-                        client_response: JSON.stringify({ statusCode: attempt.statusCode, body: attempt.responseBody }),
-                        is_retry: isOriginal ? 0 : 1, original_request_id: isOriginal ? null : logId,
-                        router_key_id: routerKeyId, original_model: originalModel,
-                    });
-                }
-                else {
-                    const h = isStream
-                        ? (r.upstreamResponseHeaders ?? {})
-                        : (r.headers);
-                    insertSuccessLog(db, { apiType, model: effectiveModel, provider, isStream, startTime,
-                        reqBody: reqBodyStr, clientReq, upstreamReq: upstreamReqBase, id: attemptLogId,
-                        status: r.statusCode, respBody: attempt.responseBody, upHdrs: h, cliHdrs: h,
-                        isRetry: !isOriginal, originalRequestId: isOriginal ? null : logId,
-                        routerKeyId, originalModel });
-                    lastSuccessLogId = attemptLogId;
-                }
-            }
+            const trackerAttempts = attempts.map(a => ({
+                statusCode: a.statusCode ?? null,
+                error: a.error ?? null,
+                latencyMs: a.latencyMs,
+                providerId: provider.id,
+            }));
+            deps.tracker?.update(logId, {
+                retryCount: Math.max(0, attempts.length - 1),
+                attempts: trackerAttempts,
+                providerId: provider.id,
+            });
+            const lastSuccessLogId = logRetryAttempts(db, {
+                apiType, model: effectiveModel, providerId: provider.id, isStream,
+                reqBodyStr, clientReq, upstreamReqBase, logId, routerKeyId, originalModel,
+            }, attempts, r, startTime);
             // --- Failover 检查 ---
             if (isFailover && r.statusCode >= FAILOVER_FAIL_THRESHOLD && !reply.raw.headersSent) {
+                deps.tracker?.complete(logId, { status: "failed", statusCode: r.statusCode });
+                releaseSemaphore();
                 excludeTargets.push(resolved);
                 continue;
             }
@@ -227,32 +333,13 @@ export async function handleProxyPost(request, reply, apiType, upstreamPath, err
                 }
                 for (const [k, v] of Object.entries(pr.headers))
                     reply.header(k, v);
-                return reply.status(pr.statusCode).send(pr.body);
+                reply.status(pr.statusCode).send(pr.body);
             }
-            // metrics 采集
             if (r.statusCode === UPSTREAM_SUCCESS) {
-                if (isStream) {
-                    const streamResult = r;
-                    if (streamResult.metricsResult) {
-                        try {
-                            insertMetrics(db, { ...streamResult.metricsResult, request_log_id: lastSuccessLogId, provider_id: provider.id, backend_model: resolved.backend_model, api_type: apiType });
-                        }
-                        catch (err) {
-                            request.log.error({ err }, "Failed to insert metrics");
-                        }
-                    }
-                }
-                else {
-                    try {
-                        const mr = MetricsExtractor.fromNonStreamResponse(apiType, r.body);
-                        if (mr)
-                            insertMetrics(db, { ...mr, request_log_id: lastSuccessLogId, provider_id: provider.id, backend_model: resolved.backend_model, api_type: apiType });
-                    }
-                    catch (err) {
-                        request.log.error({ err }, "Failed to insert metrics");
-                    }
-                }
+                collectMetrics(db, apiType, r, isStream, lastSuccessLogId, provider.id, resolved.backend_model, request);
             }
+            deps.tracker?.complete(logId, { status: r.statusCode < HTTP_BAD_REQUEST ? "completed" : "failed", statusCode: r.statusCode });
+            releaseSemaphore();
             return reply;
         }
         catch (err) {
@@ -269,10 +356,14 @@ export async function handleProxyPost(request, reply, apiType, upstreamPath, err
             });
             // --- Failover 检查（异常路径）---
             if (isFailover && !reply.raw.headersSent) {
+                deps.tracker?.complete(logId, { status: "failed" });
+                releaseSemaphore();
                 excludeTargets.push(resolved);
                 continue;
             }
             const e = errors.upstreamConnectionFailed();
+            deps.tracker?.complete(logId, { status: "failed", statusCode: HTTP_BAD_GATEWAY });
+            releaseSemaphore();
             return reply.status(e.statusCode).send(e.body);
         }
     }

package/dist/proxy/retry.d.ts

@@ -24,7 +24,7 @@ export interface RetryStrategy {
 export declare class FixedIntervalStrategy implements RetryStrategy {
     private delayMs;
     constructor(delayMs: number);
-    getDelay(_attempt: number): number;
+    getDelay(): number;
 }
 export declare class ExponentialBackoffStrategy implements RetryStrategy {
     private baseMs;

package/dist/proxy/retry.js

@@ -3,8 +3,9 @@ export class FixedIntervalStrategy {
     constructor(delayMs) {
         this.delayMs = delayMs;
     }
-    getDelay(_attempt) { return this.delayMs; }
+    getDelay() { return this.delayMs; }
 }
+const EXPONENTIAL_BASE = 2;
 export class ExponentialBackoffStrategy {
     baseMs;
     capMs;
@@ -13,7 +14,7 @@ export class ExponentialBackoffStrategy {
         this.capMs = capMs;
     }
     getDelay(attempt) {
-        return Math.min(this.baseMs * 2 ** attempt, this.capMs);
+        return Math.min(this.baseMs * EXPONENTIAL_BASE ** attempt, this.capMs);
     }
 }
 export function createStrategy(rule) {

package/dist/proxy/semaphore.d.ts

@@ -0,0 +1,27 @@
+export declare class SemaphoreQueueFullError extends Error {
+    readonly providerId: string;
+    constructor(providerId: string);
+}
+export declare class SemaphoreTimeoutError extends Error {
+    readonly providerId: string;
+    readonly timeoutMs: number;
+    constructor(providerId: string, timeoutMs: number);
+}
+interface ConcurrencyConfig {
+    maxConcurrency: number;
+    queueTimeoutMs: number;
+    maxQueueSize: number;
+}
+export declare class ProviderSemaphoreManager {
+    private readonly entries;
+    private getOrCreate;
+    updateConfig(providerId: string, config: ConcurrencyConfig): void;
+    acquire(providerId: string, signal?: AbortSignal, onQueued?: () => void): Promise<void>;
+    release(providerId: string): void;
+    getStatus(providerId: string): {
+        active: number;
+        queued: number;
+    };
+    remove(providerId: string): void;
+}
+export {};

package/dist/proxy/semaphore.js

@@ -0,0 +1,125 @@
+export class SemaphoreQueueFullError extends Error {
+    providerId;
+    constructor(providerId) {
+        super(`Provider '${providerId}' concurrency queue is full`);
+        this.providerId = providerId;
+        this.name = "SemaphoreQueueFullError";
+    }
+}
+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";
+    }
+}
+export class ProviderSemaphoreManager {
+    entries = new Map();
+    getOrCreate(providerId) {
+        let entry = this.entries.get(providerId);
+        if (!entry) {
+            entry = {
+                config: { maxConcurrency: 0, queueTimeoutMs: 0, maxQueueSize: 0 },
+                current: 0,
+                queue: [],
+            };
+            this.entries.set(providerId, entry);
+        }
+        return entry;
+    }
+    updateConfig(providerId, config) {
+        const entry = this.getOrCreate(providerId);
+        entry.config = config;
+        if (config.maxConcurrency === 0) {
+            // Admin disabled throttling — drain queue without counting, reset current
+            // because no tracking is needed when maxConcurrency=0
+            while (entry.queue.length > 0) {
+                const e = entry.queue.shift();
+                if (e.timer)
+                    clearTimeout(e.timer);
+                e.resolve();
+            }
+            entry.current = 0;
+            return;
+        }
+        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) {
+        const entry = this.getOrCreate(providerId);
+        const { maxConcurrency, queueTimeoutMs, maxQueueSize } = entry.config;
+        if (maxConcurrency === 0)
+            return;
+        if (entry.current < maxConcurrency) {
+            entry.current++;
+            return;
+        }
+        if (entry.queue.length >= maxQueueSize) {
+            throw new SemaphoreQueueFullError(providerId);
+        }
+        onQueued?.();
+        return new Promise((resolve, reject) => {
+            const qe = { resolve, reject, 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) {
+        const entry = this.entries.get(providerId);
+        if (!entry)
+            return;
+        if (entry.queue.length > 0) {
+            const e = entry.queue.shift();
+            if (e.timer)
+                clearTimeout(e.timer);
+            e.resolve();
+        }
+        else {
+            entry.current--;
+        }
+    }
+    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);
+    }
+}