llm-simple-router 0.6.7 → 0.7.1

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

@@ -1,9 +1,9 @@
 import { randomUUID } from "crypto";
-import { loadEnhancementConfig } from "../enhancement-config.js";
+import { loadEnhancementConfig } from "../routing/enhancement-config.js";
 import { getActiveProviderModels, resolveByProviderModel } from "../../db/index.js";
-import { resolveMapping } from "../mapping-resolver.js";
+import { resolveMapping } from "../routing/mapping-resolver.js";
 import { parseDirective, parseToolResult, TOOL_USE_ID_PREFIX, TOOL_USE_ID_PROVIDER_PREFIX } from "./directive-parser.js";
-import { modelState } from "../model-state.js";
+import { modelState } from "../routing/model-state.js";
 import { cleanRouterResponses } from "./response-cleaner.js";
 const MODEL_INFO_TAG_TYPE = "model-info";
 const SKIP_LABEL = "不选择";
@@ -56,66 +56,79 @@ function buildDisplayModels(db, allowedModelsRaw) {
     }
     return displayModels;
 }
+const EMPTY_META = { router_tags_stripped: 0, directive: null };
 /**
  * 在代理转发前应用代理增强逻辑（指令解析 + 会话记忆 + 模型替换 + 命令拦截）。
  * 仅当 proxy_enhancement.claude_code_enabled 开启时生效。
+ *
+ * 纯函数：不修改输入 body，返回变换后的新 body + 元数据。
  */
