llm-simple-router 0.1.0

package/dist/proxy/mapping-resolver.js

@@ -0,0 +1,27 @@
+import { STRATEGY_NAMES } from "./strategy/types.js";
+import { ScheduledStrategy } from "./strategy/scheduled.js";
+import { getMappingGroup } from "../db/index.js";
+// 策略注册表：key 为数据库中 mapping_groups.strategy 字段的值。
+// 新增策略时：
+// 1. 在 src/proxy/strategy/ 下创建实现文件
+// 2. 在此注册表中添加映射
+const STRATEGIES = {
+    [STRATEGY_NAMES.SCHEDULED]: new ScheduledStrategy(),
+};
+export function resolveMapping(db, clientModel, context) {
+    const group = getMappingGroup(db, clientModel);
+    if (!group)
+        return null;
+    let rule;
+    try {
+        rule = JSON.parse(group.rule);
+    }
+    catch {
+        console.warn(`[mapping-resolver] Failed to parse rule for client_model '${group.client_model}'`);
+        return null;
+    }
+    const strategy = STRATEGIES[group.strategy];
+    if (!strategy)
+        return null;
+    return strategy.select(rule, context) ?? null;
+}

package/dist/proxy/openai.d.ts

@@ -0,0 +1,12 @@
+import type { FastifyPluginCallback } from "fastify";
+import Database from "better-sqlite3";
+import { RetryRuleMatcher } from "./retry-rules.js";
+export interface OpenaiProxyOptions {
+    db: Database.Database;
+    encryptionKey: string;
+    streamTimeoutMs: number;
+    retryMaxAttempts: number;
+    retryBaseDelayMs: number;
+    matcher?: RetryRuleMatcher;
+}
+export declare const openaiProxy: FastifyPluginCallback<OpenaiProxyOptions>;

package/dist/proxy/openai.js

@@ -0,0 +1,72 @@
+import fp from "fastify-plugin";
+import { getActiveProviders } from "../db/index.js";
+import { decrypt } from "../utils/crypto.js";
+import { proxyGetRequest, handleProxyPost, } from "./proxy-core.js";
+const HTTP_NOT_FOUND = 404;
+const HTTP_BAD_GATEWAY = 502;
+const CHAT_COMPLETIONS_PATH = "/v1/chat/completions";
+const MODELS_PATH = "/v1/models";
+const openaiErrors = {
+    modelNotFound: (model) => ({
+        statusCode: 404,
+        body: { error: { message: `Model '${model}' is not configured`, type: "invalid_request_error", code: "model_not_found" } },
+    }),
+    modelNotAllowed: (model) => ({
+        statusCode: 403,
+        body: { error: { message: `Model '${model}' is not allowed for this API key`, type: "invalid_request_error", code: "model_not_allowed" } },
+    }),
+    providerUnavailable: () => ({
+        statusCode: 503,
+        body: { error: { message: "Provider unavailable", type: "server_error", code: "provider_unavailable" } },
+    }),
+    providerTypeMismatch: () => ({
+        statusCode: 500,
+        body: { error: { message: "Provider type mismatch for this endpoint", type: "server_error", code: "provider_type_mismatch" } },
+    }),
+    upstreamConnectionFailed: () => ({
+        statusCode: 502,
+        body: { error: { message: "Failed to connect to upstream service", type: "upstream_error", code: "upstream_connection_failed" } },
+    }),
+};
+function sendError(reply, e) {
+    return reply.status(e.statusCode).send(e.body);
+}
+const openaiProxyRaw = (app, opts, done) => {
+    const { db, encryptionKey, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher } = opts;
+    app.post(CHAT_COMPLETIONS_PATH, async (request, reply) => {
+        const deps = { db, encryptionKey, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher };
+        return handleProxyPost(request, reply, "openai", CHAT_COMPLETIONS_PATH, openaiErrors, deps, {
+            beforeSendProxy: (body, isStream) => {
+                if (isStream && !body.stream_options) {
+                    body.stream_options = { include_usage: true };
+                }
+            },
+        });
+    });
+    app.get(MODELS_PATH, async (request, reply) => {
+        const providers = getActiveProviders(db, "openai");
+        if (providers.length === 0)
+            return sendError(reply, {
+                statusCode: HTTP_NOT_FOUND,
+                body: { error: { message: "No active OpenAI provider configured", type: "invalid_request_error", code: "no_provider" } },
+            });
+        const provider = providers[0];
+        const apiKey = decrypt(provider.api_key, encryptionKey);
+        const cliHdrs = request.headers;
+        try {
+            const result = await proxyGetRequest(provider, apiKey, cliHdrs, MODELS_PATH);
+            for (const [k, v] of Object.entries(result.headers))
+                reply.header(k, v);
+            return reply.status(result.statusCode).send(result.body);
+        }
+        catch (err) {
+            request.log.error({ err: err instanceof Error ? err.message : String(err) }, "Failed to reach OpenAI backend for /v1/models");
+            return sendError(reply, {
+                statusCode: HTTP_BAD_GATEWAY,
+                body: { error: { message: "Failed to reach backend service", type: "server_error", code: "upstream_error" } },
+            });
+        }
+    });
+    done();
+};
+export const openaiProxy = fp(openaiProxyRaw, { name: "openai-proxy" });

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

