llm-simple-router 0.7.1 → 0.8.0

package/dist/admin/routes.d.ts

@@ -10,6 +10,7 @@ interface AdminRoutesOptions {
     adaptiveController?: AdaptiveConcurrencyController;
     logFileWriter?: import("../storage/log-file-writer.js").LogFileWriter | null;
     logsDir?: string;
+    pluginRegistry?: import("../proxy/transform/plugin-registry.js").PluginRegistry;
     closeFn?: () => Promise<void>;
 }
 export declare const adminRoutes: FastifyPluginCallback<AdminRoutesOptions>;

package/dist/admin/routes.js

@@ -15,6 +15,7 @@ import { adminRecommendedRoutes } from "./recommended.js";
 import { adminUsageRoutes } from "./usage.js";
 import { adminUpgradeRoutes } from "./upgrade.js";
 import { adminImportExportRoutes } from "./settings-import-export.js";
+import { adminTransformRuleRoutes } from "./transform-rules.js";
 import { adminScheduleRoutes } from "./schedules.js";
 export const adminRoutes = (app, options, done) => {
     // Setup 路由不需要 auth
@@ -33,9 +34,10 @@ export const adminRoutes = (app, options, done) => {
     app.register(adminProxyEnhancementRoutes, { db: options.db, stateRegistry: options.stateRegistry });
     app.register(adminMonitorRoutes, { tracker: options.tracker });
     app.register(adminSettingsRoutes, { db: options.db, logsDir: options.logsDir });
-    app.register(adminImportExportRoutes, { db: options.db, stateRegistry: options.stateRegistry });
+    app.register(adminImportExportRoutes, { db: options.db, stateRegistry: options.stateRegistry, pluginRegistry: options.pluginRegistry });
     app.register(adminRecommendedRoutes, { db: options.db });
     app.register(adminUsageRoutes, { db: options.db });
     app.register(adminUpgradeRoutes, { db: options.db, closeFn: options.closeFn ?? (async () => { }) });
+    app.register(adminTransformRuleRoutes, { db: options.db, pluginRegistry: options.pluginRegistry });
     done();
 };

package/dist/admin/settings-import-export.d.ts

@@ -4,6 +4,7 @@ import type { StateRegistry } from "../core/registry.js";
 interface ImportExportOptions {
     db: Database.Database;
     stateRegistry: StateRegistry;
+    pluginRegistry?: import("../proxy/transform/plugin-registry.js").PluginRegistry;
 }
 export declare const adminImportExportRoutes: FastifyPluginCallback<ImportExportOptions>;
 export {};

package/dist/admin/settings-import-export.js

@@ -1,4 +1,5 @@
 import { createHash } from "crypto";
+import { resolve } from "path";
 import { encrypt, decrypt } from "../utils/crypto.js";
 import { getSetting } from "../db/settings.js";
 import { API_CODE, apiError } from "./api-response.js";
@@ -12,6 +13,7 @@ const CONFIG_TABLES = [
     "schedules",
     "provider_model_info",
     "session_model_history",
+    "provider_transform_rules",
 ];
 // settings 表按 key 列的值过滤，不覆盖本地安全敏感配置
 const PROTECTED_SETTING_KEYS = new Set(["admin_password_hash", "jwt_secret", "encryption_key"]);
@@ -129,6 +131,11 @@ export const adminImportExportRoutes = (app, options, done) => {
         stateRegistry.removeAllProviders();
         stateRegistry.clearModelState();
         stateRegistry.reinitializeProviders();
+        // 刷新 transform plugin 缓存（从 DB 重新加载规则 + 扫描插件目录）
+        if (options.pluginRegistry) {
+            const pluginsDir = resolve(process.cwd(), "plugins/transform");
+            options.pluginRegistry.reload(options.db, pluginsDir);
+        }
         return reply.send(counts);
     });
     done();

package/dist/admin/transform-rules.d.ts

@@ -0,0 +1,8 @@
+import type { FastifyPluginCallback } from "fastify";
+import Database from "better-sqlite3";
+interface TransformRuleOptions {
+    db: Database.Database;
+    pluginRegistry?: import("../proxy/transform/plugin-registry.js").PluginRegistry;
+}
+export declare const adminTransformRuleRoutes: FastifyPluginCallback<TransformRuleOptions>;
+export {};