-export function applyEnhancement(db, request, clientModel, sessionId, enhancementConfig) {
-    const nullResult = { effectiveModel: clientModel, originalModel: null, interceptResponse: null };
+export function applyEnhancement(db, body, clientModel, sessionId, routerKey, enhancementConfig) {
+    const earlyReturn = {
+        body, effectiveModel: clientModel, originalModel: null, interceptResponse: null, meta: EMPTY_META,
+    };
     const enhancement = enhancementConfig ?? loadEnhancementConfig(db);
     if (!enhancement.claude_code_enabled) {
-        return nullResult;
+        return earlyReturn;
     }
     // 检测 AskUserQuestion 的 tool_result 回调（用户在 UI 上选择了模型或 provider）
-    const toolResult = parseToolResult(request.body);
+    const toolResult = parseToolResult(body);
     if (toolResult.isRouterToolResult) {
-        const routerKeyId = request.routerKey?.id ?? null;
+        const routerKeyId = routerKey?.id ?? null;
         const nonSkipAnswers = toolResult.allAnswers.filter(a => a !== SKIP_LABEL);
         // 所有回答都是"不选择" → 取消
         if (nonSkipAnswers.length === 0) {
             return {
+                body,
                 effectiveModel: clientModel,
                 originalModel: null,
                 interceptResponse: {
                     ...buildTextResponse("model-select-cancelled", "已取消选择"),
                     meta: { action: "取消模型选择" },
                 },
+                meta: EMPTY_META,
             };
         }
         // 选择了多个 → 提示错误
         if (nonSkipAnswers.length > 1) {
             return {
+                body,
                 effectiveModel: clientModel,
                 originalModel: null,
                 interceptResponse: {
                     ...buildTextResponse("model-select-error", "选择错误：只能选择一个模型或提供商，请重新输入 /select-model 选择"),
                     meta: { action: "选择错误" },
                 },
+                meta: EMPTY_META,
             };
         }
         const answer = nonSkipAnswers[0];
         // 两步式：用户选择了 provider → 返回该 provider 的模型列表
         if (toolResult.isProviderSelection) {
-            const allModels = buildDisplayModels(db, request.routerKey?.allowed_models ?? null);
+            const allModels = buildDisplayModels(db, routerKey?.allowed_models ?? null);
             const providerModels = getModelsForProvider(allModels, answer);
             if (providerModels.length === 0) {
                 return {
+                    body,
                     effectiveModel: clientModel,
                     originalModel: null,
                     interceptResponse: {
                         ...buildTextResponse("error", `未找到 provider: ${answer}`),
                         meta: { action: "模型选择失败", detail: answer },
                     },
+                    meta: EMPTY_META,
                 };
             }
             const questions = buildModelQuestions(providerModels);
             return {
+                body,
                 effectiveModel: clientModel,
                 originalModel: null,
                 interceptResponse: {
                     ...buildAskUserQuestionPayload(questions, false, providerModels),
                     meta: { action: `模型列表(provider=${answer})` },
                 },
+                meta: EMPTY_META,
             };
         }
         // 模型选择（直接或两步式第二步）
@@ -123,30 +136,37 @@ export function applyEnhancement(db, request, clientModel, sessionId, enhancemen
         if (resolvedClientModel) {
             modelState.set(routerKeyId, answer, sessionId, clientModel, "command");
             return {
+                body,
                 effectiveModel: answer,
                 originalModel: null,
                 interceptResponse: {
                     ...buildTextResponse("model-selected", `已选择模型: ${answer}`),
                     meta: { action: "模型选择", detail: answer },
                 },
+                meta: EMPTY_META,
             };
         }
         return {
+            body,
             effectiveModel: clientModel,
             originalModel: null,
             interceptResponse: {
                 ...buildTextResponse("error", `未找到模型: ${answer}`),
                 meta: { action: "模型选择失败", detail: answer },
             },
+            meta: EMPTY_META,
         };
     }
-    // 清理历史消息中的 <router-response> 标签
-    const cleaned = cleanRouterResponses(request.body);
-    request.body.messages = cleaned.messages;
-    const directive = parseDirective(request.body);
+    // 清理历史消息中的 <router-response> 标签（纯函数，返回新对象）
+    const originalMessages = body.messages?.length ?? 0;
+    const cleaned = cleanRouterResponses(body);
+    const cleanedMessages = cleaned.messages?.length ?? 0;
+    const tagsStripped = originalMessages - cleanedMessages;
+    const currentBody = { ...body, messages: cleaned.messages };
+    const directive = parseDirective(currentBody);
     // 命令拦截：select-model → 返回可用模型列表
     if (directive.isCommandMessage && directive.command?.startsWith("select-model")) {
-        const routerKeyId = request.routerKey?.id ?? null;
+        const routerKeyId = routerKey?.id ?? null;
         const parts = directive.command.trim().split(/\s+/);
         const arg = parts.length > 1 ? parts.slice(1).join(" ") : null;
         // 带参数：设置模型并返回确认
@@ -154,35 +174,41 @@ export function applyEnhancement(db, request, clientModel, sessionId, enhancemen
             const resolvedClientModel = resolveProviderModel(db, arg);
             if (!resolvedClientModel) {
                 return {
+                    body: currentBody,
                     effectiveModel: clientModel,
                     originalModel: null,
                     interceptResponse: {
                         ...buildTextResponse("error", `未找到模型: ${arg}`),
                         meta: { action: "模型选择失败", detail: arg },
                     },
+                    meta: { router_tags_stripped: tagsStripped, directive: { type: "router_command", value: `select-model ${arg}` } },
                 };
             }
             modelState.set(routerKeyId, arg, sessionId, clientModel, "command");
             return {
+                body: currentBody,
                 effectiveModel: arg,
                 originalModel: null,
                 interceptResponse: {
-                    ...buildSelectModelResponse(db, request.routerKey?.allowed_models ?? null, arg),
+                    ...buildSelectModelResponse(db, routerKey?.allowed_models ?? null, arg),
                     meta: { action: "模型选择", detail: arg },
                 },
+                meta: { router_tags_stripped: tagsStripped, directive: { type: "router_command", value: `select-model ${arg}` } },
             };
         }
         // 无参数：返回模型列表
-        if (hasAskUserQuestion(request.body)) {
-            const displayModels = buildDisplayModels(db, request.routerKey?.allowed_models ?? null);
+        if (hasAskUserQuestion(currentBody)) {
+            const displayModels = buildDisplayModels(db, routerKey?.allowed_models ?? null);
             if (displayModels.length === 0) {
                 return {
+                    body: currentBody,
                     effectiveModel: clientModel,
                     originalModel: null,
                     interceptResponse: {
                         ...buildTextResponse("model-list", "（无可用模型）"),
                         meta: { action: "模型列表" },
                     },
+                    meta: { router_tags_stripped: tagsStripped, directive: { type: "router_command", value: "select-model" } },
                 };
             }
             // >= TWO_STEP_THRESHOLD 且多个 provider → 两步式：先选 provider
@@ -191,12 +217,14 @@ export function applyEnhancement(db, request, clientModel, sessionId, enhancemen
                 if (providers.length >= 2) {
                     const providerQs = buildProviderQuestions(providers);
                     return {
+                        body: currentBody,
                         effectiveModel: clientModel,
                         originalModel: null,
                         interceptResponse: {
                             ...buildAskUserQuestionPayload(providerQs, true, displayModels),
                             meta: { action: "Provider列表(AskUserQuestion)" },
                         },
+                        meta: { router_tags_stripped: tagsStripped, directive: { type: "router_command", value: "select-model" } },
                     };
                 }
                 // 单 provider 且模型过多 → AskUserQuestion 显示前 6 个 + 文本列出剩余
@@ -206,65 +234,89 @@ export function applyEnhancement(db, request, clientModel, sessionId, enhancemen
                 if (displayModels.length > capped.length) {
                     const extra = displayModels.slice(capped.length).map((m, i) => `${capped.length + i + 1}. ${m}`).join("\n");
                     const textBlock = { type: "text", text: `更多模型:\n${extra}\n\n可输入 /select-model provider/model 选择` };
-                    const body = payload.body;
-                    body.content = [textBlock, ...body.content];
+                    const payloadBody = payload.body;
+                    payloadBody.content = [textBlock, ...payloadBody.content];
                 }
                 return {
+                    body: currentBody,
                     effectiveModel: clientModel,
                     originalModel: null,
                     interceptResponse: {
                         ...payload,
                         meta: { action: "模型列表(AskUserQuestion)" },
                     },
+                    meta: { router_tags_stripped: tagsStripped, directive: { type: "router_command", value: "select-model" } },
                 };
             }
             // < TWO_STEP_THRESHOLD → AskUserQuestion 2 组
             const questions = buildModelQuestions(displayModels);
             return {
+                body: currentBody,
                 effectiveModel: clientModel,
                 originalModel: null,
                 interceptResponse: {
                     ...buildAskUserQuestionPayload(questions, false),
                     meta: { action: "模型列表(AskUserQuestion)" },
                 },
+                meta: { router_tags_stripped: tagsStripped, directive: { type: "router_command", value: "select-model" } },
             };
         }
         return {
+            body: currentBody,
             effectiveModel: clientModel,
             originalModel: null,
             interceptResponse: {
-                ...buildSelectModelResponse(db, request.routerKey?.allowed_models ?? null),
+                ...buildSelectModelResponse(db, routerKey?.allowed_models ?? null),
                 meta: { action: "模型列表" },
             },
+            meta: { router_tags_stripped: tagsStripped, directive: { type: "router_command", value: "select-model" } },
         };
     }
     if (directive.modelName) {
         // 内联模型指令 → resolveMapping 验证（client_model 格式）
         const resolvedDirective = resolveMapping(db, directive.modelName, { now: new Date() });
         if (resolvedDirective) {
-            modelState.set(request.routerKey?.id ?? null, directive.modelName, sessionId, clientModel, "directive");
-            request.body.messages = directive.cleanedBody.messages;
-            return { effectiveModel: directive.modelName, originalModel: clientModel, interceptResponse: null };
+            modelState.set(routerKey?.id ?? null, directive.modelName, sessionId, clientModel, "directive");
+            const directiveBody = { ...currentBody, messages: directive.cleanedBody.messages };
+            return {
+                body: directiveBody,
+                effectiveModel: directive.modelName,
+                originalModel: clientModel,
+                interceptResponse: null,
+                meta: { router_tags_stripped: tagsStripped, directive: { type: directive.isCommandMessage ? "router_command" : "router_model", value: directive.modelName } },
+            };
         }
         // 映射失败时保留原始请求（降级策略）
-        return nullResult;
+        return { body: currentBody, effectiveModel: clientModel, originalModel: null, interceptResponse: null, meta: { router_tags_stripped: tagsStripped, directive: null } };
     }
     // 无指令 → 查询会话记忆
-    const remembered = modelState.get(request.routerKey?.id ?? null, sessionId);
+    const remembered = modelState.get(routerKey?.id ?? null, sessionId);
     if (remembered) {
         // 优先尝试 provider_name/backend_model 格式（select-model 命令存储）
         // 直接保留该格式，resolveMapping 会解析出 provider + model
         const providerResolved = resolveProviderModel(db, remembered);
         if (providerResolved) {
-            return { effectiveModel: remembered, originalModel: clientModel, interceptResponse: null };
+            return {
+                body: currentBody,
+                effectiveModel: remembered,
+                originalModel: clientModel,
+                interceptResponse: null,
+                meta: { router_tags_stripped: tagsStripped, directive: { type: "select_model", value: remembered } },
+            };
         }
         // 回退到 client_model 格式（内联指令存储）
         const resolvedRemembered = resolveMapping(db, remembered, { now: new Date() });
         if (resolvedRemembered) {
-            return { effectiveModel: remembered, originalModel: clientModel, interceptResponse: null };
+            return {
+                body: currentBody,
+                effectiveModel: remembered,
+                originalModel: clientModel,
+                interceptResponse: null,
+                meta: { router_tags_stripped: tagsStripped, directive: { type: "router_model", value: remembered } },
+            };
         }
     }
-    return nullResult;
+    return { body: currentBody, effectiveModel: clientModel, originalModel: null, interceptResponse: null, meta: { router_tags_stripped: tagsStripped, directive: null } };
 }
 /** 构造 Anthropic 格式的 router 文本响应 */
 function buildTextResponse(type, inner) {

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

@@ -1,3 +1,4 @@
 export { applyEnhancement, buildModelInfoTag } from "./enhancement-handler.js";
+export type { EnhancementResult, EnhancementMeta, RouterKeyInfo } from "./enhancement-handler.js";
 export { parseDirective, parseToolResult, TOOL_USE_ID_PREFIX, TOOL_USE_ID_PROVIDER_PREFIX } from "./directive-parser.js";
 export { cleanRouterResponses } from "./response-cleaner.js";

package/dist/proxy/handler/anthropic.d.ts

@@ -0,0 +1,7 @@
+import Database from "better-sqlite3";
+import type { FastifyPluginCallback } from "fastify";
+export interface AnthropicProxyOptions {
+    db: Database.Database;
+    container: import("../../core/container.js").ServiceContainer;
+}
+export declare const anthropicProxy: FastifyPluginCallback<AnthropicProxyOptions>;

package/dist/proxy/{anthropic.js → handler/anthropic.js}

@@ -1,10 +1,11 @@
 import { randomUUID } from "crypto";
 import fp from "fastify-plugin";
-import { insertRequestLog } from "../db/index.js";
-import { createErrorFormatter } from "./proxy-core.js";
+import { insertRequestLog } from "../../db/index.js";
+import { createErrorFormatter } from "../proxy-core.js";
 import { handleProxyRequest } from "./proxy-handler.js";
-import { createOrchestrator } from "./orchestrator.js";
-import { HTTP_BAD_GATEWAY } from "../constants.js";
+import { createOrchestrator } from "../orchestration/orchestrator.js";
+import { HTTP_BAD_GATEWAY } from "../../core/constants.js";
+import { SERVICE_KEYS } from "../../core/container.js";
 const MESSAGES_PATH = "/v1/messages";
 const ANTHROPIC_ERROR_TYPE = {
     modelNotFound: "not_found_error",
@@ -18,8 +19,8 @@ const ANTHROPIC_ERROR_TYPE = {
 };
 const anthropicErrors = createErrorFormatter((kind, message) => ({ type: "error", error: { type: ANTHROPIC_ERROR_TYPE[kind], message } }));
 const anthropicProxyRaw = (app, opts, done) => {
-    const { db, streamTimeoutMs, retryBaseDelayMs, matcher, semaphoreManager, tracker, usageWindowTracker, sessionTracker, adaptiveController } = opts;
-    const orchestrator = createOrchestrator(semaphoreManager, tracker, adaptiveController);
+    const { db, container } = opts;
+    const orchestrator = createOrchestrator(container.resolve(SERVICE_KEYS.semaphoreManager), container.resolve(SERVICE_KEYS.tracker), container.resolve(SERVICE_KEYS.adaptiveController));
     app.post(MESSAGES_PATH, async (request, reply) => {
         if (!orchestrator) {
             const body = request.body;
@@ -34,7 +35,7 @@ const anthropicProxyRaw = (app, opts, done) => {
             const e = anthropicErrors.providerUnavailable();
             return reply.code(e.statusCode).send(e.body);
         }
-        const deps = { db, streamTimeoutMs, retryBaseDelayMs, matcher, tracker, orchestrator, usageWindowTracker, sessionTracker };
+        const deps = { db, orchestrator, container };
         return handleProxyRequest(request, reply, "anthropic", MESSAGES_PATH, anthropicErrors, deps);
     });
     done();

package/dist/proxy/handler/openai.d.ts

@@ -0,0 +1,7 @@
+import type { FastifyPluginCallback } from "fastify";
+import Database from "better-sqlite3";
+export interface OpenaiProxyOptions {
+    db: Database.Database;
+    container: import("../../core/container.js").ServiceContainer;
+}
+export declare const openaiProxy: FastifyPluginCallback<OpenaiProxyOptions>;

package/dist/proxy/{openai.js → handler/openai.js}

@@ -1,12 +1,13 @@
 import { randomUUID } from "crypto";
 import fp from "fastify-plugin";
-import { getActiveProviders, insertRequestLog } from "../db/index.js";
-import { getSetting } from "../db/settings.js";
-import { decrypt } from "../utils/crypto.js";
-import { proxyGetRequest, createErrorFormatter } from "./proxy-core.js";
+import { getActiveProviders, insertRequestLog } from "../../db/index.js";
+import { getSetting } from "../../db/settings.js";
+import { decrypt } from "../../utils/crypto.js";
+import { proxyGetRequest, createErrorFormatter } from "../proxy-core.js";
 import { handleProxyRequest } from "./proxy-handler.js";
-import { createOrchestrator } from "./orchestrator.js";
-import { HTTP_NOT_FOUND, HTTP_BAD_GATEWAY } from "../constants.js";
+import { createOrchestrator } from "../orchestration/orchestrator.js";
+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";
 const OPENAI_ERROR_META = {
@@ -24,8 +25,8 @@ function sendError(reply, e) {
     return reply.code(e.statusCode).send(e.body);
 }
 const openaiProxyRaw = (app, opts, done) => {
-    const { db, streamTimeoutMs, retryBaseDelayMs, matcher, semaphoreManager, tracker, usageWindowTracker, sessionTracker, adaptiveController } = opts;
-    const orchestrator = createOrchestrator(semaphoreManager, tracker, adaptiveController);
+    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) => {
         if (!orchestrator) {
             const body = request.body;
@@ -39,7 +40,7 @@ const openaiProxyRaw = (app, opts, done) => {
             });
             return sendError(reply, openaiErrors.providerUnavailable());
         }
-        const deps = { db, streamTimeoutMs, retryBaseDelayMs, matcher, tracker, orchestrator, usageWindowTracker, sessionTracker };
+        const deps = { db, orchestrator, container };
         return handleProxyRequest(request, reply, "openai", CHAT_COMPLETIONS_PATH, openaiErrors, deps, {
             beforeSendProxy: (body, isStream) => {
                 if (isStream && !body.stream_options) {

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

@@ -0,0 +1,9 @@
+import type { ContentBlock } from "../../monitor/types.js";
+import type { ToolCallRecord } from "../loop-prevention/types.js";
+import type { TransportResult } from "../types.js";
+/** 从 TransportResult 中提取最终 HTTP status code */
+export declare function getTransportStatusCode(result: TransportResult): number | null;
+/** 将 tracker blocks 序列化为前端 tryDirectParse 可解析的 JSON */
+export declare function serializeBlocksForStorage(blocks: ContentBlock[] | undefined, apiType: "openai" | "anthropic"): string;
+/** 从请求体中提取最后一次工具调用记录 */
+export declare function extractLastToolUse(body: Record<string, unknown>): ToolCallRecord | null;

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

@@ -0,0 +1,63 @@
+import { createHash } from "crypto";
+const HASH_DIGEST_LENGTH = 16;
+/** 从 TransportResult 中提取最终 HTTP status code */
+export function getTransportStatusCode(result) {
+    if (result.kind === "success" || result.kind === "error" || result.kind === "stream_error")
+        return result.statusCode;
+    if (result.kind === "stream_success" || result.kind === "stream_abort")
+        return result.statusCode;
+    return null;
+}
+/** 将 tracker blocks 序列化为前端 tryDirectParse 可解析的 JSON */
+export function serializeBlocksForStorage(blocks, apiType) {
+    if (!blocks || blocks.length === 0)
+        return "";
+    if (apiType === "anthropic") {
+        const content = blocks.map(b => {
+            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: "text", text: b.content };
+        });
+        return JSON.stringify({ content });
+    }
+    const text = blocks.filter(b => b.type === "text").map(b => b.content).join("");
+    return JSON.stringify({ choices: [{ message: { content: text } }] });
+}
+/** 从请求体中提取最后一次工具调用记录 */
+export function extractLastToolUse(body) {
+    const messages = body.messages;
+    if (!messages)
+        return null;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.role !== "assistant")
+            continue;
+        const content = msg.content;
+        if (!Array.isArray(content))
+            continue;
+        for (let j = content.length - 1; j >= 0; j--) {
+            const block = content[j];
+            if (block.type === "tool_use") {
+                const inputText = JSON.stringify(block.input ?? {});
+                const inputHash = createHash("sha256").update(inputText).digest("hex").slice(0, HASH_DIGEST_LENGTH);
+                return {
+                    toolName: block.name ?? "unknown",
+                    toolUseId: block.id,
+                    inputHash,
+                    inputText,
+                    timestamp: Date.now(),
+                };
+            }
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,13 @@
+import type { FastifyReply, FastifyRequest } from "fastify";
+import Database from "better-sqlite3";
+import type { ProxyOrchestrator } from "../orchestration/orchestrator.js";
+import type { ProxyErrorFormatter } from "../proxy-core.js";
+export interface RouteHandlerDeps {
+    db: Database.Database;
+    orchestrator: ProxyOrchestrator;
+    container: ServiceContainer;
+}
+import type { ServiceContainer } from "../../core/container.js";
+export declare function handleProxyRequest(request: FastifyRequest, reply: FastifyReply, apiType: "openai" | "anthropic", upstreamPath: string, errors: ProxyErrorFormatter, deps: RouteHandlerDeps, options?: {
+    beforeSendProxy?: (body: Record<string, unknown>, isStream: boolean) => void;
+}): Promise<FastifyReply>;