@@ -0,0 +1,75 @@
+import type { FastifyReply, FastifyRequest } from "fastify";
+import Database from "better-sqlite3";
+import type { Provider } from "../db/index.js";
+import { SSEMetricsTransform } from "../metrics/sse-metrics-transform.js";
+import type { MetricsResult } from "../metrics/metrics-extractor.js";
+import type { RetryRuleMatcher } from "./retry-rules.js";
+export type RawHeaders = Record<string, string | string[] | undefined>;
+export interface UpstreamRequestOptions {
+    hostname: string;
+    port: number;
+    path: string;
+    method: string;
+    headers: Record<string, string>;
+}
+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>;
+    /** 流结束时从 SSEMetricsTransform 采集的指标，仅当传入了 metricsTransform 时存在 */
+    metricsResult?: MetricsResult;
+}
+export interface GetProxyResult {
+    statusCode: number;
+    body: string;
+    headers: Record<string, string>;
+}
+export declare const UPSTREAM_SUCCESS = 200;
+export declare const SKIP_UPSTREAM: Set<string>;
+export declare const SKIP_DOWNSTREAM: Set<string>;
+export declare function selectHeaders(raw: RawHeaders, skip: Set<string>): Record<string, string>;
+/** 构建发往上游的请求 headers：过滤客户端 headers + 注入后端 API key */
+export declare function buildUpstreamHeaders(clientHeaders: RawHeaders, apiKey: string, payloadBytes?: number): Record<string, string>;
+/** 根据 URL scheme 选择 http 或 https 模块 */
+export declare function createUpstreamRequest(url: URL, options: UpstreamRequestOptions): import("http").ClientRequest;
+/** 从 URL + headers 构造 Node.js http.request 所需的 options */
+export declare function buildRequestOptions(url: URL, headers: Record<string, string>, method?: string): UpstreamRequestOptions;
+/** 插入成功请求日志，供 openai/anthropic 插件共享 */
+export declare function insertSuccessLog(db: Database.Database, apiType: string, logId: string, model: string, provider: Provider, isStream: boolean, startTime: number, reqBody: string, clientReq: string, upstreamReq: string, status: number, respBody: string | null, upHdrs: Record<string, string>, cliHdrs: Record<string, string>, isRetry?: boolean, originalRequestId?: string | null, routerKeyId?: string | null): void;
+export declare function proxyNonStream(backend: Provider, apiKey: string, body: Record<string, unknown>, clientHeaders: RawHeaders, upstreamPath: string): Promise<ProxyResult>;
+export declare function proxyStream(backend: Provider, apiKey: string, body: Record<string, unknown>, clientHeaders: RawHeaders, reply: FastifyReply, timeoutMs: number, upstreamPath: string, metricsTransform?: SSEMetricsTransform): Promise<StreamProxyResult>;
+export declare function proxyGetRequest(backend: Provider, apiKey: string, clientHeaders: RawHeaders, upstreamPath: string): Promise<GetProxyResult>;
+export interface ProxyErrorResponse {
+    statusCode: number;
+    body: unknown;
+}
+export interface ProxyErrorFormatter {
+    modelNotFound(model: string): ProxyErrorResponse;
+    modelNotAllowed(model: string): ProxyErrorResponse;
+    providerUnavailable(): ProxyErrorResponse;
+    providerTypeMismatch(): ProxyErrorResponse;
+    upstreamConnectionFailed(): ProxyErrorResponse;
+}
+export interface ProxyHandlerDeps {
+    db: Database.Database;
+    encryptionKey: string;
+    streamTimeoutMs: number;
+    retryMaxAttempts: number;
+    retryBaseDelayMs: number;
+    matcher?: RetryRuleMatcher;
+}
+/**
+ * 共享 POST handler，参数化 apiType/errorFormat/upstreamPath 等差异，
+ * 消除 openai.ts / anthropic.ts 中约 120 行重复代码。
+ */
+export declare function handleProxyPost(request: FastifyRequest, reply: FastifyReply, apiType: "openai" | "anthropic", upstreamPath: string, errors: ProxyErrorFormatter, deps: ProxyHandlerDeps, options?: {
+    beforeSendProxy?: (body: Record<string, unknown>, isStream: boolean) => void;
+}): Promise<FastifyReply>;

