llm-simple-router 0.3.7 → 0.4.0

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

@@ -3,10 +3,15 @@ import { StatsAggregator } from "./stats-aggregator.js";
 import { RuntimeCollector } from "./runtime-collector.js";
 import type { ProviderSemaphoreManager } from "../proxy/semaphore.js";
 import type { ActiveRequest, ProviderConcurrencySnapshot, RuntimeMetrics, StatsSnapshot } from "./types.js";
+export interface TrackerLogger {
+    debug(obj: Record<string, unknown>, msg: string): void;
+    warn(obj: Record<string, unknown>, msg: string): void;
+}
 export declare class RequestTracker {
     private activeMap;
     private recentCompleted;
     private clients;
+    private logger?;
     private providerConfigCache;
     private pushTimer;
     private tickCount;
@@ -17,6 +22,7 @@ export declare class RequestTracker {
     constructor(deps?: {
         semaphoreManager?: ProviderSemaphoreManager;
         runtimeCollector?: RuntimeCollector;
+        logger?: TrackerLogger;
     });
     start(req: ActiveRequest): void;
     update(id: string, patch: Partial<ActiveRequest>): void;

package/dist/monitor/request-tracker.js

@@ -1,56 +1,6 @@
 import { StatsAggregator } from "./stats-aggregator.js";
 import { RuntimeCollector } from "./runtime-collector.js";
-function extractStreamText(line, apiType) {
-    const empty = { text: '', block: null };
-    if (!line.startsWith(SSE_DATA_PREFIX))
-        return empty;
-    const jsonStr = line.slice(SSE_DATA_PREFIX.length);
-    if (jsonStr === '[DONE]')
-        return empty;
-    let obj;
-    try {
-        obj = JSON.parse(jsonStr);
-    }
-    catch {
-        return empty;
-    }
-    if (apiType === 'openai') {
-        const choices = obj.choices;
-        const delta = choices?.[0]?.delta;
-        const text = delta?.content ?? '';
-        return { text, block: text ? { index: 0, type: 'text', content: text } : null };
-    }
-    // Anthropic
-    const type = obj.type;
-    const index = obj.index;
-    const delta = obj.delta;
-    if (type === 'content_block_start') {
-        const contentBlock = obj.content_block;
-        const blockType = contentBlock?.type;
-        const name = blockType === 'tool_use' ? contentBlock?.name : undefined;
-        if (blockType === 'thinking' || blockType === 'text' || blockType === 'tool_use') {
-            return { text: '', block: { index: index ?? 0, type: blockType, content: '', name } };
-        }
-        return empty;
-    }
-    if (type === 'content_block_delta' && delta) {
-        const deltaType = delta.type;
-        if (deltaType === 'thinking_delta') {
-            const thinking = delta.thinking ?? '';
-            return { text: '', block: { index: index ?? 0, type: 'thinking', content: thinking } };
-        }
-        if (deltaType === 'text_delta') {
-            const text = delta.text ?? '';
-            return { text, block: { index: index ?? 0, type: 'text', content: text } };
-        }
-        if (deltaType === 'input_json_delta') {
-            const partialJson = delta.partial_json ?? '';
-            return { text: '', block: { index: index ?? 0, type: 'tool_use', content: partialJson } };
-        }
-    }
-    return empty;
-}
-const SSE_DATA_PREFIX = "data: ";
+import { extractStreamText } from "./stream-extractor.js";
 const RUNTIME_PUSH_TICK_INTERVAL = 2;
 const RECENT_COMPLETED_MAX = 200;
 const RECENT_TTL_MS = 5 * 60 * 1000; // eslint-disable-line no-magic-numbers
@@ -60,6 +10,7 @@ export class RequestTracker {
     activeMap = new Map();
     recentCompleted = [];
     clients = new Set();
+    logger;
     providerConfigCache = new Map();
     pushTimer = null;
     tickCount = 0;
@@ -71,18 +22,23 @@ export class RequestTracker {
         this.semaphoreManager = deps?.semaphoreManager;
         this.runtimeCollector = deps?.runtimeCollector ?? new RuntimeCollector();
         this.statsAggregator = new StatsAggregator();
+        this.logger = deps?.logger;
     }
     // --- Core methods ---
     start(req) {
         this.activeMap.set(req.id, { ...req });
+        this.logger?.debug({ reqId: req.id, model: req.model, providerId: req.providerId, activeCount: this.activeMap.size }, "Tracker: start");
         this.broadcast("request_start", req);
     }
     update(id, patch) {
         const req = this.activeMap.get(id);
-        if (!req)
+        if (!req) {
+            this.logger?.warn({ reqId: id, patchKeys: Object.keys(patch) }, "Tracker: update called but request not in activeMap");
             return;
+        }
         const prevQueued = req.queued;
         Object.assign(req, patch);
+        this.logger?.debug({ reqId: id, patchQueued: patch.queued, prevQueued, activeCount: this.activeMap.size }, "Tracker: update");
         // queued 状态变化时立即广播，让前端即时看到排队/取消排队
         if (patch.queued !== undefined && patch.queued !== prevQueued) {
             this.broadcast("request_update", this.getActive());
@@ -140,8 +96,10 @@ export class RequestTracker {
     }
     complete(id, result) {
         const req = this.activeMap.get(id);
-        if (!req)
+        if (!req) {
+            this.logger?.warn({ reqId: id, result }, "Tracker: complete called but request not in activeMap");
             return;
+        }
         const now = Date.now();
         const latency = now - req.startTime;
         const statusCode = result.statusCode ?? 0;
@@ -158,6 +116,7 @@ export class RequestTracker {
         if (this.recentCompleted.length > RECENT_COMPLETED_MAX) {
             this.recentCompleted.length = RECENT_COMPLETED_MAX;
         }
+        this.logger?.debug({ reqId: id, status: result.status, statusCode, latency, activeCount: this.activeMap.size }, "Tracker: complete");
         this.broadcast("request_complete", completed);
     }
     // --- Query methods ---
@@ -237,15 +196,25 @@ export class RequestTracker {
     }
     broadcast(event, data) {
         const msg = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+        const clientCount = this.clients.size;
+        let sentCount = 0;
         for (const client of this.clients) {
             try {
-                if (!client.writableEnded)
+                if (!client.writableEnded) {
                     client.write(msg);
+                    sentCount++;
+                }
             }
             catch {
                 this.clients.delete(client);
             }
         }
+        const summary = event === "request_update" ? `active=${data?.length}`
+            : event === "concurrency_update" ? data?.map(p => `${p.providerName}=${p.active}/${p.maxConcurrency}q${p.queued}`).join(",")
+                : event === "request_start" ? `model=${data?.model}`
+                    : event === "request_complete" ? `model=${data?.model} status=${data?.status}`
+                        : "";
+        this.logger?.debug({ event, clientCount, sentCount, summary }, "Tracker: SSE broadcast");
     }
     // --- Provider config cache ---
     updateProviderConfig(providerId, config) {

package/dist/monitor/stream-extractor.d.ts

@@ -0,0 +1,11 @@
+import type { ContentBlock } from "./types.js";
+export interface StreamExtraction {
+    text: string;
+    block?: {
+        index: number;
+        type: ContentBlock["type"];
+        content: string;
+        name?: string;
+    } | null;
+}
+export declare function extractStreamText(line: string, apiType: "openai" | "anthropic"): StreamExtraction;

package/dist/monitor/stream-extractor.js

@@ -0,0 +1,51 @@
+const SSE_DATA_PREFIX = "data: ";
+export function extractStreamText(line, apiType) {
+    const empty = { text: "", block: null };
+    if (!line.startsWith(SSE_DATA_PREFIX))
+        return empty;
+    const jsonStr = line.slice(SSE_DATA_PREFIX.length);
+    if (jsonStr === "[DONE]")
+        return empty;
+    let obj;
+    try {
+        obj = JSON.parse(jsonStr);
+    }
+    catch {
+        return empty;
+    }
+    if (apiType === "openai") {
+        const choices = obj.choices;
+        const delta = choices?.[0]?.delta;
+        const text = delta?.content ?? "";
+        return { text, block: text ? { index: 0, type: "text", content: text } : null };
+    }
+    // Anthropic
+    const type = obj.type;
+    const index = obj.index;
+    const delta = obj.delta;
+    if (type === "content_block_start") {
+        const contentBlock = obj.content_block;
+        const blockType = contentBlock?.type;
+        const name = blockType === "tool_use" ? contentBlock?.name : undefined;
+        if (blockType === "thinking" || blockType === "text" || blockType === "tool_use") {
+            return { text: "", block: { index: index ?? 0, type: blockType, content: "", name } };
+        }
+        return empty;
+    }
+    if (type === "content_block_delta" && delta) {
+        const deltaType = delta.type;
+        if (deltaType === "thinking_delta") {
+            const thinking = delta.thinking ?? "";
+            return { text: "", block: { index: index ?? 0, type: "thinking", content: thinking } };
+        }
+        if (deltaType === "text_delta") {
+            const text = delta.text ?? "";
+            return { text, block: { index: index ?? 0, type: "text", content: text } };
+        }
+        if (deltaType === "input_json_delta") {
+            const partialJson = delta.partial_json ?? "";
+            return { text: "", block: { index: index ?? 0, type: "tool_use", content: partialJson } };
+        }
+    }
+    return empty;
+}

package/dist/proxy/anthropic.js

@@ -1,41 +1,28 @@
 import fp from "fastify-plugin";
-import { handleProxyPost, } from "./proxy-core.js";
+import { createErrorFormatter } from "./proxy-core.js";
+import { handleProxyRequest } from "./proxy-handler.js";
+import { createOrchestrator } from "./orchestrator.js";
 const MESSAGES_PATH = "/v1/messages";
-const anthropicErrors = {
-    modelNotFound: (model) => ({
-        statusCode: 404,
-        body: { type: "error", error: { type: "not_found_error", message: `Model '${model}' is not configured` } },
-    }),
-    modelNotAllowed: (model) => ({
-        statusCode: 403,
-        body: { type: "error", error: { type: "forbidden_error", message: `Model '${model}' is not allowed for this API key` } },
-    }),
-    providerUnavailable: () => ({
-        statusCode: 503,
-        body: { type: "error", error: { type: "api_error", message: "Provider unavailable" } },
-    }),
-    providerTypeMismatch: () => ({
-        statusCode: 500,
-        body: { type: "error", error: { type: "api_error", message: "Provider type mismatch for this endpoint" } },
-    }),
-    upstreamConnectionFailed: () => ({
-        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 ANTHROPIC_ERROR_TYPE = {
+    modelNotFound: "not_found_error",
+    modelNotAllowed: "forbidden_error",
+    providerUnavailable: "api_error",
+    providerTypeMismatch: "api_error",
+    upstreamConnectionFailed: "upstream_error",
+    concurrencyQueueFull: "api_error",
+    concurrencyTimeout: "api_error",
 };
+const anthropicErrors = createErrorFormatter((kind, message) => ({ type: "error", error: { type: ANTHROPIC_ERROR_TYPE[kind], message } }));
 const anthropicProxyRaw = (app, opts, done) => {
     const { db, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher, semaphoreManager, tracker } = opts;
+    const orchestrator = createOrchestrator(semaphoreManager, tracker);
     app.post(MESSAGES_PATH, async (request, reply) => {
-        const deps = { db, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher, semaphoreManager, tracker };
-        return handleProxyPost(request, reply, "anthropic", MESSAGES_PATH, anthropicErrors, deps);
+        if (!orchestrator) {
+            const e = anthropicErrors.providerUnavailable();
+            return reply.status(e.statusCode).send(e.body);
+        }
+        const deps = { db, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher, tracker, orchestrator };
+        return handleProxyRequest(request, reply, "anthropic", MESSAGES_PATH, anthropicErrors, deps);
     });
     done();
 };

package/dist/proxy/log-helpers.d.ts

@@ -1,7 +1,16 @@
 import Database from "better-sqlite3";
 import type { Provider } from "../db/index.js";
 import type { RawHeaders } from "./proxy-core.js";
-export interface RequestLogParams {
+export interface FailoverContext {
+    isFailoverIteration: boolean;
+    rootLogId: string;
+}
+export interface LogRetryMeta {
+    isRetry?: boolean;
+    isFailover?: boolean;
+    originalRequestId?: string | null;
+}
+export interface RequestLogParams extends LogRetryMeta {
     id: string;
     apiType: string;
     model: string;
@@ -15,14 +24,12 @@ export interface RequestLogParams {
     respBody: string | null;
     upHdrs: Record<string, string>;
     cliHdrs: Record<string, string>;
-    isRetry?: boolean;
-    originalRequestId?: string | null;
     routerKeyId?: string | null;
     originalModel?: string | null;
 }
 /** 插入成功请求日志，供 openai/anthropic 插件共享 */
 export declare function insertSuccessLog(db: Database.Database, params: RequestLogParams): void;
-export interface RejectedLogParams {
+export interface RejectedLogParams extends LogRetryMeta {
     db: Database.Database;
     logId: string;
     apiType: string;

package/dist/proxy/log-helpers.js

@@ -1,7 +1,7 @@
 import { insertRequestLog } from "../db/index.js";
 /** 插入成功请求日志，供 openai/anthropic 插件共享 */
 export function insertSuccessLog(db, params) {
-    const { id: logId, apiType, model, provider, isStream, startTime, reqBody, clientReq, upstreamReq, status, respBody, upHdrs, cliHdrs, isRetry = false, originalRequestId = null, routerKeyId = null, originalModel = null } = params;
+    const { id: logId, apiType, model, provider, isStream, startTime, reqBody, clientReq, upstreamReq, status, respBody, upHdrs, cliHdrs, isRetry = false, isFailover = false, originalRequestId = null, routerKeyId = null, originalModel = null } = params;
     insertRequestLog(db, {
         id: logId, api_type: apiType, model, provider_id: provider.id,
         status_code: status, latency_ms: Date.now() - startTime,
@@ -10,13 +10,13 @@ export function insertSuccessLog(db, params) {
         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,
+        is_retry: isRetry ? 1 : 0, is_failover: isFailover ? 1 : 0, original_request_id: originalRequestId,
         router_key_id: routerKeyId, original_model: originalModel,
     });
 }
 /** Log a request rejected before reaching upstream */
 export function insertRejectedLog(params) {
-    const { db, logId, apiType, model, statusCode, errorMessage, startTime, isStream, routerKeyId, originalBody, clientHeaders, providerId = null, originalModel = null } = params;
+    const { db, logId, apiType, model, statusCode, errorMessage, startTime, isStream, routerKeyId, originalBody, clientHeaders, providerId = null, isFailover = false, originalRequestId = null, originalModel = null } = params;
     insertRequestLog(db, {
         id: logId,
         api_type: apiType,
@@ -29,6 +29,8 @@ export function insertRejectedLog(params) {
         created_at: new Date().toISOString(),
         request_body: JSON.stringify(originalBody),
         client_request: JSON.stringify({ headers: clientHeaders, body: originalBody }),
+        is_failover: isFailover ? 1 : 0,
+        original_request_id: originalRequestId,
         router_key_id: routerKeyId,
         original_model: originalModel,
     });

package/dist/proxy/openai.js

@@ -2,49 +2,33 @@ import fp from "fastify-plugin";
 import { getActiveProviders } from "../db/index.js";
 import { getSetting } from "../db/settings.js";
 import { decrypt } from "../utils/crypto.js";
-import { proxyGetRequest, handleProxyPost, } from "./proxy-core.js";
-const HTTP_NOT_FOUND = 404;
-const HTTP_BAD_GATEWAY = 502;
+import { proxyGetRequest, createErrorFormatter } from "./proxy-core.js";
+import { handleProxyRequest } from "./proxy-handler.js";
+import { createOrchestrator } from "./orchestrator.js";
+import { HTTP_NOT_FOUND, HTTP_BAD_GATEWAY } from "../constants.js";
 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" } },
-    }),
-    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" } },
-    }),
+const OPENAI_ERROR_META = {
+    modelNotFound: { type: "invalid_request_error", code: "model_not_found" },
+    modelNotAllowed: { type: "invalid_request_error", code: "model_not_allowed" },
+    providerUnavailable: { type: "server_error", code: "provider_unavailable" },
+    providerTypeMismatch: { type: "server_error", code: "provider_type_mismatch" },
+    upstreamConnectionFailed: { type: "upstream_error", code: "upstream_connection_failed" },
+    concurrencyQueueFull: { type: "server_error", code: "concurrency_queue_full" },
+    concurrencyTimeout: { type: "server_error", code: "concurrency_timeout" },
 };
+const openaiErrors = createErrorFormatter((kind, message) => ({ error: { message, ...OPENAI_ERROR_META[kind] } }));
 function sendError(reply, e) {
     return reply.status(e.statusCode).send(e.body);
 }
 const openaiProxyRaw = (app, opts, done) => {
     const { db, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher, semaphoreManager, tracker } = opts;
+    const orchestrator = createOrchestrator(semaphoreManager, tracker);
     app.post(CHAT_COMPLETIONS_PATH, async (request, reply) => {
-        const deps = { db, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher, semaphoreManager, tracker };
-        return handleProxyPost(request, reply, "openai", CHAT_COMPLETIONS_PATH, openaiErrors, deps, {
+        if (!orchestrator)
+            return sendError(reply, openaiErrors.providerUnavailable());
+        const deps = { db, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher, tracker, orchestrator };
+        return handleProxyRequest(request, reply, "openai", CHAT_COMPLETIONS_PATH, openaiErrors, deps, {
             beforeSendProxy: (body, isStream) => {
                 if (isStream && !body.stream_options) {
                     body.stream_options = { include_usage: true };

package/dist/proxy/orchestrator.d.ts

@@ -0,0 +1,52 @@
+import type { FastifyReply, FastifyRequest } from "fastify";
+import type { TransportResult } from "./types.js";
+import type { Target } from "./strategy/types.js";
+import type { ResilienceLayer, ResilienceResult } from "./resilience.js";
+import type { RetryRuleMatcher } from "./retry-rules.js";
+import type { SemaphoreScope } from "./scope.js";
+import type { TrackerScope } from "./scope.js";
+import type { ProviderSemaphoreManager } from "./semaphore.js";
+import type { RequestTracker } from "../monitor/request-tracker.js";
+export interface OrchestratorConfig {
+    resolved: Target;
+    provider: {
+        id: string;
+        name: string;
+        is_active: number;
+        api_type: string;
+        base_url: string;
+        api_key: string;
+    };
+    clientModel: string;
+    isStream: boolean;
+    /** 外部生成的 tracker ID，用于 tracker.appendStreamChunk / tracker.update 等回调匹配 */
+    trackerId?: string;
+}
+export interface HandleContext {
+    streamTimeoutMs?: number;
+    retryMaxAttempts?: number;
+    retryBaseDelayMs?: number;
+    failoverThreshold?: number;
+    isFailover?: boolean;
+    ruleMatcher?: RetryRuleMatcher;
+    transportFn: (target: Target) => Promise<TransportResult>;
+}
+/**
+ * 工厂函数，消除 openai/anthropic 创建 orchestrator 的重复代码。
+ * 两个 provider 的创建逻辑完全一致。
+ */
+export declare function createOrchestrator(semaphoreManager?: ProviderSemaphoreManager, tracker?: RequestTracker): ProxyOrchestrator | undefined;
+export declare class ProxyOrchestrator {
+    private deps;
+    constructor(deps: {
+        semaphoreScope: SemaphoreScope;
+        trackerScope: TrackerScope;
+        resilience: ResilienceLayer;
+    });
+    handle(request: FastifyRequest, reply: FastifyReply, apiType: "openai" | "anthropic", config: OrchestratorConfig, ctx?: HandleContext): Promise<ResilienceResult>;
+    private buildActiveRequest;
+    private createAbortSignal;
+    private executeResilience;
+    private sendResponse;
+    private extractTrackStatus;
+}

package/dist/proxy/orchestrator.js

@@ -0,0 +1,100 @@
+import { ResilienceLayer as ResilienceLayerClass } from "./resilience.js";
+import { SemaphoreScope as SemaphoreScopeClass } from "./scope.js";
+import { TrackerScope as TrackerScopeClass } from "./scope.js";
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_BASE_DELAY_MS = 1000;
+const DEFAULT_FAILOVER_THRESHOLD = 400;
+/**
+ * 工厂函数，消除 openai/anthropic 创建 orchestrator 的重复代码。
+ * 两个 provider 的创建逻辑完全一致。
+ */
+export function createOrchestrator(semaphoreManager, tracker) {
+    const semaphoreScope = semaphoreManager ? new SemaphoreScopeClass(semaphoreManager) : undefined;
+    const trackerScope = tracker ? new TrackerScopeClass(tracker) : undefined;
+    if (!semaphoreScope || !trackerScope)
+        return undefined;
+    return new ProxyOrchestrator({ semaphoreScope, trackerScope, resilience: new ResilienceLayerClass() });
+}
+export class ProxyOrchestrator {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async handle(request, reply, apiType, config, ctx) {
+        const trackerReq = this.buildActiveRequest(request, config, apiType);
+        const result = await this.deps.trackerScope.track(trackerReq, () => this.deps.semaphoreScope.withSlot(config.provider.id, this.createAbortSignal(request), () => {
+            trackerReq.queued = true;
+            this.deps.trackerScope.markQueued(trackerReq.id, true);
+        }, () => {
+            if (trackerReq.queued) {
+                trackerReq.queued = false;
+                this.deps.trackerScope.markQueued(trackerReq.id, false);
+            }
+            return this.executeResilience(config, ctx);
+        }), (result) => this.extractTrackStatus(result));
+        this.sendResponse(reply, result.result, ctx);
+        return result;
+    }
+    buildActiveRequest(request, config, apiType) {
+        return {
+            id: config.trackerId ?? crypto.randomUUID(),
+            apiType,
+            model: config.clientModel,
+            providerId: config.provider.id,
+            providerName: config.provider.name,
+            isStream: config.isStream,
+            queued: false,
+            startTime: Date.now(),
+            status: "pending",
+            retryCount: 0,
+            attempts: [],
+            clientIp: request.ip,
+        };
+    }
+    createAbortSignal(request) {
+        const controller = new AbortController();
+        request.raw.on("close", () => {
+            if (!request.raw.readableEnded) {
+                controller.abort();
+            }
+        });
+        return controller.signal;
+    }
+    async executeResilience(config, ctx) {
+        if (!ctx?.transportFn)
+            throw new Error("HandleContext.transportFn is required");
+        const resilienceConfig = {
+            maxRetries: ctx.retryMaxAttempts ?? DEFAULT_MAX_RETRIES,
+            baseDelayMs: ctx.retryBaseDelayMs ?? DEFAULT_BASE_DELAY_MS,
+            failoverThreshold: ctx.failoverThreshold ?? DEFAULT_FAILOVER_THRESHOLD,
+            isFailover: ctx.isFailover ?? false,
+            ruleMatcher: ctx.ruleMatcher,
+        };
+        return this.deps.resilience.execute(() => [config.resolved], ctx.transportFn, resilienceConfig);
+    }
+    sendResponse(reply, result, ctx) {
+        if (result.kind === "stream_success" || result.kind === "stream_abort" || result.kind === "throw") {
+            return;
+        }
+        // failover 场景下错误响应由外层 proxy-handler 控制，此处不发送
+        if (ctx?.isFailover && "statusCode" in result && result.statusCode >= (ctx.failoverThreshold ?? DEFAULT_FAILOVER_THRESHOLD)) {
+            return;
+        }
+        if (result.headers) {
+            for (const [key, value] of Object.entries(result.headers)) {
+                reply.header(key, value);
+            }
+        }
+        reply.status(result.statusCode).send(result.body);
+    }
+    extractTrackStatus(result) {
+        const transport = result.result;
+        if (transport.kind === "success" || transport.kind === "stream_success" || transport.kind === "stream_abort") {
+            return { status: "completed", statusCode: transport.statusCode };
+        }
+        if (transport.kind === "throw") {
+            return { status: "failed" };
+        }
+        return { status: "failed", statusCode: transport.statusCode };
+    }
+}

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

@@ -1,11 +1,8 @@
-import type { FastifyReply, FastifyRequest } from "fastify";
-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>;
+import type { GetTransportResult } from "./transport.js";
+import type { RawHeaders } from "./types.js";
+export { UPSTREAM_SUCCESS } from "./types.js";
+export type { RawHeaders } from "./types.js";
 export interface ProxyErrorResponse {
     statusCode: number;
     body: unknown;
@@ -19,25 +16,16 @@ export interface ProxyErrorFormatter {
     concurrencyQueueFull(providerId: string): ProxyErrorResponse;
     concurrencyTimeout(providerId: string, timeoutMs: number): ProxyErrorResponse;
 }
-export interface ProxyHandlerDeps {
-    db: Database.Database;
-    streamTimeoutMs: number;
-    retryMaxAttempts: number;
-    retryBaseDelayMs: number;
-    matcher?: RetryRuleMatcher;
-    semaphoreManager?: ProviderSemaphoreManager;
-    tracker?: RequestTracker;
-}
-export type { ProxyResult, StreamProxyResult, GetProxyResult };
+export type { ProxyResult, StreamProxyResult } from "./transport.js";
+export type { GetTransportResult as GetProxyResult } from "./transport.js";
+export type ErrorKind = "modelNotFound" | "modelNotAllowed" | "providerUnavailable" | "providerTypeMismatch" | "upstreamConnectionFailed" | "concurrencyQueueFull" | "concurrencyTimeout";
+/**
+ * 工厂函数，消除 openai/anthropic 错误格式化的重复代码。
+ * statusCode 和 message 两个 provider 完全一致，仅 body 格式不同，
+ * 由 formatBody 回调根据 kind 参数映射各自的 type/code 并组装 body。
+ */
+export declare function createErrorFormatter(formatBody: (kind: ErrorKind, message: string) => Record<string, unknown>): ProxyErrorFormatter;
 export declare const SKIP_UPSTREAM: Set<string>;
 export declare function selectHeaders(raw: RawHeaders, skip: Set<string>): Record<string, string>;
 export declare function buildUpstreamHeaders(clientHeaders: RawHeaders, apiKey: string, payloadBytes?: number): Record<string, string>;
-export declare function proxyGetRequest(backend: Provider, apiKey: string, clientHeaders: RawHeaders, upstreamPath: string): Promise<GetProxyResult>;
-/**
- * 共享 POST handler，参数化 apiType/errorFormat/upstreamPath 等差异。
- * 当分组策略为 failover 时，在 while 循环中依次尝试不同 target，
- * 直到成功（或 headers 已发送）才返回。
- */
-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>;
+export declare function proxyGetRequest(backend: Provider, apiKey: string, clientHeaders: RawHeaders, upstreamPath: string): Promise<GetTransportResult>;