package/dist/admin/transform-rules.js

@@ -0,0 +1,38 @@
+import { resolve } from "path";
+import { getTransformRule, upsertTransformRule, deleteTransformRule, getAllActiveRules } from "../db/transform-rules.js";
+const ALLOWED_FIELDS = new Set([
+    "inject_headers", "request_defaults", "drop_fields", "field_overrides", "plugin_name", "is_active",
+]);
+export const adminTransformRuleRoutes = (app, options, done) => {
+    const { db } = options;
+    app.get("/admin/api/transform-rules/:providerId", async (req) => {
+        const { providerId } = req.params;
+        const rule = getTransformRule(db, providerId);
+        return { code: 0, message: "ok", data: rule };
+    });
+    app.put("/admin/api/transform-rules/:providerId", async (req) => {
+        const { providerId } = req.params;
+        const updates = {};
+        for (const [key, val] of Object.entries(req.body)) {
+            if (ALLOWED_FIELDS.has(key))
+                updates[key] = val;
+        }
+        upsertTransformRule(db, providerId, updates);
+        return { code: 0, message: "ok", data: { success: true } };
+    });
+    app.delete("/admin/api/transform-rules/:providerId", async (req) => {
+        const { providerId } = req.params;
+        deleteTransformRule(db, providerId);
+        return { code: 0, message: "ok", data: { success: true } };
+    });
+    app.post("/admin/api/transform-rules/reload", async () => {
+        if (options.pluginRegistry) {
+            const pluginsDir = resolve(process.cwd(), "plugins/transform");
+            const result = options.pluginRegistry.reload(options.db, pluginsDir);
+            return { code: 0, message: "ok", data: result };
+        }
+        const rules = getAllActiveRules(db);
+        return { code: 0, message: "ok", data: { loadedPlugins: [], rulesCount: rules.length } };
+    });
+    done();
+};

package/dist/admin/usage.js

@@ -1,6 +1,6 @@
 import { Type } from "@sinclair/typebox";
 import { getWindowsInRange, getWindowUsage } from "../db/usage-windows.js";
