llm-simple-router 0.9.33 → 0.10.0

package/dist/admin/providers.js

@@ -418,7 +418,7 @@ export const adminProviderRoutes = (app, options, done) => {
             return reply.send(modelIds);
         }
         catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
+            const message = err instanceof Error ? err.message : err instanceof Error ? err.message : JSON.stringify(err);
             return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, `连接上游失败: ${message}`));
         }
     });

package/dist/admin/routes.js

@@ -18,6 +18,7 @@ import { adminQuickSetupRoutes } from "./quick-setup.js";
 import { adminImportExportRoutes } from "./settings-import-export.js";
 import { adminTransformRuleRoutes } from "./transform-rules.js";
 import { adminScheduleRoutes } from "./schedules.js";
+import { hookRegistry } from "../proxy/pipeline/hook-registry.js";
 export const adminRoutes = (app, options, done) => {
     // Setup 路由不需要 auth
     app.register(adminSetupRoutes, { db: options.db });
@@ -41,5 +42,9 @@ export const adminRoutes = (app, options, done) => {
     app.register(adminQuickSetupRoutes, { db: options.db, stateRegistry: options.stateRegistry, tracker: options.tracker, adaptiveController: options.adaptiveController });
     app.register(adminUpgradeRoutes, { db: options.db, closeFn: options.closeFn ?? (async () => { }) });
     app.register(adminTransformRuleRoutes, { db: options.db, pluginRegistry: options.pluginRegistry });
+    // Pipeline hooks 查询
+    app.get("/admin/api/pipeline/hooks", async () => {
+        return { hooks: hookRegistry.getAll() };
+    });
     done();
 };

package/dist/admin/schedules.js

@@ -95,7 +95,7 @@ function checkOverlap(db, groupId, excludeId, weekDays, startHour, endHour) {
 }
 const HOUR_PAD_WIDTH = 2;
 function formatHour(h) {
-    return String(h).padStart(HOUR_PAD_WIDTH, "0") + ":00";
+    return h.toString().padStart(HOUR_PAD_WIDTH, "0") + ":00";
 }
 export const adminScheduleRoutes = (app, options, done) => {
     const { db } = options;

package/dist/admin/upgrade.js

@@ -93,7 +93,7 @@ export const adminUpgradeRoutes = (app, options, done) => {
             return reply.send({ ok: true, version });
         }
         catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
+            const msg = err instanceof Error ? err.message : err instanceof Error ? err.message : JSON.stringify(err);
             return reply.code(HTTP_INTERNAL_ERROR).send(apiError(API_CODE.INTERNAL_ERROR, `升级失败: ${msg}`));
         }
     });
@@ -125,7 +125,7 @@ export const adminUpgradeRoutes = (app, options, done) => {
             process.exit(0);
         }
         catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
+            const msg = err instanceof Error ? err.message : err instanceof Error ? err.message : JSON.stringify(err);
             req.log.error({ err }, `Restart failed: ${msg}`);
             process.exit(1);
         }
@@ -162,7 +162,7 @@ export const adminUpgradeRoutes = (app, options, done) => {
             return reply.send({ ok: true });
         }
         catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
+            const msg = err instanceof Error ? err.message : err instanceof Error ? err.message : JSON.stringify(err);
             return reply.code(HTTP_INTERNAL_ERROR).send(apiError(API_CODE.INTERNAL_ERROR, `同步失败: ${msg}`));
         }
     });

package/dist/config/recommended.js

@@ -12,7 +12,7 @@ function loadJson(filename) {
         return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
     }
     catch (err) {
-        process.stderr.write(`[recommended] 加载 ${filename} 失败: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.stderr.write(`[recommended] 加载 ${filename} 失败: ${err instanceof Error ? err.message : err instanceof Error ? err.message : JSON.stringify(err)}\n`);
         return [];
     }
 }
@@ -31,7 +31,7 @@ export function getConfigVersions() {
         return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
     }
     catch (err) {
-        process.stderr.write(`[recommended] 加载 version.json 失败: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.stderr.write(`[recommended] 加载 version.json 失败: ${err instanceof Error ? err.message : err instanceof Error ? err.message : JSON.stringify(err)}\n`);
         return { providers: 0, retryRules: 0 };
     }
 }

