llm-simple-router 0.5.0 → 0.5.2

package/dist/proxy/proxy-handler.js

@@ -3,19 +3,27 @@ import { getMappingGroup, getProviderById, insertRequestLog } from "../db/index.
 import { decrypt } from "../utils/crypto.js";
 import { getSetting } from "../db/settings.js";
 import { resolveMapping } from "./mapping-resolver.js";
-import { applyEnhancement, buildModelInfoTag } from "./enhancement-handler.js";
+import { applyEnhancement } from "./enhancement/enhancement-handler.js";
 import { SemaphoreQueueFullError, SemaphoreTimeoutError } from "./semaphore.js";
 import { logResilienceResult, collectTransportMetrics, handleIntercept, sanitizeHeadersForLog, } from "./proxy-logging.js";
 import { buildUpstreamHeaders } from "./proxy-core.js";
-import { UPSTREAM_SUCCESS, ProviderSwitchNeeded } from "./types.js";
-import { SSEMetricsTransform } from "../metrics/sse-metrics-transform.js";
-import { MetricsExtractor } from "../metrics/metrics-extractor.js";
+import { ProviderSwitchNeeded } from "./types.js";
 import { updateLogStreamContent } from "../db/index.js";
-import { callNonStream, callStream } from "./transport.js";
 import { insertRejectedLog } from "./log-helpers.js";
+import { buildTransportFn } from "./transport-fn.js";
 const HTTP_ERROR_THRESHOLD = 400;
