llm-simple-router 0.7.1 → 0.8.2

package/dist/proxy/patch/index.js

@@ -1,15 +1,61 @@
 import { applyDeepSeekPatches } from "./deepseek/index.js";
+const OPENAI_ORIGIN_HOSTS = ["api.openai.com", "openai.com"];
 /**
  * 根据 provider 信息分发到对应的补丁逻辑。
  * 返回浅拷贝 body + 执行的补丁类型列表，不修改原始 body。
  */
 export function applyProviderPatches(body, provider) {
+    const patches = [];
+    let cloned = false;
+    let patched;
+    const ensureCloned = () => {
+        if (!cloned) {
+            patched = JSON.parse(JSON.stringify(body));
+            cloned = true;
+        }
+        return patched;
+    };
+    // 通用补丁：OpenAI 兼容 provider（非 OpenAI 原生）不支持 developer role
+    if (provider.api_type === "openai" && !isOpenAIOrigin(provider.base_url)) {
+        if (hasDeveloperRole(body)) {
+            patchDeveloperRole(ensureCloned());
+            patches.push("developer_role");
+        }
+    }
+    // DeepSeek 特定补丁
     if (needsDeepSeekPatch(body, provider)) {
-        const cloned = JSON.parse(JSON.stringify(body));
-        applyDeepSeekPatches(cloned);
-        return { body: cloned, meta: { types: ["deepseek"] } };
+        applyDeepSeekPatches(ensureCloned(), provider.api_type);
+        patches.push("deepseek");
+    }
+    return { body: patched ?? body, meta: { types: patches } };
+}
+/** 判断是否为 OpenAI 官方端点 */
+function isOpenAIOrigin(baseUrl) {
+    try {
+        const host = new URL(baseUrl).hostname;
+        return OPENAI_ORIGIN_HOSTS.some(origin => host === origin || host.endsWith(`.${origin}`));
+    }
+    catch {
+        return false;
+    }
+}
+/** 检查 messages 中是否包含 developer role */
+function hasDeveloperRole(body) {
+    const messages = body.messages;
+    if (!messages)
+        return false;
+    return messages.some(m => m.role === "developer");
+}
+/** 将 developer role 转换为 system */
+function patchDeveloperRole(body) {
+    const messages = body.messages;
+    if (!messages)
+        return;
+    for (const msg of messages) {
+        if (msg.role === "developer") {
+            msg.role = "system";
+        }
     }
-    return { body, meta: { types: [] } };
 }
 /** DeepSeek patch 触发条件：直连 DeepSeek，或经代理转发且模型名含 deepseek */
 function needsDeepSeekPatch(body, provider) {

package/dist/proxy/patch/router-cleanup.js

@@ -1,4 +1,5 @@
 import { TOOL_USE_ID_PREFIX } from "../enhancement/directive-parser.js";
+import { mergeConsecutive } from "./deepseek/utils.js";
 /**
  * 从消息中移除 router 注入的合成 tool_use/tool_result。
  *
@@ -61,27 +62,3 @@ export function patchRouterSyntheticToolCalls(body) {
     mergeConsecutive(messages, "user");
     mergeConsecutive(messages, "assistant");
 }
-function mergeConsecutive(messages, role) {
-    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];
-            prev.content = [
-                ...normalizeToArray(prev.content),
-                ...normalizeToArray(curr.content),
-            ];
-            messages.splice(i, 1);
-        }
-        else {
-            i++;
-        }
-    }
-}
-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/safe-sse-parser.d.ts

@@ -0,0 +1,9 @@
+import { SSEParser, type SSEEvent } from "../../metrics/sse-parser.js";
+/**
+ * SSEParser 子类，增加未解析缓冲区上限保护。
+ * 防止畸形 SSE（无 \n\n 分隔）导致缓冲区无限增长。
+ * 只检查当前未解析缓冲区大小，已消费的事件不计入。
+ */
+export declare class SafeSSEParser extends SSEParser {
+    feed(chunk: string): SSEEvent[];
+}

package/dist/proxy/patch/safe-sse-parser.js

@@ -0,0 +1,16 @@
+import { SSEParser } from "../../metrics/sse-parser.js";
+const MAX_BUFFER = 65536;
+/**
+ * SSEParser 子类，增加未解析缓冲区上限保护。
+ * 防止畸形 SSE（无 \n\n 分隔）导致缓冲区无限增长。
+ * 只检查当前未解析缓冲区大小，已消费的事件不计入。
+ */
+export class SafeSSEParser extends SSEParser {
+    feed(chunk) {
+        const events = super.feed(chunk);
+        if (this.bufferLength > MAX_BUFFER) {
+            throw new Error(`SSE buffer exceeded ${MAX_BUFFER} bytes`);
+        }
+        return events;
+    }
+}

package/dist/proxy/patch/tool-round-limiter.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 工具调用轮数限制器。
+ *
+ * 检测 messages 中连续的 "assistant(tool_use) → user(tool_result)" 轮次数量，
+ * 超过阈值时注入提示词提醒 AI 不要陷入无限循环。
+ *
+ * 与 loop-prevention/tool-loop-guard 不同：
+ * - tool-loop-guard 关注"同一工具重复调用"（N-gram 检测 input 重复）
+ * - 本模块关注"工具调用轮数过多"（不管是否同一工具，反映 AI 反复操作却无法完成）
+ */
+/** OpenAI 格式的 tool_call */
+interface OpenAIToolCall {
+    type?: string;
+    function?: {
+        name?: string;
+    };
+}
+interface Message {
+    role?: string;
+    content?: unknown;
+    tool_calls?: OpenAIToolCall[];
+}
+/**
+ * 统计 messages 中连续的"工具调用轮数"。
+ *
+ * 一轮定义：assistant 消息包含 tool_use → 后面紧接 user 消息包含 tool_result。
+ * 从最后一条消息向前扫描，遇到非工具轮即停止。
+ */
+export declare function countConsecutiveToolRounds(messages: Message[]): number;
+/**
+ * 检测并注入提示词。返回可能修改后的 body（浅拷贝），未超阈值时原样返回。
+ */
+export declare function applyToolRoundLimit(body: Record<string, unknown>, apiType: "openai" | "anthropic", maxRounds?: number): {
+    body: Record<string, unknown>;
+    injected: boolean;
+    rounds: number;
+};
+export {};

package/dist/proxy/patch/tool-round-limiter.js

@@ -0,0 +1,115 @@
+/**
+ * 工具调用轮数限制器。
+ *
+ * 检测 messages 中连续的 "assistant(tool_use) → user(tool_result)" 轮次数量，
+ * 超过阈值时注入提示词提醒 AI 不要陷入无限循环。
+ *
+ * 与 loop-prevention/tool-loop-guard 不同：
+ * - tool-loop-guard 关注"同一工具重复调用"（N-gram 检测 input 重复）
+ * - 本模块关注"工具调用轮数过多"（不管是否同一工具，反映 AI 反复操作却无法完成）
+ */
+const DEFAULT_MAX_ROUNDS = 5;
+const LOOP_WARNING_PROMPT = "[系统提醒] 你已经连续进行了多轮工具调用但似乎还没有完成任务。请注意不要陷入无限循环，停下来总结当前进展，如果无法继续请直接告知用户。";
+/**
+ * 统计 messages 中连续的"工具调用轮数"。
+ *
+ * 一轮定义：assistant 消息包含 tool_use → 后面紧接 user 消息包含 tool_result。
+ * 从最后一条消息向前扫描，遇到非工具轮即停止。
+ */
+export function countConsecutiveToolRounds(messages) {
+    let rounds = 0;
+    let i = messages.length - 1;
+    while (i >= 1) {
+        const msg = messages[i];
+        // 期望：user 消息包含 tool_result（Anthropic）或 role=tool（OpenAI）
+        if (msg.role === "user" || msg.role === "tool") {
+            const hasToolResult = hasToolResultContent(msg);
+            if (hasToolResult || msg.role === "tool") {
+                // 向前找对应的 assistant 消息
+                let j = i - 1;
+                while (j >= 0 && messages[j].role !== "assistant")
+                    j--;
+                if (j >= 0 && hasToolUseContent(messages[j])) {
+                    rounds++;
+                    i = j - 1;
+                    continue;
+                }
+            }
+        }
+        // assistant 消息本身可能包含 tool_use（最后一轮可能还没 tool_result）
+        if (msg.role === "assistant" && hasToolUseContent(msg)) {
+            rounds++;
+            i--;
+            continue;
+        }
+        break;
+    }
+    return rounds;
+}
+/**
+ * 检测并注入提示词。返回可能修改后的 body（浅拷贝），未超阈值时原样返回。
+ */
+export function applyToolRoundLimit(body, apiType, maxRounds = DEFAULT_MAX_ROUNDS) {
+    const messages = body.messages ?? [];
+    if (messages.length === 0)
+        return { body, injected: false, rounds: 0 };
+    const rounds = countConsecutiveToolRounds(messages);
+    if (rounds <= maxRounds)
+        return { body, injected: false, rounds };
+    const cloned = { ...body, messages: [...messages] };
+    const clonedMessages = cloned.messages;
+    // 在尾部注入：修改最后一条消息的 content，不插入新消息到头部
+    // 这样不会使 LLM 的 KV cache 失效（前面的 messages 保持不变）
+    if (apiType === "anthropic") {
+        // Anthropic：将提示词作为 text block 追加到最后一条消息的 content 末尾
+        const lastMsg = clonedMessages[clonedMessages.length - 1];
+        if (lastMsg && Array.isArray(lastMsg.content)) {
+            const patched = [...lastMsg.content];
+            patched.push({ type: "text", text: LOOP_WARNING_PROMPT });
+            lastMsg.content = patched;
+        }
+        else if (lastMsg && typeof lastMsg.content === "string") {
+            lastMsg.content = [
+                { type: "text", text: lastMsg.content },
+                { type: "text", text: LOOP_WARNING_PROMPT },
+            ];
+        }
+        else {
+            // fallback：追加 user 消息
+            clonedMessages.push({ role: "user", content: [{ type: "text", text: LOOP_WARNING_PROMPT }] });
+        }
+    }
+    else {
+        // OpenAI 格式：将提示词追加到最后一条消息的 content 末尾
+        const lastMsg = clonedMessages[clonedMessages.length - 1];
+        if (lastMsg && typeof lastMsg.content === "string") {
+            lastMsg.content = lastMsg.content + "\n\n" + LOOP_WARNING_PROMPT;
+        }
+        else if (lastMsg && lastMsg.content != null) {
+            lastMsg.content = JSON.stringify(lastMsg.content) + "\n\n" + LOOP_WARNING_PROMPT;
+        }
+        else {
+            // fallback：追加 user 消息
+            clonedMessages.push({ role: "user", content: LOOP_WARNING_PROMPT });
+        }
+    }
+    return { body: cloned, injected: true, rounds };
+}
+// --- helpers ---
+/** Anthropic 格式：检查 content 数组中是否包含 tool_use */
+function hasToolUseContent(msg) {
+    if (Array.isArray(msg.content)) {
+        return msg.content.some((block) => block.type === "tool_use");
+    }
+    // OpenAI 格式
+    if (msg.tool_calls && msg.tool_calls.length > 0)
+        return true;
+    return false;
+}
+/** Anthropic 格式：检查 content 数组中是否包含 tool_result */
+function hasToolResultContent(msg) {
+    if (Array.isArray(msg.content)) {
+        return msg.content.some((block) => block.type === "tool_result");
+    }
+    return false;
+}

package/dist/proxy/pipeline-snapshot.d.ts

@@ -6,6 +6,10 @@ export type StageRecord = {
     stage: "enhancement";
     router_tags_stripped: number;
     directive: DirectiveMeta | null;
+} | {
+    stage: "tool_round_limit";
+    action: string;
+    rounds: number;
 } | {
     stage: "tool_guard";
     action: string;

package/dist/proxy/proxy-core.js

@@ -77,6 +77,7 @@ export function buildUpstreamHeaders(clientHeaders, apiKey, payloadBytes, apiTyp
     const headers = selectHeaders(clientHeaders, SKIP_UPSTREAM);
     if (apiType === "anthropic") {
         headers["x-api-key"] = apiKey;
+        headers["anthropic-version"] ??= "2023-06-01";
     }
     else {
         headers["Authorization"] = `Bearer ${apiKey}`;

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

@@ -4,7 +4,7 @@ import { type FailoverContext } from "./log-helpers.js";
 import type { FastifyRequest } from "fastify";
 import type { ResilienceAttempt } from "../core/types.js";
 import type { TransportResult } from "./types.js";
-/** 日志存储前脱敏 Authorization header，避免 API Key 被持久化 */
+/** 日志存储前脱敏 Authorization / x-api-key header，避免 API Key 被持久化 */
 export declare function sanitizeHeadersForLog(headers: Record<string, string>): Record<string, string>;
 export declare function handleIntercept(db: Database.Database, apiType: "openai" | "anthropic", request: FastifyRequest, reply: import("fastify").FastifyReply, interceptResponse: {
     statusCode: number;

package/dist/proxy/proxy-logging.js

@@ -7,12 +7,12 @@ import { estimateInputTokens } from "../utils/token-counter.js";
 import { UPSTREAM_SUCCESS } from "./types.js";
 import { HTTP_BAD_GATEWAY } from "../core/constants.js";
 // ---------- Header sanitization ----------
-const AUTH_HEADER_RE = /^authorization$/i;
-/** 日志存储前脱敏 Authorization header，避免 API Key 被持久化 */
+const SENSITIVE_HEADER_RE = /^(authorization|x-api-key)$/i;
+/** 日志存储前脱敏 Authorization / x-api-key header，避免 API Key 被持久化 */
 export function sanitizeHeadersForLog(headers) {
     const sanitized = {};
     for (const [key, value] of Object.entries(headers)) {
-        sanitized[key] = AUTH_HEADER_RE.test(key) ? value.replace(/(Bearer\s+)\S+/, "$1sk-***") : value;
+        sanitized[key] = SENSITIVE_HEADER_RE.test(key) ? value.replace(/(Bearer\s+)\S+/, "$1sk-***") : value;
     }
     return sanitized;
 }

package/dist/proxy/routing/enhancement-config.d.ts

@@ -3,6 +3,7 @@ export interface EnhancementConfig {
     claude_code_enabled: boolean;
     tool_call_loop_enabled: boolean;
     stream_loop_enabled: boolean;
+    tool_round_limit_enabled: boolean;
 }
 /** 集中加载 proxy_enhancement 配置，避免多处重复 getSetting + JSON.parse */
 export declare function loadEnhancementConfig(db: Database.Database): EnhancementConfig;

package/dist/proxy/routing/enhancement-config.js

@@ -3,6 +3,7 @@ const DEFAULT_CONFIG = {
     claude_code_enabled: false,
     tool_call_loop_enabled: false,
     stream_loop_enabled: false,
+    tool_round_limit_enabled: true,
 };
 /** 集中加载 proxy_enhancement 配置，避免多处重复 getSetting + JSON.parse */
 export function loadEnhancementConfig(db) {
@@ -15,6 +16,7 @@ export function loadEnhancementConfig(db) {
             claude_code_enabled: parsed.claude_code_enabled ?? false,
             tool_call_loop_enabled: parsed.tool_call_loop_enabled ?? false,
             stream_loop_enabled: parsed.stream_loop_enabled ?? false,
+            tool_round_limit_enabled: parsed.tool_round_limit_enabled ?? true,
         };
     }
     catch {

package/dist/proxy/transform/id-utils.d.ts

@@ -0,0 +1,3 @@
+export declare function generateMsgId(): string;
+export declare function generateChatcmplId(): string;
+export declare const MS_PER_SECOND = 1000;

package/dist/proxy/transform/id-utils.js

@@ -0,0 +1,9 @@
+import { randomUUID } from "crypto";
+const UUID_ID_LENGTH = 24;
+export function generateMsgId() {
+    return `msg_${randomUUID().slice(0, UUID_ID_LENGTH)}`;
+}
+export function generateChatcmplId() {
+    return `chatcmpl-${randomUUID().slice(0, UUID_ID_LENGTH)}`;
+}
+export const MS_PER_SECOND = 1000;

package/dist/proxy/transform/message-mapper.d.ts

@@ -0,0 +1,15 @@
+import type { AnthropicContentBlock } from "./types.js";
+export declare function extractSystemMessages(messages: unknown[]): {
+    systemParts: string[];
+    nonSystemMsgs: unknown[];
+};
+interface AntMessage {
+    role: string;
+    content: AnthropicContentBlock[];
+}
+export declare function convertMessagesOA2Ant(messages: unknown[]): {
+    system?: string;
+    messages: AntMessage[];
+};
+export declare function convertMessagesAnt2OA(system: unknown, messages: unknown[]): unknown[];
+export {};

package/dist/proxy/transform/message-mapper.js

@@ -0,0 +1,173 @@
+import { sanitizeToolUseId, ensureNonEmptyContent, parseToolArguments } from "./sanitize.js";
+// ---------- extractSystemMessages ----------
+export function extractSystemMessages(messages) {
+    const systemParts = [];
+    const nonSystemMsgs = [];
+    for (const msg of messages) {
+        const m = msg;
+        if (m.role === "system" || m.role === "developer") {
+            systemParts.push(String(m.content ?? ""));
+        }
+        else {
+            nonSystemMsgs.push(msg);
+        }
+    }
+    return { systemParts, nonSystemMsgs };
+}
+// ---------- Content 归一化 ----------
+function normalizeToTextBlocks(content) {
+    if (content == null || content === "")
+        return [];
+    if (typeof content === "string") {
+        return [{ type: "text", text: content }];
+    }
+    if (Array.isArray(content)) {
+        return content.flatMap((p) => {
+            if (p.type === "text" && p.text) {
+                return [{ type: "text", text: String(p.text) }];
+            }
+            // Convert OpenAI image_url to Anthropic image source
+            if (p.type === "image_url") {
+                const imageUrl = p.image_url?.url;
+                if (imageUrl) {
+                    if (imageUrl.startsWith("data:")) {
+                        // base64 data URL → base64 source
+                        const match = imageUrl.match(/^data:(image\/[^;]+);base64,(.+)$/);
+                        if (match) {
+                            return [{ type: "image", source: { type: "base64", media_type: match[1], data: match[2] } }];
+                        }
+                    }
+                    return [{ type: "image", source: { type: "url", url: imageUrl } }];
+                }
+            }
+            return [];
+        });
+    }
+    return [];
+}
+export function convertMessagesOA2Ant(messages) {
+    ensureNonEmptyContent(messages);
+    const { systemParts, nonSystemMsgs } = extractSystemMessages(messages);
+    const system = systemParts.length > 0 ? systemParts.join("\n") : undefined;
+    const raw = [];
+    for (const msg of nonSystemMsgs) {
+        const m = msg;
+        if (m.role === "user") {
+            raw.push({ role: "user", content: normalizeToTextBlocks(m.content) });
+        }
+        else if (m.role === "assistant") {
+            const blocks = [];
+            // reasoning_content → thinking block (before text)
+            if (m.reasoning_content) {
+                blocks.push({ type: "thinking", thinking: String(m.reasoning_content) });
+            }
+            // text content (skip null/undefined/empty string)
+            if (m.content != null && m.content !== "") {
+                blocks.push(...normalizeToTextBlocks(m.content));
+            }
+            // tool_calls → tool_use blocks
+            const toolCalls = m.tool_calls;
+            if (toolCalls) {
+                for (const tc of toolCalls) {
+                    const fn = tc.function;
+                    const input = parseToolArguments(fn.arguments);
+                    blocks.push({ type: "tool_use", id: sanitizeToolUseId(String(tc.id)), name: String(fn.name), input });
+                }
+            }
+            if (blocks.length === 0)
+                blocks.push({ type: "text", text: "" });
+            raw.push({ role: "assistant", content: blocks });
+        }
+        else if (m.role === "tool") {
+            // role:"tool" → role:"user" + tool_result
+            const toolResult = {
+                type: "tool_result",
+                tool_use_id: sanitizeToolUseId(String(m.tool_call_id ?? "")),
+                content: String(m.content ?? ""),
+            };
+            // 尝试合并到前一条 user 消息（或已有的 tool result 序列）
+            const last = raw[raw.length - 1];
+            if (last && last.role === "user" && last.content.every(b => b.type === "tool_result" || b.type === "text")) {
+                last.content.push(toolResult);
+            }
+            else {
+                raw.push({ role: "user", content: [toolResult] });
+            }
+        }
+    }
+    // 强制交替：合并同 role
+    const merged = [];
+    for (const msg of raw) {
+        const prev = merged[merged.length - 1];
+        if (prev && prev.role === msg.role) {
+            prev.content = [...prev.content, ...msg.content];
+        }
+        else {
+            merged.push({ ...msg, content: [...msg.content] });
+        }
+    }
+    // 确保首条是 user
+    if (merged.length > 0 && merged[0].role !== "user") {
+        merged.unshift({ role: "user", content: [{ type: "text", text: "" }] });
+    }
+    return { system, messages: merged };
+}
+// ---------- Anthropic → OpenAI ----------
+export function convertMessagesAnt2OA(system, messages) {
+    const result = [];
+    // system → role:"system"
+    if (system != null) {
+        const text = typeof system === "string"
+            ? system
+            : Array.isArray(system)
+                ? system.map(b => b.text ?? "").join("\n")
+                : String(system);
+        if (text)
+            result.push({ role: "system", content: text });
+    }
+    for (const msg of messages) {
+        const m = msg;
+        const content = m.content;
+        if (m.role === "user") {
+            if (!content || !Array.isArray(content))
+                continue;
+            const textParts = content.filter(b => b.type === "text");
+            const toolResults = content.filter(b => b.type === "tool_result");
+            if (textParts.length > 0) {
+                result.push({ role: "user", content: textParts.map(b => b.text ?? "").join("") });
+            }
+            for (const tr of toolResults) {
+                result.push({ role: "tool", tool_call_id: tr.tool_use_id, content: tr.content ?? "" });
+            }
+        }
+        else if (m.role === "assistant") {
+            if (!content || !Array.isArray(content))
+                continue;
+            const textBlocks = content.filter(b => b.type === "text");
+            const toolBlocks = content.filter(b => b.type === "tool_use");
+            const oaiMsg = { role: "assistant" };
+            // thinking → reasoning_content（保留 DeepSeek 原生思考信息，
+            // 避免 A→O 转换后被 patchNonDeepSeekToolMessages 误判为非 DeepSeek 消息）
+            const thinkingBlocks = content.filter(b => b.type === "thinking");
+            if (thinkingBlocks.length > 0) {
+                oaiMsg.reasoning_content = thinkingBlocks.map(b => b.thinking ?? "").join("");
+            }
+            // text → content
+            if (textBlocks.length > 0) {
+                oaiMsg.content = textBlocks.map(b => b.text ?? "").join("");
+            }
+            // tool_use → tool_calls
+            if (toolBlocks.length > 0) {
+                oaiMsg.tool_calls = toolBlocks.map(b => ({
+                    id: b.id,
+                    type: "function",
+                    function: { name: b.name, arguments: JSON.stringify(b.input ?? {}) },
+                }));
+            }
+            if (oaiMsg.content || oaiMsg.tool_calls) {
+                result.push(oaiMsg);
+            }
+        }
+    }
+    return result;
+}

package/dist/proxy/transform/plugin-registry.d.ts

@@ -0,0 +1,23 @@
+import type Database from "better-sqlite3";
+import type { TransformPlugin, RequestTransformContext, ResponseTransformContext } from "./plugin-types.js";
+export declare class PluginRegistry {
+    private plugins;
+    private rulesCache;
+    registerPlugin(plugin: TransformPlugin): void;
+    loadFromDB(db: Database.Database): void;
+    scanPluginsDir(dir: string): string[];
+    getMatchingPlugins(provider: {
+        id: string;
+        name: string;
+        api_type: string;
+    }): TransformPlugin[];
+    applyBeforeRequest(ctx: RequestTransformContext): void;
+    applyAfterRequest(ctx: RequestTransformContext): void;
+    applyBeforeResponse(ctx: ResponseTransformContext): void;
+    applyAfterResponse(ctx: ResponseTransformContext): void;
+    reload(db: Database.Database, pluginsDir: string): {
+        loadedPlugins: string[];
+        rulesCount: number;
+    };
+    private ruleToPlugin;
+}