package/dist/core/constants.d.ts

@@ -7,6 +7,7 @@ export declare const HTTP_CONFLICT = 409;
 export declare const HTTP_UNPROCESSABLE_ENTITY = 422;
 export declare const HTTP_INTERNAL_ERROR = 500;
 export declare const HTTP_BAD_GATEWAY = 502;
+export declare const HTTP_CLIENT_CLOSED = 499;
 export declare const HTTP_SERVICE_UNAVAILABLE = 503;
 export declare const PROXY_API_TYPES: Record<string, string>;
 export declare function getProxyApiType(url: string): string | null;

package/dist/core/constants.js

@@ -9,6 +9,7 @@ export const HTTP_CONFLICT = 409;
 export const HTTP_UNPROCESSABLE_ENTITY = 422;
 export const HTTP_INTERNAL_ERROR = 500;
 export const HTTP_BAD_GATEWAY = 502;
+export const HTTP_CLIENT_CLOSED = 499; // nginx convention: client disconnected
 export const HTTP_SERVICE_UNAVAILABLE = 503;
 // api_type 路由映射：proxy path → api type，用于全局 hook/errorHandler 中识别代理请求
 export const PROXY_API_TYPES = {

package/dist/core/container.d.ts

@@ -8,6 +8,7 @@ export declare const SERVICE_KEYS: {
     readonly sessionTracker: "sessionTracker";
     readonly adaptiveController: "adaptiveController";
     readonly pluginRegistry: "pluginRegistry";
+    readonly formatRegistry: "formatRegistry";
     readonly logFileWriter: "logFileWriter";
     readonly proxyAgentFactory: "proxyAgentFactory";
 };

package/dist/core/container.js

@@ -8,6 +8,7 @@ export const SERVICE_KEYS = {
     sessionTracker: "sessionTracker",
     adaptiveController: "adaptiveController",
     pluginRegistry: "pluginRegistry",
+    formatRegistry: "formatRegistry",
     logFileWriter: "logFileWriter",
     proxyAgentFactory: "proxyAgentFactory",
 };

package/dist/db/db-size-monitor.js

@@ -57,7 +57,7 @@ export function scheduleDbSizeMonitor(db, dbPath, options) {
         }
         catch (e) {
             // DB 可能已关闭（测试清理、进程关闭等）
-            options.log.info(`Size monitor check skipped: ${e instanceof Error ? e.message : String(e)}`);
+            options.log.info(`Size monitor check skipped: ${e instanceof Error ? e.message : e instanceof Error ? e.message : JSON.stringify(e)}`);
         }
         finally {
             running = false;

package/dist/db/log-cleaner.js

@@ -29,7 +29,7 @@ export function scheduleLogCleanup(db, log) {
         }
         catch (e) {
             // DB 可能已关闭（测试清理、进程关闭等）
-            log.info(`Log cleanup skipped: ${e instanceof Error ? e.message : String(e)}`);
+            log.info(`Log cleanup skipped: ${e instanceof Error ? e.message : e instanceof Error ? e.message : JSON.stringify(e)}`);
         }
         finally {
             cleaning = false;

package/dist/db/settings.js

@@ -14,7 +14,7 @@ export function getLogRetentionDays(db) {
     return val ? parseInt(val, 10) : DEFAULT_LOG_RETENTION_DAYS;
 }
 export function setLogRetentionDays(db, days) {
-    setSetting(db, "log_retention_days", String(days));
+    setSetting(db, "log_retention_days", days.toString());
 }
 const DEFAULT_DB_MAX_SIZE_MB = 1024;
 const DEFAULT_LOG_TABLE_MAX_SIZE_MB = 800;
@@ -23,14 +23,14 @@ export function getDbMaxSizeMb(db) {
     return val ? parseInt(val, 10) : DEFAULT_DB_MAX_SIZE_MB;
 }
 export function setDbMaxSizeMb(db, mb) {
-    setSetting(db, "db_max_size_mb", String(mb));
+    setSetting(db, "db_max_size_mb", mb.toString());
 }
 export function getLogTableMaxSizeMb(db) {
     const val = getSetting(db, "log_table_max_size_mb");
     return val ? parseInt(val, 10) : DEFAULT_LOG_TABLE_MAX_SIZE_MB;
 }
 export function setLogTableMaxSizeMb(db, mb) {
-    setSetting(db, "log_table_max_size_mb", String(mb));
+    setSetting(db, "log_table_max_size_mb", mb.toString());
 }
 export function getConfigSyncSource(db) {
     const val = getSetting(db, "config_sync_source");

package/dist/index.js

@@ -15,12 +15,20 @@ import { getConfig, getBaseConfig } from "./config/index.js";
 import { initDatabase, getAllProviders } from "./db/index.js";
 import { loadRecommendedConfig } from "./config/recommended.js";
 import { authMiddleware } from "./middleware/auth.js";
-import { openaiProxy } from "./proxy/handler/openai.js";
-import { anthropicProxy } from "./proxy/handler/anthropic.js";
-import { responsesProxy } from "./proxy/handler/responses.js";
+import { createProxyHandler } from "./proxy/handler/create-proxy-handler.js";
 import { adminRoutes } from "./admin/routes.js";
 import { RetryRuleMatcher } from "./proxy/orchestration/retry-rules.js";
 import { PluginRegistry } from "./proxy/transform/plugin-registry.js";
+import { FormatRegistry } from "./proxy/format/registry.js";
+import { openaiAdapter } from "./proxy/format/adapters/openai.js";
+import { anthropicAdapter } from "./proxy/format/adapters/anthropic.js";
+import { responsesAdapter } from "./proxy/format/adapters/responses.js";
+import { openaiToAnthropicConverter } from "./proxy/format/converters/openai-anthropic.js";
+import { anthropicToOpenAIConverter } from "./proxy/format/converters/anthropic-openai.js";
+import { openaiToResponsesConverter } from "./proxy/format/converters/openai-responses.js";
+import { responsesToOpenAIConverter } from "./proxy/format/converters/responses-openai.js";
+import { responsesToAnthropicConverter } from "./proxy/format/converters/responses-anthropic.js";
+import { anthropicToResponsesConverter } from "./proxy/format/converters/anthropic-responses.js";
 import { SemaphoreManager, AdaptiveController } from "@llm-router/core/concurrency";
 import { RequestTracker } from "@llm-router/core/monitor";
 import { UsageWindowTracker } from "./proxy/routing/usage-window-tracker.js";
@@ -32,6 +40,7 @@ import fastifyStatic from "@fastify/static";
 import { ServiceContainer, SERVICE_KEYS } from "./core/container.js";
 import { LogFileWriter } from "./storage/log-file-writer.js";
 import { ProxyAgentFactory } from "./proxy/transport/proxy-agent.js";
+import { registerBuiltinHooks } from "./proxy/pipeline/register-hooks.js";
 import { scheduleLogFileMaintenance } from "./storage/log-file-compressor.js";
 import { getDetailLogEnabled, getLogFileRetentionDays } from "./db/settings.js";
 import { dirname, join } from "node:path";
@@ -216,6 +225,18 @@ export async function buildApp(options) {
     const pluginsDir = path.resolve(__dirname, "../plugins/transform");
     pluginRegistry.scanPluginsDir(pluginsDir);
     container.register(SERVICE_KEYS.pluginRegistry, () => pluginRegistry);
+    // 注册 FormatRegistry（3 adapters + 6 converters 覆盖所有格式转换）
+    const formatRegistry = new FormatRegistry();
+    formatRegistry.registerAdapter(openaiAdapter);
+    formatRegistry.registerAdapter(anthropicAdapter);
+    formatRegistry.registerAdapter(responsesAdapter);
+    formatRegistry.registerConverter(openaiToAnthropicConverter);
+    formatRegistry.registerConverter(anthropicToOpenAIConverter);
+    formatRegistry.registerConverter(openaiToResponsesConverter);
+    formatRegistry.registerConverter(responsesToOpenAIConverter);
+    formatRegistry.registerConverter(responsesToAnthropicConverter);
+    formatRegistry.registerConverter(anthropicToResponsesConverter);
+    container.register(SERVICE_KEYS.formatRegistry, () => formatRegistry);
     // 注册 ProxyAgentFactory
     container.register(SERVICE_KEYS.proxyAgentFactory, () => new ProxyAgentFactory());
     // 从容器解析所有服务
@@ -230,9 +251,24 @@ export async function buildApp(options) {
     // 从 DB 读取已有 provider 的并发配置，初始化信号量/adaptive/tracker（共享逻辑）
     initializeProviderState(db, semaphoreManager, adaptiveController, tracker);
     app.register(authMiddleware, { db });
-    app.register(openaiProxy, { db, container });
-    app.register(anthropicProxy, { db, container });
-    app.register(responsesProxy, { db, container });
+    // 注册内置 hooks 到 hookRegistry（供 Admin API 查询）
+    registerBuiltinHooks();
+    // --- New pipeline-based proxy handlers (Phase 3) ---
+    const openaiHandler = createProxyHandler({
+        apiType: "openai",
+        paths: ["/v1/chat/completions", "/chat/completions"],
+    });
+    const anthropicHandler = createProxyHandler({
+        apiType: "anthropic",
+        paths: ["/v1/messages"],
+    });
+    const responsesHandler = createProxyHandler({
+        apiType: "openai-responses",
+        paths: ["/v1/responses", "/responses"],
+    });
+    app.register(openaiHandler, { db, container });
+    app.register(anthropicHandler, { db, container });
+    app.register(responsesHandler, { db, container });
     // StateRegistry — Admin 层通过此接口触发 proxy 层状态刷新，消除 admin→proxy 依赖
     const stateRegistry = {
         refreshRetryRules: () => matcher.load(db),
@@ -262,7 +298,7 @@ export async function buildApp(options) {
         });
         // SPA fallback: /admin/ 下非 API 路径返回 index.html
         app.setNotFoundHandler((request, reply) => {
-            if (request.url.startsWith("/admin") &&
+            if ((request.url.startsWith("/admin/") || request.url === "/admin") &&
                 !request.url.startsWith("/admin/api")) {
                 return reply.sendFile("index.html");
             }
@@ -347,7 +383,7 @@ export async function main() {
     });
     process.on("unhandledRejection", (reason) => {
         try {
-            app.log.error({ err: reason instanceof Error ? reason : new Error(String(reason)) }, "Unhandled rejection");
+            app.log.error({ err: reason instanceof Error ? reason : new Error(typeof reason === 'string' ? reason : JSON.stringify(reason)) }, "Unhandled rejection");
             /* eslint-disable taste/no-silent-catch -- app.log 可能已崩溃，console 是最后手段 */
         }
         catch {

package/dist/proxy/format/adapters/anthropic.d.ts

@@ -0,0 +1,2 @@
+import type { FormatAdapter } from "../types.js";
+export declare const anthropicAdapter: FormatAdapter;

package/dist/proxy/format/adapters/anthropic.js

@@ -0,0 +1,18 @@
+const ANTHROPIC_ERROR_META = {
+    modelNotFound: { type: "not_found_error", code: "model_not_found" },
+    modelNotAllowed: { type: "forbidden_error", code: "model_not_allowed" },
+    providerUnavailable: { type: "api_error", code: "provider_unavailable" },
+    providerTypeMismatch: { type: "api_error", code: "provider_type_mismatch" },
+    upstreamConnectionFailed: { type: "upstream_error", code: "upstream_connection_failed" },
+    concurrencyQueueFull: { type: "api_error", code: "concurrency_queue_full" },
+    concurrencyTimeout: { type: "api_error", code: "concurrency_timeout" },
+    promptTooLong: { type: "invalid_request_error", code: "context_window_exceeded" },
+};
+export const anthropicAdapter = {
+    apiType: "anthropic",
+    defaultPath: "/v1/messages",
+    errorMeta: ANTHROPIC_ERROR_META,
+    formatError(message) {
+        return { type: "error", error: { type: "api_error", message } };
+    },
+};

package/dist/proxy/format/adapters/openai.d.ts

@@ -0,0 +1,2 @@
+import type { FormatAdapter } from "../types.js";
+export declare const openaiAdapter: FormatAdapter;

package/dist/proxy/format/adapters/openai.js

@@ -0,0 +1,14 @@
+import { OPENAI_FAMILY_ERROR_META } from "./shared-error-meta.js";
+export const openaiAdapter = {
+    apiType: "openai",
+    defaultPath: "/v1/chat/completions",
+    errorMeta: OPENAI_FAMILY_ERROR_META,
+    beforeSendProxy(body, isStream) {
+        if (isStream && !body.stream_options) {
+            body.stream_options = { include_usage: true };
+        }
+    },
+    formatError(message, code) {
+        return { error: { message, type: "upstream_error", code: code ?? "upstream_error" } };
+    },
+};

package/dist/proxy/format/adapters/responses.d.ts

@@ -0,0 +1,2 @@
+import type { FormatAdapter } from "../types.js";
+export declare const responsesAdapter: FormatAdapter;

package/dist/proxy/format/adapters/responses.js

@@ -0,0 +1,9 @@
+import { OPENAI_FAMILY_ERROR_META } from "./shared-error-meta.js";
+export const responsesAdapter = {
+    apiType: "openai-responses",
+    defaultPath: "/v1/responses",
+    errorMeta: OPENAI_FAMILY_ERROR_META,
+    formatError(message, code) {
+        return { error: { message, type: "invalid_request_error", code: code ?? "upstream_error" } };
+    },
+};

package/dist/proxy/format/adapters/shared-error-meta.d.ts

@@ -0,0 +1,9 @@
+import type { ErrorKind } from "../types.js";
+/**
+ * OpenAI 和 Responses API 共用的错误元数据。
+ * 两者 error code/type 完全相同，仅 apiType/defaultPath/formatError 不同。
+ */
+export declare const OPENAI_FAMILY_ERROR_META: Record<ErrorKind, {
+    type: string;
+    code: string;
+}>;

package/dist/proxy/format/adapters/shared-error-meta.js

@@ -0,0 +1,14 @@
+/**
+ * OpenAI 和 Responses API 共用的错误元数据。
+ * 两者 error code/type 完全相同，仅 apiType/defaultPath/formatError 不同。
+ */
+export const OPENAI_FAMILY_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" },
+    promptTooLong: { type: "invalid_request_error", code: "context_window_exceeded" },
+};

package/dist/proxy/format/converters/anthropic-openai.d.ts

@@ -0,0 +1 @@
+export declare const anthropicToOpenAIConverter: import("../types.js").FormatConverter;

package/dist/proxy/format/converters/anthropic-openai.js

@@ -0,0 +1,11 @@
+import { createConverter } from "../types.js";
+import { anthropicToOpenAIRequest } from "../../transform/request-transform.js";
+import { anthropicResponseToOpenAI } from "../../transform/response-transform.js";
+import { AnthropicToOpenAITransform } from "../../transform/stream-ant2oa.js";
+export const anthropicToOpenAIConverter = createConverter({
+    sourceType: "anthropic",
+    targetType: "openai",
+    requestTransform: anthropicToOpenAIRequest,
+    responseTransform: anthropicResponseToOpenAI,
+    streamTransformClass: AnthropicToOpenAITransform,
+});

package/dist/proxy/format/converters/anthropic-responses.d.ts

@@ -0,0 +1 @@
+export declare const anthropicToResponsesConverter: import("../types.js").FormatConverter;

package/dist/proxy/format/converters/anthropic-responses.js

@@ -0,0 +1,11 @@
+import { createConverter } from "../types.js";
+import { anthropicToResponsesRequest } from "../../transform/request-transform-responses.js";
+import { anthropicToResponsesResponse } from "../../transform/response-transform-responses.js";
+import { AnthropicToResponsesTransform } from "../../transform/stream-ant2resp.js";
+export const anthropicToResponsesConverter = createConverter({
+    sourceType: "anthropic",
+    targetType: "openai-responses",
+    requestTransform: anthropicToResponsesRequest,
+    responseTransform: anthropicToResponsesResponse,
+    streamTransformClass: AnthropicToResponsesTransform,
+});

package/dist/proxy/format/converters/openai-anthropic.d.ts

@@ -0,0 +1 @@
+export declare const openaiToAnthropicConverter: import("../types.js").FormatConverter;

package/dist/proxy/format/converters/openai-anthropic.js

@@ -0,0 +1,11 @@
+import { createConverter } from "../types.js";
+import { openaiToAnthropicRequest } from "../../transform/request-transform.js";
+import { openaiResponseToAnthropic } from "../../transform/response-transform.js";
+import { OpenAIToAnthropicTransform } from "../../transform/stream-oa2ant.js";
+export const openaiToAnthropicConverter = createConverter({
+    sourceType: "openai",
+    targetType: "anthropic",
+    requestTransform: openaiToAnthropicRequest,
+    responseTransform: openaiResponseToAnthropic,
+    streamTransformClass: OpenAIToAnthropicTransform,
+});

package/dist/proxy/format/converters/openai-responses.d.ts

@@ -0,0 +1 @@
+export declare const openaiToResponsesConverter: import("../types.js").FormatConverter;

package/dist/proxy/format/converters/openai-responses.js

@@ -0,0 +1,11 @@
+import { createConverter } from "../types.js";
+import { chatToResponsesRequest } from "../../transform/request-bridge-responses.js";
+import { chatToResponsesResponse } from "../../transform/response-bridge-responses.js";
+import { ChatToResponsesBridgeTransform } from "../../transform/stream-bridge-chat2resp.js";
+export const openaiToResponsesConverter = createConverter({
+    sourceType: "openai",
+    targetType: "openai-responses",
+    requestTransform: chatToResponsesRequest,
+    responseTransform: chatToResponsesResponse,
+    streamTransformClass: ChatToResponsesBridgeTransform,
+});

package/dist/proxy/format/converters/responses-anthropic.d.ts

@@ -0,0 +1 @@
+export declare const responsesToAnthropicConverter: import("../types.js").FormatConverter;

package/dist/proxy/format/converters/responses-anthropic.js

@@ -0,0 +1,11 @@
+import { createConverter } from "../types.js";
+import { responsesToAnthropicRequest } from "../../transform/request-transform-responses.js";
+import { responsesToAnthropicResponse } from "../../transform/response-transform-responses.js";
+import { ResponsesToAnthropicTransform } from "../../transform/stream-resp2ant.js";
+export const responsesToAnthropicConverter = createConverter({
+    sourceType: "openai-responses",
+    targetType: "anthropic",
+    requestTransform: responsesToAnthropicRequest,
+    responseTransform: responsesToAnthropicResponse,
+    streamTransformClass: ResponsesToAnthropicTransform,
+});

package/dist/proxy/format/converters/responses-openai.d.ts

@@ -0,0 +1 @@
+export declare const responsesToOpenAIConverter: import("../types.js").FormatConverter;

package/dist/proxy/format/converters/responses-openai.js

@@ -0,0 +1,11 @@
+import { createConverter } from "../types.js";
+import { responsesToChatRequest } from "../../transform/request-bridge-responses.js";
+import { responsesToChatResponse } from "../../transform/response-bridge-responses.js";
+import { ResponsesToChatBridgeTransform } from "../../transform/stream-bridge-resp2chat.js";
+export const responsesToOpenAIConverter = createConverter({
+    sourceType: "openai-responses",
+    targetType: "openai",
+    requestTransform: responsesToChatRequest,
+    responseTransform: responsesToChatResponse,
+    streamTransformClass: ResponsesToChatBridgeTransform,
+});

package/dist/proxy/format/registry.d.ts

@@ -0,0 +1,17 @@
+import type { Transform } from "stream";
+import type { FormatAdapter, FormatConverter } from "./types.js";
+export declare class FormatRegistry {
+    private adapters;
+    private converters;
+    registerAdapter(adapter: FormatAdapter): void;
+    registerConverter(converter: FormatConverter): void;
+    getAdapter(apiType: string): FormatAdapter | undefined;
+    needsTransform(source: string, target: string): boolean;
+    transformRequest(body: Record<string, unknown>, source: string, target: string, model: string): {
+        body: Record<string, unknown>;
+        upstreamPath: string;
+    };
+    transformResponse(bodyStr: string, source: string, target: string): string;
+    transformError(bodyStr: string, source: string, target: string): string;
+    createStreamTransform(source: string, target: string, model: string): Transform | undefined;
+}

package/dist/proxy/format/registry.js

@@ -0,0 +1,50 @@
+export class FormatRegistry {
+    adapters = new Map();
+    converters = new Map();
+    registerAdapter(adapter) {
+        this.adapters.set(adapter.apiType, adapter);
+    }
+    registerConverter(converter) {
+        this.converters.set(`${converter.sourceType}→${converter.targetType}`, converter);
+    }
+    getAdapter(apiType) {
+        return this.adapters.get(apiType);
+    }
+    needsTransform(source, target) {
+        return source !== target;
+    }
+    transformRequest(body, source, target, model) {
+        const targetAdapter = this.adapters.get(target);
+        const upstreamPath = targetAdapter?.defaultPath ?? "/v1/chat/completions";
+        const converter = this.converters.get(`${source}→${target}`);
+        if (!converter)
+            return { body, upstreamPath };
+        return { body: converter.transformRequest(body, model), upstreamPath };
+    }
+    transformResponse(bodyStr, source, target) {
+        const converter = this.converters.get(`${source}→${target}`);
+        if (!converter)
+            return bodyStr;
+        return converter.transformResponse(bodyStr);
+    }
+    transformError(bodyStr, source, target) {
+        if (source === target)
+            return bodyStr;
+        try {
+            const parsed = JSON.parse(bodyStr);
+            const message = parsed.error?.message ?? parsed.message ?? JSON.stringify(parsed);
+            const code = parsed.error?.code ?? parsed.code;
+            const targetAdapter = this.adapters.get(target);
+            if (!targetAdapter)
+                return bodyStr;
+            return JSON.stringify(targetAdapter.formatError(message, code));
+        }
+        catch {
+            return bodyStr;
+        }
+    }
+    createStreamTransform(source, target, model) {
+        const converter = this.converters.get(`${source}→${target}`);
+        return converter?.createStreamTransform(model);
+    }
+}

package/dist/proxy/format/types.d.ts

@@ -0,0 +1,27 @@
+import type { Transform } from "stream";
+export type ErrorKind = "modelNotFound" | "modelNotAllowed" | "providerUnavailable" | "providerTypeMismatch" | "upstreamConnectionFailed" | "concurrencyQueueFull" | "concurrencyTimeout" | "promptTooLong";
+export interface FormatAdapter {
+    readonly apiType: string;
+    readonly defaultPath: string;
+    readonly errorMeta: Record<ErrorKind, {
+        type: string;
+        code: string;
+    }>;
+    beforeSendProxy?(body: Record<string, unknown>, isStream: boolean): void;
+    formatError(message: string, code?: string): unknown;
+}
+export interface FormatConverter {
+    readonly sourceType: string;
+    readonly targetType: string;
+    transformRequest(body: Record<string, unknown>, model: string): Record<string, unknown>;
+    transformResponse(bodyStr: string): string;
+    createStreamTransform(model: string): Transform;
+}
+/** Factory: eliminates repetitive object literal structure across 6 converters. */
+export declare function createConverter(deps: {
+    sourceType: string;
+    targetType: string;
+    requestTransform: (body: Record<string, unknown>) => Record<string, unknown>;
+    responseTransform: (bodyStr: string) => string;
+    streamTransformClass: new (model: string) => Transform;
+}): FormatConverter;

package/dist/proxy/format/types.js

@@ -0,0 +1,16 @@
+/** Factory: eliminates repetitive object literal structure across 6 converters. */
+export function createConverter(deps) {
+    return {
+        sourceType: deps.sourceType,
+        targetType: deps.targetType,
+        transformRequest(body) {
+            return deps.requestTransform(body);
+        },
+        transformResponse(bodyStr) {
+            return deps.responseTransform(bodyStr);
+        },
+        createStreamTransform(model) {
+            return new deps.streamTransformClass(model);
+        },
+    };
+}

package/dist/proxy/handler/create-proxy-handler.d.ts

@@ -0,0 +1,14 @@
+import type { FastifyPluginCallback } from "fastify";
+import Database from "better-sqlite3";
+import type { ServiceContainer } from "../../core/container.js";
+export interface ProxyHandlerConfig {
+    /** API 类型：openai | openai-responses | anthropic */
+    apiType: "openai" | "openai-responses" | "anthropic";
+    /** 注册 POST 路由的路径列表 */
+    paths: string[];
+}
+export interface ProxyHandlerOptions {
+    db: Database.Database;
+    container: ServiceContainer;
+}
+export declare function createProxyHandler(config: ProxyHandlerConfig): FastifyPluginCallback<ProxyHandlerOptions>;