-const STREAM_CONTENT_MAX_RAW = 131072;
-const STREAM_CONTENT_MAX_TEXT = 65536;
+function rejectAndReply(reply, params, error, errorMessage, providerId) {
+    insertRejectedLog({
+        db: params.db, logId: params.logId, apiType: params.apiType, model: params.model,
+        statusCode: error.statusCode, errorMessage, startTime: params.startTime,
+        isStream: params.isStream, routerKeyId: params.routerKeyId,
+        originalBody: params.originalBody, clientHeaders: params.clientHeaders,
+        providerId, originalModel: params.originalModel,
+        isFailover: params.isFailover, originalRequestId: params.originalRequestId,
+        sessionId: params.sessionId,
+    });
+    return reply.code(error.statusCode).send(error.body);
+}
 /** 将 tracker blocks 序列化为前端 tryDirectParse 可解析的 JSON */
 function serializeBlocksForStorage(blocks, apiType) {
     if (!blocks || blocks.length === 0)
@@ -39,17 +47,7 @@ function serializeBlocksForStorage(blocks, apiType) {
     const text = blocks.filter(b => b.type === "text").map(b => b.content).join("");
     return JSON.stringify({ choices: [{ message: { content: text } }] });
 }
-function toStreamMetrics(m) {
-    return {
-        inputTokens: m.input_tokens,
-        outputTokens: m.output_tokens,
-        cacheReadTokens: m.cache_read_tokens,
-        ttftMs: m.ttft_ms,
-        tokensPerSecond: m.tokens_per_second,
-        stopReason: m.stop_reason,
-        isComplete: m.is_complete === 1,
-    };
-}
+// ---------- Main entry ----------
 export async function handleProxyRequest(request, reply, apiType, upstreamPath, errors, deps, options) {
     request.raw.socket.on("error", (err) => request.log.debug({ err }, "client socket error"));
     const clientModel = request.body.model || "unknown";
@@ -58,9 +56,18 @@ export async function handleProxyRequest(request, reply, apiType, upstreamPath,
     if (interceptResponse)
         return handleIntercept(deps.db, apiType, request, reply, interceptResponse, clientModel, sessionId);
     const group = getMappingGroup(deps.db, effectiveModel);
-    const isFailover = group?.strategy === "failover";
+    return executeFailoverLoop({
+        request, reply, apiType, upstreamPath, errors, deps, options,
+        effectiveModel, originalModel,
+        isFailover: group?.strategy === "failover",
+        originalBody: JSON.parse(JSON.stringify(request.body)),
+        sessionId,
+    });
+}
+// ---------- Failover loop ----------
+async function executeFailoverLoop(ctx) {
+    const { request, reply, apiType, upstreamPath, errors, deps, options, effectiveModel, originalModel, isFailover, originalBody, sessionId } = ctx;
     const excludeTargets = [];
-    const originalBody = JSON.parse(JSON.stringify(request.body));
     let rootLogId = null;
     while (true) {
         const startTime = Date.now();
@@ -72,27 +79,18 @@ export async function handleProxyRequest(request, reply, apiType, upstreamPath,
         const body = request.body;
         const isStream = body.stream === true;
         const cliHdrs = request.headers;
+        const rCtx = {
+            db: deps.db, logId, apiType, model: effectiveModel,
+            startTime, isStream, routerKeyId, originalBody, clientHeaders: cliHdrs, originalModel,
+            isFailover: isFailoverIteration, originalRequestId: isFailoverIteration ? rootLogId : null, sessionId,
+        };
         const resolved = resolveMapping(deps.db, effectiveModel, { now: new Date(), excludeTargets });
         request.log.debug({ logId, model: effectiveModel, apiType, isStream, action: "resolve_mapping", resolved: !!resolved });
         if (!resolved) {
             if (isFailover && excludeTargets.length > 0) {
-                const e = errors.upstreamConnectionFailed();
-                insertRejectedLog({
-                    db: deps.db, logId, apiType, model: effectiveModel, statusCode: e.statusCode,
-                    errorMessage: `All failover targets exhausted (${excludeTargets.length} attempted)`,
-                    startTime, isStream, routerKeyId, originalBody, clientHeaders: cliHdrs, originalModel,
-                    isFailover: true, originalRequestId: rootLogId, sessionId,
-                });
-                return reply.status(e.statusCode).send(e.body);
+                return rejectAndReply(reply, { ...rCtx, isFailover: true, originalRequestId: rootLogId }, errors.upstreamConnectionFailed(), `All failover targets exhausted (${excludeTargets.length} attempted)`);
             }
-            const e = errors.modelNotFound(effectiveModel);
-            insertRejectedLog({
-                db: deps.db, logId, apiType, model: effectiveModel, statusCode: e.statusCode,
-                errorMessage: `No mapping found for model '${effectiveModel}'`, startTime, isStream,
-                routerKeyId, originalBody, clientHeaders: cliHdrs, originalModel,
-                isFailover: isFailoverIteration, originalRequestId: isFailoverIteration ? rootLogId : null, sessionId,
-            });
-            return reply.status(e.statusCode).send(e.body);
+            return rejectAndReply(reply, rCtx, errors.modelNotFound(effectiveModel), `No mapping found for model '${effectiveModel}'`);
         }
         if (excludeTargets.length === 0) {
             const allowedModels = request.routerKey?.allowed_models;
@@ -100,14 +98,7 @@ export async function handleProxyRequest(request, reply, apiType, upstreamPath,
                 try {
                     const models = JSON.parse(allowedModels).filter((m) => m.trim() !== "");
                     if (models.length > 0 && !models.includes(resolved.backend_model)) {
-                        const e = errors.modelNotAllowed(resolved.backend_model);
-                        insertRejectedLog({
-                            db: deps.db, logId, apiType, model: effectiveModel, statusCode: e.statusCode,
-                            errorMessage: `Model '${resolved.backend_model}' not allowed`, startTime, isStream, routerKeyId,
-                            originalBody, clientHeaders: cliHdrs, providerId: resolved.provider_id, originalModel,
-                            isFailover: isFailoverIteration, originalRequestId: isFailoverIteration ? rootLogId : null, sessionId,
-                        });
-                        return reply.status(e.statusCode).send(e.body);
+                        return rejectAndReply(reply, rCtx, errors.modelNotAllowed(resolved.backend_model), `Model '${resolved.backend_model}' not allowed`, resolved.provider_id);
                     }
                 }
                 catch {
@@ -117,24 +108,10 @@ export async function handleProxyRequest(request, reply, apiType, upstreamPath,
         }
         const provider = getProviderById(deps.db, resolved.provider_id);
         if (!provider || !provider.is_active) {
-            const e = errors.providerUnavailable();
-            insertRejectedLog({
-                db: deps.db, logId, apiType, model: effectiveModel, statusCode: e.statusCode,
-                errorMessage: `Provider '${resolved.provider_id}' unavailable`, startTime, isStream, routerKeyId,
-                originalBody, clientHeaders: cliHdrs, providerId: resolved.provider_id, originalModel,
-                isFailover: isFailoverIteration, originalRequestId: isFailoverIteration ? rootLogId : null, sessionId,
-            });
-            return reply.status(e.statusCode).send(e.body);
+            return rejectAndReply(reply, rCtx, errors.providerUnavailable(), `Provider '${resolved.provider_id}' unavailable`, resolved.provider_id);
         }
         if (provider.api_type !== apiType) {
-            const e = errors.providerTypeMismatch();
-            insertRejectedLog({
-                db: deps.db, logId, apiType, model: effectiveModel, statusCode: e.statusCode,
-                errorMessage: `API type mismatch: expected '${apiType}'`, startTime, isStream, routerKeyId,
-                originalBody, clientHeaders: cliHdrs, providerId: resolved.provider_id, originalModel,
-                isFailover: isFailoverIteration, originalRequestId: isFailoverIteration ? rootLogId : null, sessionId,
-            });
-            return reply.status(e.statusCode).send(e.body);
+            return rejectAndReply(reply, rCtx, errors.providerTypeMismatch(), `API type mismatch: expected '${apiType}'`, resolved.provider_id);
         }
         body.model = resolved.backend_model;
         const apiKey = decrypt(provider.api_key, getSetting(deps.db, "encryption_key"));
@@ -146,63 +123,23 @@ export async function handleProxyRequest(request, reply, apiType, upstreamPath,
             headers: sanitizeHeadersForLog(buildUpstreamHeaders(cliHdrs, apiKey, Buffer.byteLength(reqBodyStr))),
             body: reqBodyStr,
         });
-        // transportFn 闭包捕获当前迭代的 provider/apiKey/headers/body/reply 上下文
-        // target 由 resilience 层传入但当前架构下 provider 已在闭包中确定
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const transportFn = async (_target) => {
-            if (isStream) {
-                const metricsTransform = new SSEMetricsTransform(apiType, startTime, {
-                    onMetrics: (m) => {
-                        deps.tracker?.update(logId, { streamMetrics: toStreamMetrics(m) });
-                    },
-                    onChunk: (rawLine) => {
-                        deps.tracker?.appendStreamChunk(logId, rawLine, apiType, STREAM_CONTENT_MAX_RAW, STREAM_CONTENT_MAX_TEXT);
-                    },
-                });
-                const checkEarlyError = deps.matcher
-                    ? (data) => deps.matcher.test(UPSTREAM_SUCCESS, data)
-                    : undefined;
-                const streamResult = await callStream(provider, apiKey, body, cliHdrs, reply, deps.streamTimeoutMs, upstreamPath, buildUpstreamHeaders, metricsTransform, checkEarlyError);
-                const m = (streamResult.kind === "stream_success" || streamResult.kind === "stream_abort")
-                    ? streamResult.metrics : undefined;
-                if (m)
-                    deps.tracker?.update(logId, { streamMetrics: toStreamMetrics(m) });
-                return streamResult;
-            }
-            const result = await callNonStream(provider, apiKey, body, cliHdrs, upstreamPath, buildUpstreamHeaders);
-            // 非流式请求：从响应体提取指标并更新 tracker
-            if (result.kind === "success") {
-                const mr = MetricsExtractor.fromNonStreamResponse(apiType, result.body);
-                if (mr) {
-                    deps.tracker?.update(logId, { streamMetrics: toStreamMetrics(mr) });
-                }
-            }
-            // 非流式响应注入模型信息标签（模型映射场景）
-            if (originalModel && result.kind === "success" && result.statusCode === UPSTREAM_SUCCESS) {
-                try {
-                    const bodyObj = JSON.parse(result.body);
-                    if (bodyObj.content?.[0]?.text) {
-                        bodyObj.content[0].text += `\n\n${buildModelInfoTag(effectiveModel)}`;
-                        return { ...result, body: JSON.stringify(bodyObj) };
-                    }
-                }
-                catch {
-                    request.log.debug("Failed to inject model-info tag into non-JSON response");
-                }
-            }
-            return result;
-        };
+        const transportFn = buildTransportFn({
+            provider, apiKey, body, cliHdrs, reply, upstreamPath, apiType,
+            isStream, startTime, logId, effectiveModel, originalModel,
+            streamTimeoutMs: deps.streamTimeoutMs, tracker: deps.tracker, matcher: deps.matcher, request,
+        });
         try {
-            const resilienceResult = await deps.orchestrator.handle(request, reply, apiType, { resolved, provider, clientModel: effectiveModel, isStream, trackerId: logId, sessionId, clientRequest: clientReq }, { retryMaxAttempts: deps.retryMaxAttempts, retryBaseDelayMs: deps.retryBaseDelayMs, isFailover, ruleMatcher: deps.matcher, transportFn });
+            const resilienceResult = await deps.orchestrator.handle(request, reply, apiType, { resolved, provider, clientModel: effectiveModel, isStream, trackerId: logId, sessionId, clientRequest: clientReq }, { retryBaseDelayMs: deps.retryBaseDelayMs, isFailover, ruleMatcher: deps.matcher, transportFn });
             const lastLogId = logResilienceResult(deps.db, {
                 apiType, model: effectiveModel, providerId: provider.id, isStream,
                 clientReq, upstreamReqBase, logId, routerKeyId, originalModel, sessionId,
                 failover: { isFailoverIteration, rootLogId: rootLogId },
             }, resilienceResult.attempts, resilienceResult.result, startTime);
             collectTransportMetrics(deps.db, apiType, resilienceResult.result, isStream, lastLogId, provider.id, resolved.backend_model, request);
-            // 流式请求：将 tracker 中累积的内容持久化到日志
-            // blocks 含非 text 类型时（thinking/tool_use）必须序列化为 JSON 以保留结构
-            // 注意：tracker 在原 logId 下累积内容，lastLogId 可能因 resilience 重试而指向不同记录
+            const tr = resilienceResult.result;
+            const succeeded = tr.kind === "success" || tr.kind === "stream_success" || tr.kind === "stream_abort";
+            if (succeeded)
+                deps.usageWindowTracker?.recordRequest(routerKeyId ?? undefined);
             if (isStream && deps.tracker) {
                 const sc = deps.tracker.get(logId)?.streamContent;
                 const blocks = sc?.blocks;
@@ -213,7 +150,6 @@ export async function handleProxyRequest(request, reply, apiType, upstreamPath,
                 if (content)
                     updateLogStreamContent(deps.db, lastLogId, content);
             }
-            // Failover: 单 provider 内重试已耗尽但仍失败，尝试下一个 target
             if (isFailover && !reply.raw.headersSent) {
                 const tr = resilienceResult.result;
                 const failed = tr.kind === "throw"
@@ -224,12 +160,12 @@ export async function handleProxyRequest(request, reply, apiType, upstreamPath,
                 }
             }
             // orchestrator.sendResponse 对 throw/stream_success/stream_abort 不发送，
-            // 对非 failover 的 error/throw 需要由外层发送错误响应
+            // 对 failover 场景的错误也不发送——这些情况需要外层 proxy-handler 处理
             if (!reply.raw.headersSent) {
                 const tr = resilienceResult.result;
                 if (tr.kind === "throw" || (tr.kind === "error" && tr.statusCode >= HTTP_ERROR_THRESHOLD)) {
                     const err = errors.upstreamConnectionFailed();
-                    return reply.status(err.statusCode).send(err.body);
+                    return reply.code(err.statusCode).send(err.body);
                 }
             }
             return reply;
@@ -241,26 +177,10 @@ export async function handleProxyRequest(request, reply, apiType, upstreamPath,
                 continue;
             }
             if (e instanceof SemaphoreQueueFullError) {
-                const err = errors.concurrencyQueueFull(provider.id);
-                insertRejectedLog({
-                    db: deps.db, logId, apiType, model: effectiveModel, statusCode: err.statusCode,
-                    errorMessage: `Concurrency queue full for provider '${provider.id}'`,
-                    startTime, isStream, routerKeyId, originalBody, clientHeaders: cliHdrs,
-                    providerId: provider.id, originalModel,
-                    isFailover: isFailoverIteration, originalRequestId: isFailoverIteration ? rootLogId : null, sessionId,
-                });
-                return reply.status(err.statusCode).send(err.body);
+                return rejectAndReply(reply, rCtx, errors.concurrencyQueueFull(provider.id), `Concurrency queue full for provider '${provider.id}'`, provider.id);
             }
             if (e instanceof SemaphoreTimeoutError) {
-                const err = errors.concurrencyTimeout(provider.id, e.timeoutMs);
-                insertRejectedLog({
-                    db: deps.db, logId, apiType, model: effectiveModel, statusCode: err.statusCode,
-                    errorMessage: `Concurrency wait timeout for provider '${provider.id}' (${e.timeoutMs}ms)`,
-                    startTime, isStream, routerKeyId, originalBody, clientHeaders: cliHdrs,
-                    providerId: provider.id, originalModel,
-                    isFailover: isFailoverIteration, originalRequestId: isFailoverIteration ? rootLogId : null, sessionId,
-                });
-                return reply.status(err.statusCode).send(err.body);
+                return rejectAndReply(reply, rCtx, errors.concurrencyTimeout(provider.id, e.timeoutMs), `Concurrency wait timeout for provider '${provider.id}' (${e.timeoutMs}ms)`, provider.id);
             }
             const errMsg = e instanceof Error ? e.message : String(e);
             request.log.debug({ logId, error: errMsg, action: "upstream_error" });
@@ -274,7 +194,7 @@ export async function handleProxyRequest(request, reply, apiType, upstreamPath,
                 session_id: sessionId,
             });
             const err = errors.upstreamConnectionFailed();
-            return reply.status(err.statusCode).send(err.body);
+            return reply.code(err.statusCode).send(err.body);
         }
     }
 }

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

@@ -3,8 +3,6 @@ import { type FailoverContext } from "./log-helpers.js";
 import type { FastifyRequest } from "fastify";
 import type { ResilienceAttempt } from "./resilience.js";
 import type { TransportResult } from "./types.js";
-export { UPSTREAM_SUCCESS } from "./types.js";
-export type { RawHeaders } from "./types.js";
 /** 日志存储前脱敏 Authorization header，避免 API Key 被持久化 */
 export declare function sanitizeHeadersForLog(headers: Record<string, string>): Record<string, string>;
 export declare function handleIntercept(db: Database.Database, apiType: "openai" | "anthropic", request: FastifyRequest, reply: import("fastify").FastifyReply, interceptResponse: {

package/dist/proxy/proxy-logging.js

@@ -2,8 +2,6 @@ import { randomUUID } from "crypto";
 import { insertRequestLog, insertMetrics, updateLogMetrics } from "../db/index.js";
 import { insertSuccessLog } from "./log-helpers.js";
 import { MetricsExtractor } from "../metrics/metrics-extractor.js";
-// Re-export shared constants & types from types.ts (canonical home)
-export { UPSTREAM_SUCCESS } from "./types.js";
 // Internal imports from types.ts
 import { UPSTREAM_SUCCESS } from "./types.js";
 import { HTTP_BAD_GATEWAY } from "../constants.js";
@@ -34,7 +32,7 @@ export function handleIntercept(db, apiType, request, reply, interceptResponse,
         router_key_id: request.routerKey?.id ?? null, original_model: null,
         session_id: sessionId,
     });
-    return reply.status(interceptResponse.statusCode).send(interceptResponse.body);
+    return reply.code(interceptResponse.statusCode).send(interceptResponse.body);
 }
 // ---------- New-architecture logging ----------
 export function logResilienceResult(db, params, attempts, result, startTime) {

package/dist/proxy/resilience.d.ts

@@ -7,7 +7,7 @@ export interface RetryStrategy {
 export declare class FixedIntervalStrategy implements RetryStrategy {
     private delayMs;
     constructor(delayMs: number);
-    getDelay(): number;
+    getDelay(_attempt: number): number;
 }
 export declare class ExponentialBackoffStrategy implements RetryStrategy {
     private baseMs;
@@ -21,11 +21,14 @@ export declare function createStrategy(rule: {
     max_delay_ms: number;
 }): RetryStrategy;
 export interface ResilienceConfig {
-    maxRetries: number;
     baseDelayMs: number;
     failoverThreshold: number;
     ruleMatcher?: RetryRuleMatcher;
     isFailover: boolean;
+    /** DB 规则 max_retries 的全局安全阀，防止单规则配置导致过多重试 */
+    globalRetryCap?: number;
+    /** 全局迭代上限，防止极端配置导致 while(true) 循环过多 */
+    iterationCap?: number;
 }
 export interface ResilienceAttempt {
     target: Target;

package/dist/proxy/resilience.js

@@ -1,10 +1,12 @@
+import { MS_PER_SECOND } from "../constants.js";
 import { ProviderSwitchNeeded } from "./types.js";
 export class FixedIntervalStrategy {
     delayMs;
     constructor(delayMs) {
         this.delayMs = delayMs;
     }
-    getDelay() { return this.delayMs; }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getDelay(_attempt) { return this.delayMs; }
 }
 const EXPONENTIAL_BASE = 2;
 export class ExponentialBackoffStrategy {
@@ -26,7 +28,9 @@ export function createStrategy(rule) {
 // ---------- Constants ----------
 const RETRYABLE_THROW_CODES = new Set(["ETIMEDOUT", "ECONNRESET", "ECONNREFUSED"]);
 const HTTP_TOO_MANY_REQUESTS = 429;
-const MS_PER_SECOND = 1000;
+const DEFAULT_THROW_MAX_RETRIES = 3;
+const DEFAULT_RETRY_CAP = 3;
+const DEFAULT_ITERATION_CAP = 50;
 // ---------- Internal helpers ----------
 function isRetryableThrow(err) {
     if (err && typeof err === "object" && "code" in err) {
@@ -73,7 +77,7 @@ export class ResilienceLayer {
             if (!isRetryableThrow(result.error)) {
                 return { action: "abort", reason: result.error.message };
             }
-            if (state.attemptCount < config.maxRetries) {
+            if (state.attemptCount < DEFAULT_THROW_MAX_RETRIES) {
                 return { action: "retry", delayMs: config.baseDelayMs };
             }
             return config.isFailover
@@ -86,8 +90,7 @@ export class ResilienceLayer {
             const matchedRule = body && config.ruleMatcher
                 ? config.ruleMatcher.match(result.statusCode, body)
                 : null;
-            const effectiveMaxRetries = Math.min(matchedRule?.max_retries ?? 0, config.maxRetries);
-            if (matchedRule && state.attemptCount < effectiveMaxRetries) {
+            if (matchedRule && state.attemptCount < Math.min(matchedRule.max_retries, config.globalRetryCap ?? DEFAULT_RETRY_CAP)) {
                 const strategy = createStrategy(matchedRule);
                 const headers = extractHeaders(result);
                 const retryAfterMs = result.statusCode === HTTP_TOO_MANY_REQUESTS
@@ -103,8 +106,7 @@ export class ResilienceLayer {
         const body = extractBody(result);
         if (body && config.ruleMatcher) {
             const matchedRule = config.ruleMatcher.match(result.statusCode, body);
-            const effectiveMaxRetries = Math.min(matchedRule?.max_retries ?? 0, config.maxRetries);
-            if (matchedRule && state.attemptCount < effectiveMaxRetries) {
+            if (matchedRule && state.attemptCount < Math.min(matchedRule.max_retries, config.globalRetryCap ?? DEFAULT_RETRY_CAP)) {
                 const strategy = createStrategy(matchedRule);
                 return { action: "retry", delayMs: strategy.getDelay(state.attemptCount) };
             }
@@ -123,6 +125,13 @@ export class ResilienceLayer {
             perTargetCounts.set(targetKey(t), (perTargetCounts.get(targetKey(t)) ?? 0) + 1);
         };
         while (true) {
+            if (globalAttemptIndex >= (config.iterationCap ?? DEFAULT_ITERATION_CAP)) {
+                return {
+                    result: lastResult ?? { kind: "error", statusCode: 502, body: "Iteration cap exceeded", headers: {}, sentHeaders: {}, sentBody: "" },
+                    attempts: allAttempts,
+                    excludedTargets,
+                };
+            }
             const available = targets().filter(t => !excludedTargets.some(e => e.backend_model === t.backend_model && e.provider_id === t.provider_id));
             if (available.length === 0) {
                 return {

package/dist/proxy/strategy/failover.js

@@ -1,13 +1,8 @@
-import { isTargetsRule } from "./targets-rule.js";
+import { isTargetsRule, filterExcluded } from "./targets-rule.js";
 export class FailoverStrategy {
     select(rule, context) {
         if (!isTargetsRule(rule))
             return undefined;
-        for (const t of rule.targets) {
-            const excluded = context.excludeTargets?.some((e) => e.backend_model === t.backend_model && e.provider_id === t.provider_id);
-            if (!excluded)
-                return t;
-        }
-        return undefined;
+        return filterExcluded(rule.targets, context.excludeTargets)[0];
     }
 }

package/dist/proxy/strategy/random.js

@@ -1,9 +1,9 @@
-import { isTargetsRule } from "./targets-rule.js";
+import { isTargetsRule, filterExcluded } from "./targets-rule.js";
 export class RandomStrategy {
     select(rule, context) {
         if (!isTargetsRule(rule))
             return undefined;
-        const filtered = rule.targets.filter((t) => !context.excludeTargets?.some((e) => e.backend_model === t.backend_model && e.provider_id === t.provider_id));
+        const filtered = filterExcluded(rule.targets, context.excludeTargets);
         if (filtered.length === 0)
             return undefined;
         return filtered[Math.floor(Math.random() * filtered.length)];

package/dist/proxy/strategy/round-robin.js

@@ -1,11 +1,11 @@
-import { isTargetsRule } from "./targets-rule.js";
+import { isTargetsRule, filterExcluded } from "./targets-rule.js";
 export class RoundRobinStrategy {
     indexMap = new Map();
     select(rule, context, clientModel) {
         if (!isTargetsRule(rule))
             return undefined;
         const key = clientModel ?? JSON.stringify(rule);
-        const filtered = rule.targets.filter((t) => !context.excludeTargets?.some((e) => e.backend_model === t.backend_model && e.provider_id === t.provider_id));
+        const filtered = filterExcluded(rule.targets, context.excludeTargets);
         if (filtered.length === 0)
             return undefined;
         const lastIndex = this.indexMap.get(key) ?? -1;

package/dist/proxy/strategy/scheduled.js

@@ -1,11 +1,4 @@
-function isTarget(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        "backend_model" in value &&
-        typeof value.backend_model === "string" &&
-        "provider_id" in value &&
-        typeof value.provider_id === "string");
-}
+import { isTarget } from "./targets-rule.js";
 function isTimeWindow(value) {
     return (typeof value === "object" &&
         value !== null &&

package/dist/proxy/strategy/targets-rule.d.ts

@@ -4,4 +4,5 @@ interface TargetsRule {
 }
 export declare function isTarget(value: unknown): value is Target;
 export declare function isTargetsRule(value: unknown): value is TargetsRule;
+export declare function filterExcluded(targets: Target[], excludeTargets?: Target[]): Target[];
 export {};

package/dist/proxy/strategy/targets-rule.js

@@ -12,3 +12,8 @@ export function isTargetsRule(value) {
     const r = value;
     return Array.isArray(r.targets) && r.targets.every(isTarget);
 }
+export function filterExcluded(targets, excludeTargets) {
+    if (!excludeTargets || excludeTargets.length === 0)
+        return targets;
+    return targets.filter((t) => !excludeTargets.some((e) => e.backend_model === t.backend_model && e.provider_id === t.provider_id));
+}

package/dist/proxy/transport-fn.d.ts

@@ -0,0 +1,25 @@
+import type { FastifyReply, FastifyRequest } from "fastify";
+import { getProviderById } from "../db/index.js";
+import type { RawHeaders, TransportResult } from "./types.js";
+import type { Target } from "./strategy/types.js";
+import type { RequestTracker } from "../monitor/request-tracker.js";
+import type { RetryRuleMatcher } from "./retry-rules.js";
+export interface TransportFnParams {
+    provider: NonNullable<ReturnType<typeof getProviderById>>;
+    apiKey: string;
+    body: Record<string, unknown>;
+    cliHdrs: RawHeaders;
+    reply: FastifyReply;
+    upstreamPath: string;
+    apiType: "openai" | "anthropic";
+    isStream: boolean;
+    startTime: number;
+    logId: string;
+    effectiveModel: string;
+    originalModel: string | null;
+    streamTimeoutMs: number;
+    tracker?: RequestTracker;
+    matcher?: RetryRuleMatcher;
+    request: FastifyRequest;
+}
+export declare function buildTransportFn(p: TransportFnParams): (target: Target) => Promise<TransportResult>;

package/dist/proxy/transport-fn.js

@@ -0,0 +1,55 @@
+import { callNonStream, callStream } from "./transport.js";
+import { SSEMetricsTransform } from "../metrics/sse-metrics-transform.js";
+import { MetricsExtractor } from "../metrics/metrics-extractor.js";
+import { buildUpstreamHeaders } from "./proxy-core.js";
+import { UPSTREAM_SUCCESS } from "./types.js";
+import { buildModelInfoTag } from "./enhancement/enhancement-handler.js";
+import { DEFAULT_MAX_RAW as STREAM_CONTENT_MAX_RAW, DEFAULT_MAX_TEXT as STREAM_CONTENT_MAX_TEXT } from "../monitor/stream-content-accumulator.js";
+function toStreamMetrics(m) {
+    return {
+        inputTokens: m.input_tokens,
+        outputTokens: m.output_tokens,
+        cacheReadTokens: m.cache_read_tokens,
+        ttftMs: m.ttft_ms,
+        tokensPerSecond: m.tokens_per_second,
+        stopReason: m.stop_reason,
+        isComplete: m.is_complete === 1,
+    };
+}
+export function buildTransportFn(p) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    return async (_target) => {
+        if (p.isStream) {
+            const metricsTransform = new SSEMetricsTransform(p.apiType, p.startTime, {
+                onMetrics: (m) => { p.tracker?.update(p.logId, { streamMetrics: toStreamMetrics(m) }); },
+                onChunk: (rawLine) => { p.tracker?.appendStreamChunk(p.logId, rawLine, p.apiType, STREAM_CONTENT_MAX_RAW, STREAM_CONTENT_MAX_TEXT); },
+            });
+            const checkEarlyError = p.matcher ? (data) => p.matcher.test(UPSTREAM_SUCCESS, data) : undefined;
+            const streamResult = await callStream(p.provider, p.apiKey, p.body, p.cliHdrs, p.reply, p.streamTimeoutMs, p.upstreamPath, buildUpstreamHeaders, metricsTransform, checkEarlyError);
+            const m = (streamResult.kind === "stream_success" || streamResult.kind === "stream_abort")
+                ? streamResult.metrics : undefined;
+            if (m)
+                p.tracker?.update(p.logId, { streamMetrics: toStreamMetrics(m) });
+            return streamResult;
+        }
+        const result = await callNonStream(p.provider, p.apiKey, p.body, p.cliHdrs, p.upstreamPath, buildUpstreamHeaders);
+        if (result.kind === "success") {
+            const mr = MetricsExtractor.fromNonStreamResponse(p.apiType, result.body);
+            if (mr)
+                p.tracker?.update(p.logId, { streamMetrics: toStreamMetrics(mr) });
+        }
+        if (p.originalModel && result.kind === "success" && result.statusCode === UPSTREAM_SUCCESS) {
+            try {
+                const bodyObj = JSON.parse(result.body);
+                if (bodyObj.content?.[0]?.text) {
+                    bodyObj.content[0].text += `\n\n${buildModelInfoTag(p.effectiveModel)}`;
+                    return { ...result, body: JSON.stringify(bodyObj) };
+                }
+            }
+            catch {
+                p.request.log.debug("Failed to inject model-info tag into non-JSON response");
+            }
+        }
+        return result;
+    };
+}

package/dist/proxy/transport.d.ts

@@ -1,7 +1,4 @@
-import type { FastifyReply } from "fastify";
 import type { RawHeaders, TransportResult } from "./types.js";
-import type { MetricsResult } from "../metrics/metrics-extractor.js";
-import type { SSEMetricsTransform } from "../metrics/sse-metrics-transform.js";
 export { callStream } from "./stream-proxy.js";
 export interface UpstreamRequestOptions {
     hostname: string;
@@ -13,7 +10,6 @@ export interface UpstreamRequestOptions {
 export declare const _transportInternals: {
     createUpstreamRequest(url: URL, options: UpstreamRequestOptions): import("http").ClientRequest;
 };
-export declare function createUpstreamRequest(url: URL, options: UpstreamRequestOptions): import("http").ClientRequest;
 export declare function buildRequestOptions(url: URL, headers: Record<string, string>, method?: string): UpstreamRequestOptions;
 export type BuildHeadersFn = (cliHdrs: RawHeaders, key: string, bytes?: number) => Record<string, string>;
 export declare function callNonStream(backend: {
@@ -27,24 +23,3 @@ export interface GetTransportResult {
 export declare function callGet(backend: {
     base_url: string;
 }, apiKey: string, clientHeaders: RawHeaders, upstreamPath: string, buildHeaders: (cliHdrs: RawHeaders, key: string) => Record<string, string>): Promise<GetTransportResult>;
-export interface ProxyResult {
-    statusCode: number;
-    body: string;
-    headers: Record<string, string>;
-    sentHeaders: Record<string, string>;
-    sentBody: string;
-}
-export interface StreamProxyResult {
-    statusCode: number;
-    responseBody?: string;
-    upstreamResponseHeaders?: Record<string, string>;
-    sentHeaders?: Record<string, string>;
-    metricsResult?: MetricsResult;
-    abnormalClose?: boolean;
-}
-export declare function proxyNonStreamCompat(backend: {
-    base_url: string;
-}, apiKey: string, body: Record<string, unknown>, clientHeaders: RawHeaders, upstreamPath: string, buildHeaders: BuildHeadersFn): Promise<ProxyResult>;
-export declare function proxyStreamCompat(backend: {
-    base_url: string;
-}, apiKey: string, body: Record<string, unknown>, clientHeaders: RawHeaders, reply: FastifyReply, timeoutMs: number, upstreamPath: string, buildHeaders: BuildHeadersFn, metricsTransform?: SSEMetricsTransform, checkEarlyError?: (bufferedData: string) => boolean): Promise<StreamProxyResult>;