package/dist/proxy/proxy-core.js

@@ -0,0 +1,408 @@
+import { randomUUID } from "crypto";
+import { request as httpRequestFn } from "http";
+import { request as httpsRequestFn } from "https";
+import { PassThrough } from "stream";
+import { getProviderById, insertRequestLog, insertMetrics } from "../db/index.js";
+import { decrypt } from "../utils/crypto.js";
+import { SSEMetricsTransform } from "../metrics/sse-metrics-transform.js";
+import { MetricsExtractor } from "../metrics/metrics-extractor.js";
+import { resolveMapping } from "./mapping-resolver.js";
+import { retryableCall, buildRetryConfig } from "./retry.js";
+// ---------- Constants ----------
+export const UPSTREAM_SUCCESS = 200;
+const HTTPS_DEFAULT_PORT = 443;
+const HTTP_DEFAULT_PORT = 80;
+const UPSTREAM_BAD_GATEWAY = 502;
+// ---------- Header utilities ----------
+export const SKIP_UPSTREAM = new Set([
+    "host",
+    "content-length",
+    "accept-encoding",
+    "authorization",
+    "connection",
+    "keep-alive",
+    "transfer-encoding",
+    "upgrade",
+]);
+export const SKIP_DOWNSTREAM = new Set([
+    "content-length",
+    "transfer-encoding",
+    "connection",
+    "keep-alive",
+]);
+export function selectHeaders(raw, skip) {
+    const out = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (value == null || skip.has(key.toLowerCase()))
+            continue;
+        out[key] = Array.isArray(value) ? value.join(", ") : value;
+    }
+    return out;
+}
+// 当前两个 provider 都使用 Bearer token（commit eaa4f7d 将 Anthropic 从 x-api-key 改为 Bearer）
+// 如果未来需要支持其他鉴权方式，需要参数化 header 构造
+/** 构建发往上游的请求 headers：过滤客户端 headers + 注入后端 API key */
+export function buildUpstreamHeaders(clientHeaders, apiKey, payloadBytes) {
+    const headers = selectHeaders(clientHeaders, SKIP_UPSTREAM);
+    headers["Authorization"] = `Bearer ${apiKey}`;
+    if (payloadBytes !== undefined) {
+        headers["Content-Type"] = "application/json";
+        headers["Content-Length"] = String(payloadBytes);
+    }
+    return headers;
+}
+// ---------- Request utilities ----------
+/** 根据 URL scheme 选择 http 或 https 模块 */
+export function createUpstreamRequest(url, options) {
+    return url.protocol === "https:" ? httpsRequestFn(options) : httpRequestFn(options);
+}
+/** 从 URL + headers 构造 Node.js http.request 所需的 options */
+export function buildRequestOptions(url, headers, method = "POST") {
+    return {
+        hostname: url.hostname,
+        port: Number(url.port) || (url.protocol === "https:" ? HTTPS_DEFAULT_PORT : HTTP_DEFAULT_PORT),
+        path: url.pathname,
+        method,
+        headers,
+    };
+}
+// ---------- Logging ----------
+/** 插入成功请求日志，供 openai/anthropic 插件共享 */
+export function insertSuccessLog(db, apiType, logId, model, provider, isStream, startTime, reqBody, clientReq, upstreamReq, status, respBody, upHdrs, cliHdrs, isRetry = false, originalRequestId = null, routerKeyId = null) {
+    insertRequestLog(db, {
+        id: logId, api_type: apiType, model, provider_id: provider.id,
+        status_code: status, latency_ms: Date.now() - startTime,
+        is_stream: isStream ? 1 : 0, error_message: null,
+        created_at: new Date().toISOString(), request_body: reqBody,
+        response_body: respBody, client_request: clientReq, upstream_request: upstreamReq,
+        upstream_response: JSON.stringify({ statusCode: status, headers: upHdrs, body: respBody }),
+        client_response: JSON.stringify({ statusCode: status, headers: cliHdrs, body: respBody }),
+        is_retry: isRetry ? 1 : 0, original_request_id: originalRequestId,
+        router_key_id: routerKeyId,
+    });
+}
+// ---------- Non-stream proxy ----------
+export function proxyNonStream(backend, apiKey, body, clientHeaders, upstreamPath) {
+    return new Promise((resolve, reject) => {
+        const url = new URL(`${backend.base_url}${upstreamPath}`);
+        const payload = JSON.stringify(body);
+        const upstreamHeaders = buildUpstreamHeaders(clientHeaders, apiKey, Buffer.byteLength(payload));
+        const options = buildRequestOptions(url, upstreamHeaders);
+        const req = createUpstreamRequest(url, options);
+        req.on("response", (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => {
+                resolve({
+                    statusCode: res.statusCode || UPSTREAM_BAD_GATEWAY,
+                    body: Buffer.concat(chunks).toString("utf-8"),
+                    headers: selectHeaders(res.headers, SKIP_DOWNSTREAM),
+                    sentHeaders: { ...upstreamHeaders },
+                    sentBody: payload,
+                });
+            });
+        });
+        req.on("error", (err) => reject(err));
+        req.write(payload);
+        req.end();
+    });
+}
+// ---------- Stream proxy (SSE) ----------
+export function proxyStream(backend, apiKey, body, clientHeaders, reply, timeoutMs, upstreamPath, metricsTransform) {
+    return new Promise((resolve, reject) => {
+        const url = new URL(`${backend.base_url}${upstreamPath}`);
+        const payload = JSON.stringify(body);
+        const upstreamHeaders = buildUpstreamHeaders(clientHeaders, apiKey, Buffer.byteLength(payload));
+        const options = buildRequestOptions(url, upstreamHeaders);
+        const upstreamReq = createUpstreamRequest(url, options);
+        upstreamReq.on("response", (upstreamRes) => {
+            const statusCode = upstreamRes.statusCode || UPSTREAM_BAD_GATEWAY;
+            if (statusCode !== UPSTREAM_SUCCESS) {
+                // 非200路径：仅返回错误信息，不操作 reply
+                const chunks = [];
+                upstreamRes.on("data", (chunk) => chunks.push(chunk));
+                upstreamRes.on("end", () => {
+                    const errorBody = Buffer.concat(chunks).toString("utf-8");
+                    resolve({
+                        statusCode,
+                        responseBody: errorBody,
+                        upstreamResponseHeaders: selectHeaders(upstreamRes.headers, SKIP_DOWNSTREAM),
+                        sentHeaders: upstreamHeaders,
+                    });
+                });
+                return;
+            }
+            const sseHeaders = selectHeaders(upstreamRes.headers, SKIP_DOWNSTREAM);
+            sseHeaders["Content-Type"] = "text/event-stream";
+            sseHeaders["Cache-Control"] = "no-cache";
+            sseHeaders["Connection"] = "keep-alive";
+            reply.raw.writeHead(statusCode, sseHeaders);
+            const passThrough = new PassThrough();
+            if (metricsTransform) {
+                // 管道: upstreamRes → metricsTransform → passThrough → reply.raw
+                metricsTransform.pipe(passThrough).pipe(reply.raw);
+            }
+            else {
+                passThrough.pipe(reply.raw);
+            }
+            // 管道入口：有 metricsTransform 时写入它，否则直接写 passThrough
+            const pipeEntry = metricsTransform ?? passThrough;
+            const captureChunks = [];
+            let idleTimer = null;
+            let resolved = false;
+            function cleanup() {
+                if (idleTimer)
+                    clearTimeout(idleTimer);
+                idleTimer = null;
+                if (!passThrough.destroyed)
+                    passThrough.destroy();
+                if (metricsTransform && !metricsTransform.destroyed)
+                    metricsTransform.destroy();
+                if (!upstreamRes.destroyed)
+                    upstreamRes.destroy();
+            }
+            /** 从 metricsTransform 中提取指标，供 resolve 时附带 */
+            function collectMetrics(isComplete) {
+                if (!metricsTransform)
+                    return undefined;
+                const result = metricsTransform.getExtractor().getMetrics();
+                if (!isComplete) {
+                    return { ...result, is_complete: 0 };
+                }
+                return result;
+            }
+            reply.raw.on("close", () => {
+                if (!resolved) {
+                    cleanup();
+                    resolve({ statusCode, responseBody: undefined, upstreamResponseHeaders: sseHeaders, sentHeaders: upstreamHeaders, metricsResult: collectMetrics(false) });
+                }
+            });
+            passThrough.on("error", () => {
+                cleanup();
+                if (!resolved) {
+                    resolved = true;
+                    resolve({ statusCode, responseBody: undefined, upstreamResponseHeaders: sseHeaders, sentHeaders: upstreamHeaders, metricsResult: collectMetrics(false) });
+                }
+            });
+            function resetIdleTimer() {
+                if (idleTimer)
+                    clearTimeout(idleTimer);
+                idleTimer = setTimeout(() => {
+                    cleanup();
+                    if (!resolved) {
+                        resolved = true;
+                        resolve({ statusCode, responseBody: undefined, upstreamResponseHeaders: sseHeaders, sentHeaders: upstreamHeaders, metricsResult: collectMetrics(false) });
+                    }
+                }, timeoutMs);
+            }
+            resetIdleTimer();
+            upstreamRes.on("data", (chunk) => {
+                if (resolved)
+                    return;
+                resetIdleTimer();
+                pipeEntry.write(chunk);
+                captureChunks.push(chunk);
+            });
+            upstreamRes.on("end", () => {
+                if (resolved)
+                    return;
+                resolved = true;
+                if (idleTimer)
+                    clearTimeout(idleTimer);
+                pipeEntry.end();
+                reply.raw.end();
+                resolve({
+                    statusCode,
+                    responseBody: Buffer.concat(captureChunks).toString("utf-8"),
+                    upstreamResponseHeaders: sseHeaders,
+                    sentHeaders: upstreamHeaders,
+                    metricsResult: collectMetrics(true),
+                });
+            });
+            upstreamRes.on("error", (err) => {
+                if (resolved)
+                    return;
+                resolved = true;
+                cleanup();
+                reject(err);
+            });
+        });
+        upstreamReq.on("error", (err) => reject(err));
+        upstreamReq.write(payload);
+        upstreamReq.end();
+    });
+}
+// ---------- GET proxy ----------
+export function proxyGetRequest(backend, apiKey, clientHeaders, upstreamPath) {
+    return new Promise((resolve, reject) => {
+        const url = new URL(`${backend.base_url}${upstreamPath}`);
+        const headers = buildUpstreamHeaders(clientHeaders, apiKey);
+        const options = buildRequestOptions(url, headers, "GET");
+        const req = createUpstreamRequest(url, options);
+        req.on("response", (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => {
+                resolve({
+                    statusCode: res.statusCode || UPSTREAM_BAD_GATEWAY,
+                    body: Buffer.concat(chunks).toString("utf-8"),
+                    headers: selectHeaders(res.headers, SKIP_DOWNSTREAM),
+                });
+            });
+        });
+        req.on("error", (err) => reject(err));
+        req.end();
+    });
+}
+const HTTP_BAD_GATEWAY = 502;
+/**
+ * 共享 POST handler，参数化 apiType/errorFormat/upstreamPath 等差异，
+ * 消除 openai.ts / anthropic.ts 中约 120 行重复代码。
+ */
+export async function handleProxyPost(request, reply, apiType, upstreamPath, errors, deps, options) {
+    const { db, encryptionKey, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher } = deps;
+    request.raw.socket.on("error", (err) => request.log.debug({ err }, "client socket error"));
+    const startTime = Date.now();
+    const logId = randomUUID();
+    const routerKeyId = request.routerKey?.id ?? null;
+    const body = request.body;
+    const originalBody = JSON.parse(JSON.stringify(body));
+    const clientModel = body.model || "unknown";
+    const resolved = resolveMapping(db, clientModel, { now: new Date() });
+    if (!resolved) {
+        const e = errors.modelNotFound(clientModel);
+        return reply.status(e.statusCode).send(e.body);
+    }
+    // 白名单校验
+    const allowedModels = request.routerKey?.allowed_models;
+    if (allowedModels) {
+        try {
+            const models = JSON.parse(allowedModels);
+            if (models.length > 0 && !models.includes(resolved.backend_model)) {
+                const e = errors.modelNotAllowed(resolved.backend_model);
+                return reply.status(e.statusCode).send(e.body);
+            }
+        }
+        catch {
+            request.log.warn("Invalid allowed_models JSON, allowing all models");
+        }
+    }
+    const provider = getProviderById(db, resolved.provider_id);
+    if (!provider || !provider.is_active) {
+        const e = errors.providerUnavailable();
+        return reply.status(e.statusCode).send(e.body);
+    }
+    if (provider.api_type !== apiType) {
+        const e = errors.providerTypeMismatch();
+        return reply.status(e.statusCode).send(e.body);
+    }
+    body.model = resolved.backend_model;
+    const apiKey = decrypt(provider.api_key, encryptionKey);
+    const isStream = body.stream === true;
+    // 允许调用方在发送代理请求前修改 body（如 openai 的 stream_options 注入）
+    options?.beforeSendProxy?.(body, isStream);
+    const reqBodyStr = JSON.stringify(body);
+    const cliHdrs = request.headers;
+    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 });
+    try {
+        const { result: r, attempts } = isStream
+            ? await retryableCall(() => {
+                const metricsTransform = new SSEMetricsTransform(apiType, startTime);
+                return proxyStream(provider, apiKey, body, cliHdrs, reply, streamTimeoutMs, upstreamPath, metricsTransform);
+            }, retryConfig, reply)
+            : await retryableCall(() => proxyNonStream(provider, apiKey, body, cliHdrs, upstreamPath), 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: clientModel, 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,
+                });
+            }
+            else if (attempt.statusCode !== UPSTREAM_SUCCESS) {
+                insertRequestLog(db, {
+                    id: attemptLogId, api_type: apiType, model: clientModel, 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,
+                });
+            }
+            else {
+                const h = isStream
+                    ? (r.upstreamResponseHeaders ?? {})
+                    : (r.headers);
+                insertSuccessLog(db, apiType, attemptLogId, clientModel, provider, isStream, startTime, reqBodyStr, clientReq, upstreamReqBase, r.statusCode, attempt.responseBody, h, h, !isOriginal, isOriginal ? null : logId, routerKeyId);
+                lastSuccessLogId = attemptLogId;
+            }
+        }
+        // 将最终结果发送给客户端
+        if (isStream) {
+            if (r.statusCode !== UPSTREAM_SUCCESS) {
+                for (const [k, v] of Object.entries(r.upstreamResponseHeaders ?? {}))
+                    reply.header(k, v);
+                reply.status(r.statusCode).send(r.responseBody);
+            }
+        }
+        else {
+            const pr = r;
+            for (const [k, v] of Object.entries(pr.headers))
+                reply.header(k, v);
+            return 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");
+                }
+            }
+        }
+        return reply;
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        const sentH = buildUpstreamHeaders(cliHdrs, apiKey, Buffer.byteLength(reqBodyStr));
+        const upstreamReq = JSON.stringify({ url: `${provider.base_url}${upstreamPath}`, headers: sentH, body: reqBodyStr });
+        insertRequestLog(db, {
+            id: logId, api_type: apiType, model: clientModel, provider_id: provider.id,
+            status_code: HTTP_BAD_GATEWAY, latency_ms: Date.now() - startTime,
+            is_stream: isStream ? 1 : 0, error_message: errMsg || "Upstream connection failed",
+            created_at: new Date().toISOString(), request_body: reqBodyStr,
+            client_request: clientReq, upstream_request: upstreamReq,
+            router_key_id: routerKeyId,
+        });
+        const e = errors.upstreamConnectionFailed();
+        return reply.status(e.statusCode).send(e.body);
+    }
+}

