llm-simple-router 0.7.1 → 0.8.2

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

@@ -16,6 +16,7 @@ import { applyOverflowRedirect } from "../routing/overflow.js";
 import { applyProviderPatches } from "../patch/index.js";
 import { PipelineSnapshot } from "../pipeline-snapshot.js";
 import { maybeInjectModelInfoTag } from "../response-transform.js";
+import { applyToolRoundLimit } from "../patch/tool-round-limiter.js";
 import { loadEnhancementConfig } from "../routing/enhancement-config.js";
 import { getTransportStatusCode, serializeBlocksForStorage, extractLastToolUse } from "./proxy-handler-utils.js";
 const HTTP_ERROR_THRESHOLD = 400;
@@ -37,6 +38,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");
@@ -57,13 +59,22 @@ export async function handleProxyRequest(request, reply, apiType, upstreamPath,
     // enhancement 阶段
     const { body: enhancedBody, effectiveModel, originalModel, interceptResponse, meta: enhMeta } = applyEnhancement(deps.db, request.body, clientModel, sessionId, request.routerKey);
     snapshot.add({ stage: "enhancement", router_tags_stripped: enhMeta.router_tags_stripped, directive: enhMeta.directive });
-    // tool guard 阶段 — 使用 enhancedBody
+    // tool round limiter 阶段 — 检测连续工具调用轮数，超阈值时注入提示词
     let pipelineBody = enhancedBody;
+    if (enhancementConfig.tool_round_limit_enabled) {
+        const roundResult = applyToolRoundLimit(enhancedBody, apiType);
+        if (roundResult.injected) {
+            pipelineBody = roundResult.body;
+            snapshot.add({ stage: "tool_round_limit", action: "inject_warning", rounds: roundResult.rounds });
+            request.log.info({ sessionId, rounds: roundResult.rounds }, "Tool round limit reached, injecting warning prompt");
+        }
+    }
+    // tool guard 阶段 — 使用 pipelineBody（可能已被 round limiter 修改）
     const sessionTracker = deps.container.resolve(SERVICE_KEYS.sessionTracker);
     if (enhancementConfig.tool_call_loop_enabled && sessionTracker && sessionId) {
         const routerKeyId = request.routerKey?.id ?? null;
         const sessionKey = routerKeyId ? `${routerKeyId}:${sessionId}` : sessionId;
-        const lastToolUse = extractLastToolUse(enhancedBody);
+        const lastToolUse = extractLastToolUse(pipelineBody);
         if (lastToolUse) {
             const toolGuard = new ToolLoopGuard(sessionTracker, {
                 enabled: true,
@@ -75,7 +86,7 @@ export async function handleProxyRequest(request, reply, apiType, upstreamPath,
                 const loopCount = sessionTracker.getLoopCount(sessionKey);
                 if (loopCount === 1) {
                     // 层级 1：透明重试 — 注入中断提示词
-                    pipelineBody = toolGuard.injectLoopBreakPrompt(enhancedBody, apiType, lastToolUse.toolName);
+                    pipelineBody = toolGuard.injectLoopBreakPrompt(pipelineBody, apiType, lastToolUse.toolName);
                     snapshot.add({ stage: "tool_guard", action: "inject_break_prompt", tool: lastToolUse.toolName });
                     request.log.warn({ sessionId, toolName: lastToolUse.toolName, loopCount }, "Tool call loop detected, injecting break prompt");
                 }
@@ -119,6 +130,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 +182,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 +236,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;
+        }
+    }
+}

package/dist/proxy/patch/deepseek/patch-non-deepseek-tools.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 方案 7（OpenAI 格式）：将非 DeepSeek 生成的 tool 消息降级为 text。
+ *
+ * 当 agent 从其他模型切换到 DeepSeek 时，历史中的 tool_calls 消息
+ * 可能不包含 DeepSeek 要求的 reasoning_content，导致上游校验失败或
+ * 工具调用无限循环。
+ *
+ * 判断标准：assistant 消息有 tool_calls 但无 reasoning_content → 非 DeepSeek 生成。
+ *
+ * 转换：
+ * - assistant.tool_calls → JSON 序列化到 content，删除 tool_calls
+ * - role:"tool" → role:"user"，内容 JSON 序列化，删除 tool_call_id
+ *
+ * 设计文档：docs/deepseek-patch-investigation.md §5
+ */
+export declare function patchNonDeepSeekToolMessages(body: Record<string, unknown>): void;

package/dist/proxy/patch/deepseek/patch-non-deepseek-tools.js

@@ -0,0 +1,74 @@
+/**
+ * 方案 7（OpenAI 格式）：将非 DeepSeek 生成的 tool 消息降级为 text。
+ *
+ * 当 agent 从其他模型切换到 DeepSeek 时，历史中的 tool_calls 消息
+ * 可能不包含 DeepSeek 要求的 reasoning_content，导致上游校验失败或
+ * 工具调用无限循环。
+ *
+ * 判断标准：assistant 消息有 tool_calls 但无 reasoning_content → 非 DeepSeek 生成。
+ *
+ * 转换：
+ * - assistant.tool_calls → JSON 序列化到 content，删除 tool_calls
+ * - role:"tool" → role:"user"，内容 JSON 序列化，删除 tool_call_id
+ *
+ * 设计文档：docs/deepseek-patch-investigation.md §5
+ */
+export function patchNonDeepSeekToolMessages(body) {
+    const messages = body.messages;
+    if (!messages || !Array.isArray(messages))
+        return;
+    // Step 1: 收集需要降级的 tool_call IDs
+    const downgradeIds = new Set();
+    for (const msg of messages) {
+        if (msg.role !== "assistant")
+            continue;
+        const toolCalls = msg.tool_calls;
+        if (!toolCalls || toolCalls.length === 0)
+            continue;
+        // 有 tool_calls 但无 reasoning_content → 非 DeepSeek 生成
+        if (!msg.reasoning_content) {
+            for (const tc of toolCalls) {
+                if (typeof tc.id === "string")
+                    downgradeIds.add(tc.id);
+            }
+        }
+    }
+    if (downgradeIds.size === 0)
+        return;
+    // Step 2: 降级 assistant 消息 — tool_calls → text content
+    for (const msg of messages) {
+        if (msg.role !== "assistant")
+            continue;
+        const toolCalls = msg.tool_calls;
+        if (!toolCalls || toolCalls.length === 0)
+            continue;
+        if (msg.reasoning_content)
+            continue;
+        const serialized = JSON.stringify(toolCalls.map(tc => ({
+            id: tc.id,
+            type: "function",
+            function: {
+                name: tc.function?.name,
+                arguments: tc.function?.arguments,
+            },
+        })));
+        const existing = typeof msg.content === "string" ? msg.content : "";
+        msg.content = existing ? `${existing}\n[tool_calls]: ${serialized}` : `[tool_calls]: ${serialized}`;
+        delete msg.tool_calls;
+    }
+    // Step 3: 降级对应的 tool 消息 — role:"tool" → role:"user"
+    for (const msg of messages) {
+        if (msg.role !== "tool")
+            continue;
+        const toolCallId = String(msg.tool_call_id ?? "");
+        if (!downgradeIds.has(toolCallId))
+            continue;
+        msg.role = "user";
+        msg.content = JSON.stringify({
+            type: "tool_result",
+            tool_use_id: toolCallId,
+            content: msg.content,
+        });
+        delete msg.tool_call_id;
+    }
+}

package/dist/proxy/patch/deepseek/patch-orphan-tool-results.d.ts

@@ -7,6 +7,15 @@
  * 2. 移除 tool_use_id 不在集合中的 tool_result 块
  * 3. 移除清空后的空 user 消息
  * 4. 合并相邻的 user 消息（Anthropic API 不允许连续 user 消息）
- * 5. 合并相邻的 assistant 消息（同理）
+ * 5. 合并相邻的 assistant 消息（带 tool_use 去重）
+ * 6. 移除 content 为空数组的 assistant 消息
+ * 7. 最终合并连续同角色消息
  */
 export declare function patchOrphanToolResults(body: Record<string, unknown>): void;
+/**
+ * OpenAI 格式版本的孤儿 tool 消息清理。
+ *
+ * 检测 role:"tool" 消息的 tool_call_id 是否有对应的 assistant tool_calls[].id。
+ * 移除孤儿 tool 消息后合并连续 user 消息。
+ */
+export declare function patchOrphanToolResultsOA(body: Record<string, unknown>): void;

package/dist/proxy/patch/deepseek/patch-orphan-tool-results.js

@@ -1,3 +1,4 @@
+import { mergeConsecutive, mergeAssistantContent } from "./utils.js";
 /**
  * 修复孤儿 tool_result 块——Claude Code 的 context management 截断历史消息时
  * 可能丢失 tool_use 块但保留对应的 tool_result，导致 DeepSeek 严格校验失败。
@@ -7,7 +8,9 @@
  * 2. 移除 tool_use_id 不在集合中的 tool_result 块
  * 3. 移除清空后的空 user 消息
  * 4. 合并相邻的 user 消息（Anthropic API 不允许连续 user 消息）
- * 5. 合并相邻的 assistant 消息（同理）
+ * 5. 合并相邻的 assistant 消息（带 tool_use 去重）
+ * 6. 移除 content 为空数组的 assistant 消息
+ * 7. 最终合并连续同角色消息
  */
 export function patchOrphanToolResults(body) {
     if (!body.messages)
@@ -60,18 +63,65 @@ export function patchOrphanToolResults(body) {
     }
     // Step 4: 合并相邻的 user 消息
     mergeConsecutive(messages, "user");
-    // Step 5: 合并相邻的 assistant 消息（删除空 user 消息后可能产生）
-    mergeConsecutive(messages, "assistant");
+    // Step 5: 合并相邻的 assistant 消息（带 tool_use 去重）
+    mergeConsecutive(messages, "assistant", mergeAssistantContent);
+    // Step 6: 移除 content 为空数组的 assistant 消息
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.role === "assistant" && Array.isArray(msg.content) && msg.content.length === 0) {
+            messages.splice(i, 1);
+        }
+    }
+    // Step 7: 删除空 assistant 后可能产生连续同角色消息，再合并一次
+    mergeConsecutive(messages, "user");
+    mergeConsecutive(messages, "assistant", mergeAssistantContent);
 }
-function mergeConsecutive(messages, role) {
+/**
+ * OpenAI 格式版本的孤儿 tool 消息清理。
+ *
+ * 检测 role:"tool" 消息的 tool_call_id 是否有对应的 assistant tool_calls[].id。
+ * 移除孤儿 tool 消息后合并连续 user 消息。
+ */
+export function patchOrphanToolResultsOA(body) {
+    const messages = body.messages;
+    if (!messages || !Array.isArray(messages) || messages.length === 0)
+        return;
+    // Step 1: 收集所有 assistant tool_calls IDs
+    const knownToolCallIds = new Set();
+    for (const msg of messages) {
+        if (msg.role !== "assistant")
+            continue;
+        const toolCalls = msg.tool_calls;
+        if (!toolCalls)
+            continue;
+        for (const tc of toolCalls) {
+            if (typeof tc.id === "string")
+                knownToolCallIds.add(tc.id);
+        }
+    }
+    // Step 2: 移除孤儿 tool 消息（逆序遍历避免索引偏移）
+    let removedAny = false;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.role !== "tool")
+            continue;
+        const toolCallId = String(msg.tool_call_id ?? "");
+        if (!knownToolCallIds.has(toolCallId)) {
+            messages.splice(i, 1);
+            removedAny = true;
+        }
+    }
+    if (!removedAny)
+        return;
+    // Step 3: 合并连续 user 消息
     let i = 1;
     while (i < messages.length) {
-        if (messages[i].role === role && messages[i - 1].role === role) {
+        if (messages[i].role === "user" && messages[i - 1].role === "user") {
             const prev = messages[i - 1];
             const curr = messages[i];
-            const prevContent = normalizeToArray(prev.content);
-            const currContent = normalizeToArray(curr.content);
-            prev.content = [...prevContent, ...currContent];
+            const prevContent = typeof prev.content === "string" ? prev.content : JSON.stringify(prev.content ?? "");
+            const currContent = typeof curr.content === "string" ? curr.content : JSON.stringify(curr.content ?? "");
+            prev.content = prevContent + "\n" + currContent;
             messages.splice(i, 1);
         }
         else {
@@ -79,10 +129,3 @@ function mergeConsecutive(messages, role) {
         }
     }
 }
-function normalizeToArray(content) {
-    if (Array.isArray(content))
-        return content;
-    if (typeof content === "string")
-        return [{ type: "text", text: content }];
-    return [{ type: "text", text: String(content ?? "") }];
-}

package/dist/proxy/patch/deepseek/patch-thinking-blocks.d.ts

@@ -1,6 +1,10 @@
 /**
  * DeepSeek thinking 协议实现不完整：开启 thinking 模式后部分轮次不返回 thinking block，
  * 但后续请求要求历史 assistant 消息必须携带 thinking block。
- * 在 content 数组开头补一个空 thinking block 以绕过上游校验。
+ *
+ * 处理：
+ * 1. 检测历史 thinking block 是否带 signature 字段，保持格式一致
+ * 2. 对缺少 thinking block 的 assistant 消息，在 content 数组开头补一个空 thinking block
+ * 3. 对 thinking block 不在首位的 assistant 消息，修正位置
  */
 export declare function patchMissingThinkingBlocks(body: Record<string, unknown>): void;

package/dist/proxy/patch/deepseek/patch-thinking-blocks.js

@@ -1,7 +1,11 @@
 /**
  * DeepSeek thinking 协议实现不完整：开启 thinking 模式后部分轮次不返回 thinking block，
  * 但后续请求要求历史 assistant 消息必须携带 thinking block。
- * 在 content 数组开头补一个空 thinking block 以绕过上游校验。
+ *
+ * 处理：
+ * 1. 检测历史 thinking block 是否带 signature 字段，保持格式一致
+ * 2. 对缺少 thinking block 的 assistant 消息，在 content 数组开头补一个空 thinking block
+ * 3. 对 thinking block 不在首位的 assistant 消息，修正位置
  */
 export function patchMissingThinkingBlocks(body) {
     if (!body.messages)
@@ -13,12 +17,41 @@ export function patchMissingThinkingBlocks(body) {
         && msg.content.some((b) => b && typeof b === "object" && b.type === "thinking"));
     if (!thinkingActive)
         return;
+    // 检测历史中 thinking block 是否带 signature 字段
+    const needsSignature = detectSignatureUsage(messages);
     for (const msg of messages) {
         if (msg.role !== "assistant" || !Array.isArray(msg.content))
             continue;
-        const hasThinking = msg.content.some((b) => b && typeof b === "object" && b.type === "thinking");
-        if (!hasThinking) {
-            msg.content.unshift({ type: "thinking", thinking: "", signature: "" });
+        const blocks = msg.content;
+        const thinkingIdx = blocks.findIndex((b) => b && typeof b === "object" && b.type === "thinking");
+        if (thinkingIdx === -1) {
+            // 不存在 thinking block → 补一个
+            const emptyThinking = { type: "thinking", thinking: "" };
+            if (needsSignature)
+                emptyThinking.signature = "";
+            blocks.unshift(emptyThinking);
+        }
+        else if (thinkingIdx > 0) {
+            // thinking block 不在第一位 → 移到首位
+            const [thinkingBlock] = blocks.splice(thinkingIdx, 1);
+            blocks.unshift(thinkingBlock);
+        }
+    }
+}
+/**
+ * 扫描历史 assistant 消息中的 thinking block，
+ * 判断是否需要 signature 字段。
+ */
+function detectSignatureUsage(messages) {
+    for (const msg of messages) {
+        if (msg.role !== "assistant" || !Array.isArray(msg.content))
+            continue;
+        for (const b of msg.content) {
+            if (b && typeof b === "object" && b.type === "thinking") {
+                return "signature" in b;
+            }
         }
     }
+    // 无历史 thinking block 时，默认带 signature（保持向后兼容）
+    return true;
 }

package/dist/proxy/patch/deepseek/patch-thinking-param.d.ts

@@ -0,0 +1,6 @@
+/**
+ * DeepSeek 开启 thinking 后，后续请求必须显式传 thinking 参数。
+ * 客户端（如 Claude Code）可能在后续轮次省略此参数。
+ * 检测历史中是否存在 thinking 内容，自动补上参数。
+ */
+export declare function patchThinkingParam(body: Record<string, unknown>, apiType: "openai" | "anthropic"): void;

package/dist/proxy/patch/deepseek/patch-thinking-param.js

@@ -0,0 +1,32 @@
+/**
+ * DeepSeek 开启 thinking 后，后续请求必须显式传 thinking 参数。
+ * 客户端（如 Claude Code）可能在后续轮次省略此参数。
+ * 检测历史中是否存在 thinking 内容，自动补上参数。
+ */
+export function patchThinkingParam(body, apiType) {
+    if (body.thinking)
+        return;
+    const messages = body.messages;
+    if (!messages)
+        return;
+    const hasThinking = messages.some(msg => {
+        if (msg.role !== "assistant")
+            return false;
+        if (apiType === "openai") {
+            return msg.reasoning_content !== undefined;
+        }
+        // Anthropic 格式
+        return Array.isArray(msg.content) &&
+            msg.content
+                .some(b => b?.type === "thinking");
+    });
+    if (!hasThinking)
+        return;
+    if (apiType === "openai") {
+        body.thinking = { type: "enabled" };
+    }
+    else {
+        // Anthropic 格式要求 budget_tokens
+        body.thinking = { type: "enabled", budget_tokens: 10000 };
+    }
+}

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

@@ -0,0 +1,8 @@
+export type ContentBlock = Record<string, unknown>;
+export type Message = {
+    role: string;
+    content: unknown;
+};
+export declare function normalizeToArray(content: unknown): ContentBlock[];
+export declare function mergeConsecutive(messages: Message[], role: string, mergeAssistant?: (prev: ContentBlock[], curr: ContentBlock[]) => ContentBlock[]): void;
+export declare function mergeAssistantContent(prev: ContentBlock[], curr: ContentBlock[]): ContentBlock[];

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

@@ -0,0 +1,38 @@
+export function normalizeToArray(content) {
+    if (Array.isArray(content))
+        return content;
+    if (typeof content === "string")
+        return [{ type: "text", text: content }];
+    return [{ type: "text", text: String(content ?? "") }];
+}
+export function mergeConsecutive(messages, role, mergeAssistant) {
+    let i = 1;
+    while (i < messages.length) {
+        if (messages[i].role === role && messages[i - 1].role === role) {
+            const prev = messages[i - 1];
+            const curr = messages[i];
+            const prevContent = normalizeToArray(prev.content);
+            const currContent = normalizeToArray(curr.content);
+            if (role === "assistant" && mergeAssistant) {
+                prev.content = mergeAssistant(prevContent, currContent);
+            }
+            else {
+                prev.content = [...prevContent, ...currContent];
+            }
+            messages.splice(i, 1);
+        }
+        else {
+            i++;
+        }
+    }
+}
+export function mergeAssistantContent(prev, curr) {
+    const seenToolIds = new Set();
+    for (const b of prev) {
+        if (b?.type === "tool_use" && typeof b.id === "string") {
+            seenToolIds.add(b.id);
+        }
+    }
+    const deduped = curr.filter(b => !(b?.type === "tool_use" && typeof b.id === "string" && seenToolIds.has(b.id)));
+    return [...prev, ...deduped];
+}

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

@@ -1,5 +1,6 @@
-interface ProviderInfo {
+export interface ProviderInfo {
     base_url: string;
+    api_type: string;
 }
 export interface ProviderPatchMeta {
     types: string[];
@@ -12,4 +13,3 @@ export declare function applyProviderPatches(body: Record<string, unknown>, prov
     body: Record<string, unknown>;
     meta: ProviderPatchMeta;
 };
-export {};