-import { getProviderById } from "../db/providers.js";
+import { getProviderById } from "../db/index.js";
 import { resolveTimeRange } from "../utils/time-range.js";
 const UsageQuerySchema = Type.Object({
     router_key_id: Type.Optional(Type.String()),

package/dist/core/container.d.ts

@@ -7,6 +7,7 @@ export declare const SERVICE_KEYS: {
     readonly usageWindowTracker: "usageWindowTracker";
     readonly sessionTracker: "sessionTracker";
     readonly adaptiveController: "adaptiveController";
+    readonly pluginRegistry: "pluginRegistry";
     readonly logFileWriter: "logFileWriter";
 };
 export type ServiceKey = (typeof SERVICE_KEYS)[keyof typeof SERVICE_KEYS];

package/dist/core/container.js

@@ -7,6 +7,7 @@ export const SERVICE_KEYS = {
     usageWindowTracker: "usageWindowTracker",
     sessionTracker: "sessionTracker",
     adaptiveController: "adaptiveController",
+    pluginRegistry: "pluginRegistry",
     logFileWriter: "logFileWriter",
 };
 /**

package/dist/db/migrations/034_create_provider_transform_rules.sql

@@ -0,0 +1,11 @@
+CREATE TABLE IF NOT EXISTS provider_transform_rules (
+  provider_id TEXT PRIMARY KEY REFERENCES providers(id) ON DELETE CASCADE,
+  inject_headers TEXT,
+  request_defaults TEXT,
+  drop_fields TEXT,
+  field_overrides TEXT,
+  plugin_name TEXT,
+  is_active INTEGER DEFAULT 1,
+  created_at TEXT DEFAULT (datetime('now')),
+  updated_at TEXT DEFAULT (datetime('now'))
+);

package/dist/db/transform-rules.d.ts

@@ -0,0 +1,16 @@
+import Database from "better-sqlite3";
+export interface TransformRules {
+    provider_id: string;
+    inject_headers: Record<string, string> | null;
+    request_defaults: Record<string, unknown> | null;
+    drop_fields: string[] | null;
+    field_overrides: Record<string, unknown> | null;
+    plugin_name: string | null;
+    is_active: number;
+    created_at?: string;
+    updated_at?: string;
+}
+export declare function getTransformRule(db: Database.Database, providerId: string): TransformRules | null;
+export declare function upsertTransformRule(db: Database.Database, providerId: string, rules: Partial<Omit<TransformRules, "provider_id">>): void;
+export declare function deleteTransformRule(db: Database.Database, providerId: string): void;
+export declare function getAllActiveRules(db: Database.Database): TransformRules[];

package/dist/db/transform-rules.js

@@ -0,0 +1,51 @@
+const JSON_COLUMNS = ["inject_headers", "request_defaults", "drop_fields", "field_overrides"];
+function parseJsonColumns(row) {
+    const result = { ...row };
+    for (const col of JSON_COLUMNS) {
+        if (result[col]) {
+            try {
+                result[col] = JSON.parse(result[col]);
+            }
+            catch {
+                console.error(`[transform-rules] Failed to parse JSON column "${col}", keeping raw value`);
+            }
+        }
+    }
+    return result;
+}
+export function getTransformRule(db, providerId) {
+    const row = db.prepare("SELECT * FROM provider_transform_rules WHERE provider_id = ?").get(providerId);
+    if (!row)
+        return null;
+    return parseJsonColumns(row);
+}
+export function upsertTransformRule(db, providerId, rules) {
+    const existing = db.prepare("SELECT provider_id FROM provider_transform_rules WHERE provider_id = ?").get(providerId);
+    if (existing) {
+        const fields = [];
+        const values = [];
+        const jsonFields = new Set(["inject_headers", "request_defaults", "drop_fields", "field_overrides"]);
+        for (const [key, val] of Object.entries(rules)) {
+            if (key === "provider_id")
+                continue;
+            fields.push(`${key} = ?`);
+            values.push(jsonFields.has(key) && val ? JSON.stringify(val) : val);
+        }
+        if (fields.length === 0)
+            return;
+        fields.push("updated_at = datetime('now')");
+        values.push(providerId);
+        db.prepare(`UPDATE provider_transform_rules SET ${fields.join(", ")} WHERE provider_id = ?`).run(...values);
+    }
+    else {
+        db.prepare(`INSERT INTO provider_transform_rules (provider_id, inject_headers, request_defaults, drop_fields, field_overrides, plugin_name, is_active)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`).run(providerId, rules.inject_headers ? JSON.stringify(rules.inject_headers) : null, rules.request_defaults ? JSON.stringify(rules.request_defaults) : null, rules.drop_fields ? JSON.stringify(rules.drop_fields) : null, rules.field_overrides ? JSON.stringify(rules.field_overrides) : null, rules.plugin_name ?? null, rules.is_active ?? 1);
+    }
+}
+export function deleteTransformRule(db, providerId) {
+    db.prepare("DELETE FROM provider_transform_rules WHERE provider_id = ?").run(providerId);
+}
+export function getAllActiveRules(db) {
+    const rows = db.prepare("SELECT * FROM provider_transform_rules WHERE is_active = 1").all();
+    return rows.map(parseJsonColumns);
+}

package/dist/index.js

@@ -19,6 +19,7 @@ import { openaiProxy } from "./proxy/handler/openai.js";
 import { anthropicProxy } from "./proxy/handler/anthropic.js";
 import { adminRoutes } from "./admin/routes.js";
 import { RetryRuleMatcher } from "./proxy/orchestration/retry-rules.js";
+import { PluginRegistry } from "./proxy/transform/plugin-registry.js";
 import { ProviderSemaphoreManager } from "./proxy/orchestration/semaphore.js";
 import { AdaptiveConcurrencyController } from "./proxy/adaptive-controller.js";
 import { loadEnhancementConfig } from "./proxy/routing/enhancement-config.js";
@@ -210,6 +211,12 @@ export async function buildApp(options) {
         const ac = new AdaptiveConcurrencyController(c.resolve(SERVICE_KEYS.semaphoreManager), app.log);
         return ac;
     });
+    // 注册 PluginRegistry（从 DB 和 plugins 目录加载转换插件）
+    const pluginRegistry = new PluginRegistry();
+    pluginRegistry.loadFromDB(db);
+    const pluginsDir = path.resolve(__dirname, "../plugins/transform");
+    pluginRegistry.scanPluginsDir(pluginsDir);
+    container.register(SERVICE_KEYS.pluginRegistry, () => pluginRegistry);
     // 从容器解析所有服务
     const matcher = container.resolve(SERVICE_KEYS.matcher);
     const semaphoreManager = container.resolve(SERVICE_KEYS.semaphoreManager);
@@ -244,7 +251,7 @@ export async function buildApp(options) {
     // Late-bound close ref — close 函数在 adminRoutes 注册之后才定义，
     // 但 restart API 需要在运行时调用它
     const closeRef = { fn: async () => { } };
-    app.register(adminRoutes, { db, stateRegistry, tracker, adaptiveController, logFileWriter, logsDir, closeFn: () => closeRef.fn() });
+    app.register(adminRoutes, { db, stateRegistry, tracker, adaptiveController, logFileWriter, logsDir, closeFn: () => closeRef.fn(), pluginRegistry });
     // 前端静态文件服务（生产环境）
     const frontendDist = path.resolve(process.env.FRONTEND_DIST || path.join(__dirname, "../frontend-dist"));
     if (existsSync(frontendDist)) {

package/dist/metrics/sse-parser.d.ts

@@ -11,6 +11,8 @@ export interface SSEEvent {
 export declare class SSEParser {
     private buffer;
     isDone: boolean;
+    /** 当前未解析缓冲区长度，子类可据此做内存保护 */
+    get bufferLength(): number;
     feed(chunk: string): SSEEvent[];
     flush(): SSEEvent[];
     private drainEvents;

package/dist/metrics/sse-parser.js

@@ -1,6 +1,10 @@
 export class SSEParser {
     buffer = "";
     isDone = false;
+    /** 当前未解析缓冲区长度，子类可据此做内存保护 */
+    get bufferLength() {
+        return this.buffer.length;
+    }
     feed(chunk) {
         if (this.isDone)
             return [];

package/dist/monitor/request-tracker.js

@@ -224,7 +224,14 @@ export class RequestTracker {
         // request_start: 无需处理，已是原始数据
         // request_complete: strip clientRequest（完成后从 DB 加载详情）
         let payload = data;
-        if (event === "request_complete" && data && typeof data === "object") {
+        if (event === "request_update" && Array.isArray(data)) {
+            payload = data.map((req) => {
+                const copy = { ...req };
+                delete copy.clientRequest;
+                return copy;
+            });
+        }
+        else if ((event === "request_complete" || event === "request_start") && data && typeof data === "object") {
             const copy = { ...data };
             delete copy.clientRequest;
             payload = copy;

package/dist/monitor/types.d.ts

@@ -1,5 +1,5 @@
 export interface ContentBlock {
-    type: 'thinking' | 'text' | 'tool_use';
+    type: 'thinking' | 'text' | 'tool_use' | 'tool_result';
     content: string;
     name?: string;
 }

package/dist/proxy/enhancement/response-cleaner.js

@@ -40,19 +40,27 @@ export function cleanRouterResponses(body) {
         }
         if (msg.role === "assistant") {
             const blocks = Array.isArray(msg.content) ? msg.content : [msg.content];
-            // 清理 router synthetic AskUserQuestion 的 tool_use 消息
+            // 清理 router synthetic AskUserQuestion 的 tool_use 消息（Anthropic content blocks）
             const toolUseBlocks = blocks.filter((b) => b && typeof b === "object" && b.type === "tool_use"
                 && b.name === "AskUserQuestion"
                 && typeof b.id === "string"
                 && b.id.startsWith(TOOL_USE_ID_PREFIX));
             if (toolUseBlocks.length > 0 && toolUseBlocks.length === blocks.length)
                 return false;
-            const texts = blocks
-                .filter((b) => b?.type === "text" && typeof b.text === "string")
-                .map((b) => b.text);
-            const combined = texts.join("");
+            // 提取文本：兼容 Anthropic content blocks 和 OpenAI 纯字符串
+            const textParts = [];
+            for (const b of blocks) {
+                if (typeof b === "string") {
+                    textParts.push(b);
+                }
+                else if (b && typeof b === "object" && b.type === "text" && typeof b.text === "string") {
+                    textParts.push(b.text);
+                }
+            }
+            const combined = textParts.join("");
             const stripped = combined.replace(RE_ROUTER_RESPONSE, "").trim();
-            if (!stripped)
+            // 有 tool_calls 的消息即使 text 为空也保留（OpenAI 格式）
+            if (!stripped && !msg.tool_calls)
                 return false;
         }
         return true;

package/dist/proxy/handler/openai.js

@@ -10,6 +10,9 @@ import { HTTP_NOT_FOUND, HTTP_BAD_GATEWAY } from "../../core/constants.js";
 import { SERVICE_KEYS } from "../../core/container.js";
 const CHAT_COMPLETIONS_PATH = "/v1/chat/completions";
 const MODELS_PATH = "/v1/models";
+/** OpenAI 兼容路径（不带 /v1 前缀），供部分客户端使用 */
+const CHAT_COMPLETIONS_COMPAT_PATH = "/chat/completions";
+const MODELS_COMPAT_PATH = "/models";
 const OPENAI_ERROR_META = {
     modelNotFound: { type: "invalid_request_error", code: "model_not_found" },
     modelNotAllowed: { type: "invalid_request_error", code: "model_not_allowed" },
@@ -27,7 +30,7 @@ function sendError(reply, e) {
 const openaiProxyRaw = (app, opts, done) => {
     const { db, container } = opts;
     const orchestrator = createOrchestrator(container.resolve(SERVICE_KEYS.semaphoreManager), container.resolve(SERVICE_KEYS.tracker), container.resolve(SERVICE_KEYS.adaptiveController));
-    app.post(CHAT_COMPLETIONS_PATH, async (request, reply) => {
+    const handleChatCompletions = async (request, reply) => {
         if (!orchestrator) {
             const body = request.body;
             insertRequestLog(db, {
@@ -48,8 +51,11 @@ const openaiProxyRaw = (app, opts, done) => {
                 }
             },
         });
-    });
-    app.get(MODELS_PATH, async (request, reply) => {
+    };
+    // 规范路径 + 兼容路径（不带 /v1 前缀）
+    app.post(CHAT_COMPLETIONS_PATH, handleChatCompletions);
+    app.post(CHAT_COMPLETIONS_COMPAT_PATH, handleChatCompletions);
+    const handleModels = async (request, reply) => {
         const startTime = Date.now();
         const providers = getActiveProviders(db, "openai");
         if (providers.length === 0) {
@@ -97,7 +103,10 @@ const openaiProxyRaw = (app, opts, done) => {
                 body: { error: { message: "Failed to reach backend service", type: "server_error", code: "upstream_error" } },
             });
         }
-    });
+    };
+    // 规范路径 + 兼容路径
+    app.get(MODELS_PATH, handleModels);
+    app.get(MODELS_COMPAT_PATH, handleModels);
     done();
 };
 export const openaiProxy = fp(openaiProxyRaw, { name: "openai-proxy" });

package/dist/proxy/handler/proxy-handler-utils.js

@@ -1,4 +1,5 @@
 import { createHash } from "crypto";
+import { parseToolArguments } from "../transform/sanitize.js";
 const HASH_DIGEST_LENGTH = 16;
 /** 从 TransportResult 中提取最终 HTTP status code */
 export function getTransportStatusCode(result) {
@@ -17,13 +18,7 @@ export function serializeBlocksForStorage(blocks, apiType) {
             if (b.type === "thinking")
                 return { type: "thinking", thinking: b.content };
             if (b.type === "tool_use") {
-                let input = {};
-                // eslint-disable-next-line taste/no-silent-catch
-                try {
-                    input = JSON.parse(b.content || "{}");
-                }
-                catch { /* tool_use content 非合法 JSON 时保留空对象 */ }
-                return { type: "tool_use", name: b.name ?? "", input };
+                return { type: "tool_use", name: b.name ?? "", input: parseToolArguments(b.content) };
             }
             return { type: "text", text: b.content };
         });

package/dist/proxy/handler/proxy-handler.js

@@ -37,6 +37,7 @@ function rejectAndReply(reply, params, error, errorMessage, providerId) {
 }
 import { getConfig } from "../../config/index.js";
 import { SERVICE_KEYS } from "../../core/container.js";
+import { TransformCoordinator } from "../transform/transform-coordinator.js";
 // ---------- Main entry ----------
 export async function handleProxyRequest(request, reply, apiType, upstreamPath, errors, deps, options) {
     const socketErrorHandler = (err) => request.log.debug({ err }, "client socket error");
@@ -119,6 +120,8 @@ async function executeFailoverLoop(ctx) {
     const config = getConfig();
     const excludeTargets = [];
     let rootLogId = null;
+    // TransformCoordinator 无状态，只需创建一次
+    const coordinator = new TransformCoordinator();
     while (true) {
         const startTime = Date.now();
         const logId = randomUUID();
@@ -169,25 +172,46 @@ async function executeFailoverLoop(ctx) {
         if (!provider || !provider.is_active) {
             return rejectAndReply(reply, rCtx, errors.providerUnavailable(), `Provider '${resolved.provider_id}' unavailable`, resolved.provider_id);
         }
-        if (provider.api_type !== apiType) {
-            return rejectAndReply(reply, rCtx, errors.providerTypeMismatch(), `API type mismatch: expected '${apiType}'`, resolved.provider_id);
-        }
-        // routing — 创建新对象而非 in-place mutation
-        currentBody = { ...currentBody, model: resolved.backend_model };
-        iterationSnapshot.add({ stage: "routing", client_model: effectiveModel, backend_model: resolved.backend_model, provider_id: resolved.provider_id, strategy: resolveResult.targetCount > 1 ? "failover" : "scheduled" });
-        // --- 溢出重定向：上下文超出时切换到更大模型 ---
+        // --- 溢出重定向：上下文超出时切换到更大模型（必须在 transform 之前，确保使用正确的 api_type） ---
         const overflowResult = applyOverflowRedirect(resolved, deps.db, currentBody);
         if (overflowResult) {
             const overflowProvider = getProviderById(deps.db, overflowResult.provider_id);
-            if (overflowProvider && overflowProvider.is_active && overflowProvider.api_type === apiType) {
+            if (overflowProvider && overflowProvider.is_active) {
                 resolved = { ...resolved, provider_id: overflowResult.provider_id, backend_model: overflowResult.backend_model };
                 provider = overflowProvider;
                 currentBody = { ...currentBody, model: overflowResult.backend_model };
-                iterationSnapshot.add({ stage: "overflow", triggered: true, redirect_to: overflowResult.backend_model, redirect_provider: overflowResult.provider_id });
             }
         }
-        else {
-            iterationSnapshot.add({ stage: "overflow", triggered: false });
+        // 格式转换：apiType 不匹配时转换请求体和路径
+        const needsTransform = coordinator.needsTransform(apiType, provider.api_type);
+        let effectiveApiType = apiType;
+        let effectiveUpstreamPath = upstreamPath;
+        if (needsTransform) {
+            const transformed = coordinator.transformRequest(currentBody, apiType, provider.api_type, resolved.backend_model);
+            // 用转换后的结果替换 currentBody
+            currentBody = transformed.body;
+            effectiveUpstreamPath = transformed.upstreamPath;
+            effectiveApiType = provider.api_type;
+        }
+        // routing — 创建新对象而非 in-place mutation
+        currentBody = { ...currentBody, model: resolved.backend_model };
+        iterationSnapshot.add({ stage: "routing", client_model: effectiveModel, backend_model: resolved.backend_model, provider_id: resolved.provider_id, strategy: resolveResult.targetCount > 1 ? "failover" : "scheduled" });
+        // overflow redirect 已在 transform 之前完成，此处不再重复
+        iterationSnapshot.add({ stage: "overflow", triggered: overflowResult != null });
+        // Plugin 调整 body 和 headers（不受 needsTransform 限制，inject_headers 等同格式也需要）
+        let injectedHeaders = {};
+        const pluginRegistry = deps.container.resolve(SERVICE_KEYS.pluginRegistry);
+        if (pluginRegistry) {
+            const pluginCtx = {
+                body: currentBody,
+                headers: {},
+                sourceApiType: apiType,
+                targetApiType: provider.api_type,
+                provider: { id: provider.id, name: provider.name, base_url: provider.base_url, api_type: provider.api_type },
+            };
+            pluginRegistry.applyBeforeRequest(pluginCtx);
+            pluginRegistry.applyAfterRequest(pluginCtx);
+            injectedHeaders = pluginCtx.headers;
         }
         // provider patches — 使用返回值
         const { body: patchedBody, meta: patchMeta } = applyProviderPatches(currentBody, provider);
@@ -202,15 +226,48 @@ async function executeFailoverLoop(ctx) {
         const reqBodyStr = JSON.stringify(patchedBody);
         const clientReq = JSON.stringify({ headers: cliHdrs, body: rawBody });
         const upstreamReqBase = JSON.stringify({
-            url: buildUpstreamUrl(provider.base_url, upstreamPath),
-            headers: sanitizeHeadersForLog(buildUpstreamHeaders(cliHdrs, apiKey, Buffer.byteLength(reqBodyStr), apiType)),
+            url: buildUpstreamUrl(provider.base_url, effectiveUpstreamPath),
+            headers: sanitizeHeadersForLog(buildUpstreamHeaders(cliHdrs, apiKey, Buffer.byteLength(reqBodyStr), effectiveApiType)),
             body: reqBodyStr,
         });
+        const formatTransform = needsTransform ? coordinator.createFormatTransform(apiType, provider.api_type, resolved.backend_model) : undefined;
+        if (formatTransform) {
+            formatTransform.on("warning", (err) => request.log.warn({ err, logId }, "formatTransform warning"));
+        }
+        const responseTransform = needsTransform ? (bodyStr) => {
+            try {
+                const parsed = JSON.parse(bodyStr);
+                if (parsed.type === "error" || parsed.error) {
+                    return coordinator.transformErrorResponse(bodyStr, provider.api_type, apiType);
+                }
+                let transformed = coordinator.transformResponse(bodyStr, provider.api_type, apiType);
+                if (pluginRegistry && !isStream) {
+                    try {
+                        const respObj = JSON.parse(transformed);
+                        const respCtx = {
+                            response: respObj,
+                            sourceApiType: provider.api_type,
+                            targetApiType: apiType,
+                            provider: { id: provider.id, name: provider.name, base_url: provider.base_url, api_type: provider.api_type },
+                        };
+                        pluginRegistry.applyBeforeResponse(respCtx);
+                        pluginRegistry.applyAfterResponse(respCtx);
+                        transformed = JSON.stringify(respCtx.response);
+                    }
+                    catch { /* response hooks best-effort */ }
+                }
+                return transformed;
+            }
+            catch (err) {
+                request.log.error({ err }, "responseTransform failed");
+                return bodyStr;
+            }
+        } : undefined;
         const transportFn = buildTransportFn({
-            provider, apiKey, body: patchedBody, cliHdrs, reply, upstreamPath, apiType,
+            provider, apiKey, body: patchedBody, cliHdrs, reply, upstreamPath: effectiveUpstreamPath, apiType: effectiveApiType,
             isStream, startTime, logId, effectiveModel, originalModel,
             streamTimeoutMs: config.STREAM_TIMEOUT_MS, tracker, matcher, request,
-            streamLoopEnabled,
+            streamLoopEnabled, formatTransform, responseTransform, injectedHeaders,
         });
         const pipelineSnapshot = iterationSnapshot.toJSON();
         try {

package/dist/proxy/patch/deepseek/index.d.ts

@@ -1,6 +1,18 @@
 /**
  * 按序执行所有 DeepSeek 特定补丁。
- * thinking 补丁先执行（影响 assistant 消息结构），
- * tool_result 配对修复后执行。
+ *
+ * Patch 在格式转换之后执行，body 已经是 provider 的 api_type 格式。
+ * DeepSeek 的 api_type 为 openai，但 Anthropic 端点也受支持，
+ * 因此按 apiType 分发不同的 patch 流程。
+ *
+ * Anthropic 格式执行顺序：
+ *   1. patchThinkingParam — 注入 thinking 参数
+ *   2. stripCacheControl — 剥离 cache_control
+ *   3. patchMissingThinkingBlocks — 补 thinking block
+ *   4. patchOrphanToolResults — 清理孤儿 tool_result
+ *
+ * OpenAI 格式执行顺序（参考 docs/deepseek-patch-investigation.md §5.5）：
+ *   1. patchNonDeepSeekToolMessages — 将非 DeepSeek 生成的 tool_calls 降级为 text
+ *   2. patchOrphanToolResultsOA — 处理孤儿 tool 消息
  */
-export declare function applyDeepSeekPatches(body: Record<string, unknown>): void;
+export declare function applyDeepSeekPatches(body: Record<string, unknown>, apiType: "openai" | "anthropic"): void;

package/dist/proxy/patch/deepseek/index.js

@@ -1,11 +1,34 @@
+import { patchThinkingParam } from "./patch-thinking-param.js";
+import { stripCacheControl } from "./patch-cache-control.js";
 import { patchMissingThinkingBlocks } from "./patch-thinking-blocks.js";
-import { patchOrphanToolResults } from "./patch-orphan-tool-results.js";
+import { patchNonDeepSeekToolMessages } from "./patch-non-deepseek-tools.js";
+import { patchOrphanToolResults, patchOrphanToolResultsOA } from "./patch-orphan-tool-results.js";
 /**
  * 按序执行所有 DeepSeek 特定补丁。
- * thinking 补丁先执行（影响 assistant 消息结构），
- * tool_result 配对修复后执行。
+ *
+ * Patch 在格式转换之后执行，body 已经是 provider 的 api_type 格式。
+ * DeepSeek 的 api_type 为 openai，但 Anthropic 端点也受支持，
+ * 因此按 apiType 分发不同的 patch 流程。
+ *
+ * Anthropic 格式执行顺序：
+ *   1. patchThinkingParam — 注入 thinking 参数
+ *   2. stripCacheControl — 剥离 cache_control
+ *   3. patchMissingThinkingBlocks — 补 thinking block
+ *   4. patchOrphanToolResults — 清理孤儿 tool_result
+ *
+ * OpenAI 格式执行顺序（参考 docs/deepseek-patch-investigation.md §5.5）：
+ *   1. patchNonDeepSeekToolMessages — 将非 DeepSeek 生成的 tool_calls 降级为 text
+ *   2. patchOrphanToolResultsOA — 处理孤儿 tool 消息
  */
-export function applyDeepSeekPatches(body) {
-    patchMissingThinkingBlocks(body);
-    patchOrphanToolResults(body);
+export function applyDeepSeekPatches(body, apiType) {
+    if (apiType === "anthropic") {
+        patchThinkingParam(body, apiType);
+        stripCacheControl(body);
+        patchMissingThinkingBlocks(body);
+        patchOrphanToolResults(body);
+    }
+    else {
+        patchNonDeepSeekToolMessages(body);
+        patchOrphanToolResultsOA(body);
+    }
 }

package/dist/proxy/patch/deepseek/patch-cache-control.d.ts

@@ -0,0 +1,6 @@
+/**
+ * DeepSeek 的 Anthropic 兼容 API 不支持 cache_control。
+ * Claude Code 等客户端会在 content block 和 system prompt 上标注
+ * cache_control: { type: "ephemeral" }，需要剥离以避免上游报错。
+ */
+export declare function stripCacheControl(body: Record<string, unknown>): void;

package/dist/proxy/patch/deepseek/patch-cache-control.js

@@ -0,0 +1,30 @@
+/**
+ * DeepSeek 的 Anthropic 兼容 API 不支持 cache_control。
+ * Claude Code 等客户端会在 content block 和 system prompt 上标注
+ * cache_control: { type: "ephemeral" }，需要剥离以避免上游报错。
+ */
+export function stripCacheControl(body) {
+    // 处理顶级 system 字段（Anthropic 协议中 system 可以是 content block 数组）
+    if (Array.isArray(body.system)) {
+        for (const block of body.system) {
+            delete block.cache_control;
+        }
+    }
+    // 处理 messages 中的 content block
+    if (!body.messages)
+        return;
+    const messages = body.messages;
+    for (const msg of messages) {
+        if (Array.isArray(msg.content)) {
+            for (const block of msg.content) {
+                delete block.cache_control;
+            }
+        }
+    }
+    // 处理 tools 上的 cache_control
+    if (Array.isArray(body.tools)) {
+        for (const tool of body.tools) {
+            delete tool.cache_control;
+        }
+    }
+}