package/dist/proxy/retry-rules.d.ts

@@ -0,0 +1,9 @@
+import Database from "better-sqlite3";
+import { type RetryRule } from "../db/index.js";
+export declare class RetryRuleMatcher {
+    private cache;
+    private raw;
+    load(db: Database.Database): void;
+    match(statusCode: number, body: string): RetryRule | null;
+    test(statusCode: number, body: string): boolean;
+}

package/dist/proxy/retry-rules.js

@@ -0,0 +1,27 @@
+import { getActiveRetryRules } from "../db/index.js";
+export class RetryRuleMatcher {
+    cache = new Map();
+    raw = [];
+    load(db) {
+        this.raw = getActiveRetryRules(db);
+        this.cache.clear();
+        for (const rule of this.raw) {
+            const entries = this.cache.get(rule.status_code) ?? [];
+            entries.push({ rule, pattern: new RegExp(rule.body_pattern) });
+            this.cache.set(rule.status_code, entries);
+        }
+    }
+    match(statusCode, body) {
+        const entries = this.cache.get(statusCode);
+        if (!entries)
+            return null;
+        for (const { rule, pattern } of entries) {
+            if (pattern.test(body))
+                return rule;
+        }
+        return null;
+    }
+    test(statusCode, body) {
+        return this.match(statusCode, body) !== null;
+    }
+}