llm-simple-router 0.5.2 → 0.5.4

package/dist/index.js

@@ -40,7 +40,12 @@ export async function buildApp(options) {
         shouldBackfill = true;
     }
     const isDev = process.env.NODE_ENV !== "production";
+    const MAX_BODY_SIZE_MB = 50;
+    const KB = 1024;
+    const MB = KB * KB;
     const app = Fastify({
+        // Claude Code 图片请求含 base64 编码，单张可达数十 MB
+        bodyLimit: MAX_BODY_SIZE_MB * MB,
         logger: {
             level: config.LOG_LEVEL,
             ...(isDev
@@ -71,6 +76,11 @@ export async function buildApp(options) {
             .join("; ");
         return new Error(message);
     });
+    // 记录请求到达时间，供全局错误处理计算延迟
+    app.addHook("onRequest", (request, _reply, done) => {
+        request.receivedAt = Date.now();
+        done();
+    });
     // 统一错误处理：代理路由保持 {error:{message}}，Admin API 使用信封格式
     app.setErrorHandler((error, request, reply) => {
         const fastifyError = error;
@@ -81,17 +91,19 @@ export async function buildApp(options) {
             if (proxyApiType) {
                 request.log.error({ statusCode: status, err: error }, `Proxy request error: ${fastifyError.message}`);
                 const body = request.body;
+                const receivedAt = request.receivedAt;
+                const latencyMs = receivedAt ? Date.now() - receivedAt : 0;
                 insertRequestLog(db, {
                     id: randomUUID(),
                     api_type: proxyApiType,
                     model: body?.model || null,
                     provider_id: null,
                     status_code: status,
-                    latency_ms: 0,
-                    is_stream: 0,
+                    latency_ms: latencyMs,
+                    is_stream: body?.stream === true ? 1 : 0,
                     error_message: fastifyError.message,
                     created_at: new Date().toISOString(),
-                    client_request: JSON.stringify({ headers: request.headers }),
+                    client_request: JSON.stringify({ headers: request.headers, ...(body ? { body } : {}) }),
                     router_key_id: request.routerKey?.id ?? null,
                 });
             }

package/dist/middleware/auth.js

@@ -31,7 +31,7 @@ function logRejectedAuth(db, apiType, statusCode, errorMessage, request) {
         is_stream: 0,
         error_message: errorMessage,
         created_at: new Date().toISOString(),
-        client_request: JSON.stringify({ headers: request.headers }),
+        client_request: JSON.stringify({ method: request.method, ip: request.ip, headers: request.headers }),
     });
 }
 const authMiddlewareRaw = (app, options, done) => {

package/dist/monitor/request-tracker.d.ts

@@ -41,6 +41,8 @@ export declare class RequestTracker {
     getConcurrency(): ProviderConcurrencySnapshot[];
     getRuntime(): RuntimeMetrics;
     addClient(res: ServerResponse): void;
+    /** 向单个客户端发送当前活跃请求快照 */
+    private sendInitialSnapshot;
     removeClient(res: ServerResponse): void;
     startPushInterval(): void;
     stopPushInterval(): void;

package/dist/monitor/request-tracker.js

@@ -131,10 +131,28 @@ export class RequestTracker {
     // --- SSE client management ---
     addClient(res) {
         this.clients.add(res);
+        // 连接时立即推送当前活跃请求，让新客户端看到页面加载前已存在的请求
+        this.sendInitialSnapshot(res);
         res.on("close", () => {
             this.clients.delete(res);
         });
     }
+    /** 向单个客户端发送当前活跃请求快照 */
+    sendInitialSnapshot(res) {
+        const active = this.getActive().map((req) => {
+            const copy = { ...req };
+            delete copy.clientRequest;
+            return copy;
+        });
+        const msg = `event: request_update\ndata: ${JSON.stringify(active)}\n\n`;
+        try {
+            if (!res.writableEnded)
+                res.write(msg);
+        }
+        catch {
+            this.clients.delete(res);
+        }
+    }
     removeClient(res) {
         this.clients.delete(res);
     }

package/dist/proxy/anthropic.js

@@ -1,7 +1,10 @@
+import { randomUUID } from "crypto";
 import fp from "fastify-plugin";
+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";
 const MESSAGES_PATH = "/v1/messages";
 const ANTHROPIC_ERROR_TYPE = {
     modelNotFound: "not_found_error",
@@ -11,6 +14,7 @@ const ANTHROPIC_ERROR_TYPE = {
     upstreamConnectionFailed: "upstream_error",
     concurrencyQueueFull: "api_error",
     concurrencyTimeout: "api_error",
+    promptTooLong: "invalid_request_error",
 };
 const anthropicErrors = createErrorFormatter((kind, message) => ({ type: "error", error: { type: ANTHROPIC_ERROR_TYPE[kind], message } }));
 const anthropicProxyRaw = (app, opts, done) => {
@@ -18,6 +22,15 @@ const anthropicProxyRaw = (app, opts, done) => {
     const orchestrator = createOrchestrator(semaphoreManager, tracker);
     app.post(MESSAGES_PATH, async (request, reply) => {
         if (!orchestrator) {
+            const body = request.body;
+            insertRequestLog(db, {
+                id: randomUUID(), api_type: "anthropic", model: body?.model || null,
+                provider_id: null, status_code: HTTP_BAD_GATEWAY, latency_ms: 0, is_stream: 0,
+                error_message: "Orchestrator not available (missing semaphore or tracker)",
+                created_at: new Date().toISOString(),
+                client_request: JSON.stringify({ headers: request.headers }),
+                router_key_id: request.routerKey?.id ?? null,
+            });
             const e = anthropicErrors.providerUnavailable();
             return reply.code(e.statusCode).send(e.body);
         }

package/dist/proxy/enhancement/directive-parser.d.ts

@@ -1,5 +1,7 @@
-/** synthetic tool_use 的 ID 前缀，用于识别我们的 AskUserQuestion 响应 */
+/** synthetic tool_use 的 ID 前缀，用于识别 model 选择的 AskUserQuestion 响应 */
 export declare const TOOL_USE_ID_PREFIX = "toolu_router_";
+/** synthetic tool_use 的 ID 前缀，用于识别 provider 选择的 AskUserQuestion 响应（两步式） */
+export declare const TOOL_USE_ID_PROVIDER_PREFIX = "toolu_router_prov_";
 export interface DirectiveParseResult {
     modelName: string | null;
     command: string | null;
@@ -10,9 +12,13 @@ export declare function parseDirective(body: Record<string, unknown>): Directive
 export interface ToolResultParseResult {
     isRouterToolResult: boolean;
     selectedModel: string | null;
+    /** true = 用户选择了 provider（两步式第一步） */
+    isProviderSelection: boolean;
+    /** 所有答案（多问题时可从中查找非"不选择"的回答） */
+    allAnswers: string[];
 }
 /**
  * 检测请求中是否包含对 router synthetic AskUserQuestion 的 tool_result 回调，
- * 如果是，从中提取用户选择的模型名。
+ * 如果是，从中提取用户选择的模型名或 provider 名。
  */
 export declare function parseToolResult(body: Record<string, unknown>): ToolResultParseResult;

package/dist/proxy/enhancement/directive-parser.js

@@ -1,12 +1,9 @@
 const MODEL_MAX_LEN = 128;
 const MODEL_RE = /^[a-zA-Z0-9][a-zA-Z0-9._:-]*$/;
-/** synthetic tool_use 的 ID 前缀，用于识别我们的 AskUserQuestion 响应 */
+/** synthetic tool_use 的 ID 前缀，用于识别 model 选择的 AskUserQuestion 响应 */
 export const TOOL_USE_ID_PREFIX = "toolu_router_";
-/**
- * 从 Claude Code AskUserQuestion 的 tool_result content 文本中提取用户选择。
- * 格式：User has answered your questions: "question"="answer". ...
- */
-const RE_TOOL_RESULT_ANSWER = /="([^"]+)"\./;
+/** synthetic tool_use 的 ID 前缀，用于识别 provider 选择的 AskUserQuestion 响应（两步式） */
+export const TOOL_USE_ID_PROVIDER_PREFIX = "toolu_router_prov_";
 function isValidModelName(name) {
     return name.length <= MODEL_MAX_LEN && MODEL_RE.test(name) && !/^\d+$/.test(name);
 }
@@ -77,12 +74,13 @@ export function parseDirective(body) {
 }
 /**
  * 检测请求中是否包含对 router synthetic AskUserQuestion 的 tool_result 回调，
- * 如果是，从中提取用户选择的模型名。
+ * 如果是，从中提取用户选择的模型名或 provider 名。
  */
 export function parseToolResult(body) {
+    const empty = { isRouterToolResult: false, selectedModel: null, isProviderSelection: false, allAnswers: [] };
     const messages = body.messages;
     if (!messages?.length)
-        return { isRouterToolResult: false, selectedModel: null };
+        return empty;
     let lastUserIdx = -1;
     for (let i = messages.length - 1; i >= 0; i--) {
         if (messages[i].role === "user") {
@@ -91,7 +89,7 @@ export function parseToolResult(body) {
         }
     }
     if (lastUserIdx < 0)
-        return { isRouterToolResult: false, selectedModel: null };
+        return empty;
     const lastUser = messages[lastUserIdx];
     const blocks = Array.isArray(lastUser.content) ? lastUser.content : [lastUser.content];
     for (const block of blocks) {
@@ -100,15 +98,44 @@ export function parseToolResult(body) {
         const b = block;
         if (b.type !== "tool_result" || typeof b.tool_use_id !== "string")
             continue;
-        if (!b.tool_use_id.startsWith(TOOL_USE_ID_PREFIX))
+        const isProviderSelection = b.tool_use_id.startsWith(TOOL_USE_ID_PROVIDER_PREFIX);
+        // provider 前缀也以 toolu_router_ 开头，因此先检查 provider 前缀
+        const isRouterToolResult = isProviderSelection || b.tool_use_id.startsWith(TOOL_USE_ID_PREFIX);
+        if (!isRouterToolResult)
             continue;
-        const text = typeof b.content === "string" ? b.content : "";
-        const match = RE_TOOL_RESULT_ANSWER.exec(text);
-        if (match?.[1]) {
-            return { isRouterToolResult: true, selectedModel: match[1] };
+        // 支持 string 和 content blocks 数组两种格式
+        let text = "";
+        if (typeof b.content === "string") {
+            text = b.content;
+        }
+        else if (Array.isArray(b.content)) {
+            text = b.content
+                .filter(c => c?.type === "text" && typeof c.text === "string")
+                .map(c => c.text)
+                .join("\n");
+        }
+        const answers = [];
+        let match;
+        // 宽松匹配：提取所有 ="answer" 对（Claude Code 格式: "question"="answer". ）
+        const re = /="([^"]+)"/g;
+        while ((match = re.exec(text)) !== null) {
+            answers.push(match[1]);
+        }
+        // Fallback: 尝试从 JSON {"question": "answer", ...} 提取
+        if (answers.length === 0 && text.startsWith("{")) {
+            try {
+                const parsed = JSON.parse(text);
+                if (typeof parsed === "object" && parsed !== null) {
+                    for (const v of Object.values(parsed)) {
+                        if (typeof v === "string")
+                            answers.push(v);
+                    }
+                }
+            }
+            catch { /* not JSON */ }
         }
-        // tool_result 匹配前缀但无法提取模型名
-        return { isRouterToolResult: true, selectedModel: null };
+        const selectedModel = answers.length > 0 ? answers[0] : null;
+        return { isRouterToolResult: true, selectedModel, isProviderSelection, allAnswers: answers };
     }
-    return { isRouterToolResult: false, selectedModel: null };
+    return empty;
 }

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

@@ -1,11 +1,14 @@
 import { randomUUID } from "crypto";
-import { getSetting } from "../../db/settings.js";
+import { loadEnhancementConfig } from "../enhancement-config.js";
 import { getActiveProviderModels, resolveByProviderModel } from "../../db/index.js";
 import { resolveMapping } from "../mapping-resolver.js";
-import { parseDirective, parseToolResult, TOOL_USE_ID_PREFIX } from "./directive-parser.js";
+import { parseDirective, parseToolResult, TOOL_USE_ID_PREFIX, TOOL_USE_ID_PROVIDER_PREFIX } from "./directive-parser.js";
 import { modelState } from "../model-state.js";
 import { cleanRouterResponses } from "./response-cleaner.js";
 const MODEL_INFO_TAG_TYPE = "model-info";
+const SKIP_LABEL = "不选择";
+const TWO_STEP_THRESHOLD = 9;
+const MODELS_PER_GROUP = 3;
 /**
  * 解析 "provider_name/backend_model" 格式，返回对应的 client_model。
  * provider_name 只允许 [a-zA-Z0-9_-]，/ 作为分隔符。
@@ -37,7 +40,7 @@ function buildDisplayModels(db, allowedModelsRaw) {
             if (parsed.length > 0)
                 allowedSet = new Set(parsed);
         }
-        catch { /* 解析失败时不做过滤 */ }
+        catch { /* eslint-disable-line taste/no-silent-catch -- JSON.parse 解析失败时不做过滤，属于预期降级 */ }
     }
     const filtered = allowedSet
         ? providerModels.filter(m => allowedSet.has(m.backend_model))
@@ -59,45 +62,83 @@ function buildDisplayModels(db, allowedModelsRaw) {
  */
 export function applyEnhancement(db, request, clientModel, sessionId) {
     const nullResult = { effectiveModel: clientModel, originalModel: null, interceptResponse: null };
-    const enhancementRaw = getSetting(db, "proxy_enhancement");
-    let enhancement = null;
-    try {
-        enhancement = enhancementRaw ? JSON.parse(enhancementRaw) : null;
-    }
-    catch {
-        request.log.warn("Invalid proxy_enhancement JSON, feature disabled");
-    }
-    if (enhancement?.claude_code_enabled !== true) {
+    const enhancement = loadEnhancementConfig(db);
+    if (!enhancement.claude_code_enabled) {
         return nullResult;
     }
-    // 检测 AskUserQuestion 的 tool_result 回调（用户在 UI 上选择了模型）
+    // 检测 AskUserQuestion 的 tool_result 回调（用户在 UI 上选择了模型或 provider）
     const toolResult = parseToolResult(request.body);
     if (toolResult.isRouterToolResult) {
         const routerKeyId = request.routerKey?.id ?? null;
-        if (toolResult.selectedModel) {
-            const resolvedClientModel = resolveProviderModel(db, toolResult.selectedModel);
-            if (resolvedClientModel) {
-                modelState.set(routerKeyId, toolResult.selectedModel, sessionId, clientModel, "command");
+        const nonSkipAnswers = toolResult.allAnswers.filter(a => a !== SKIP_LABEL);
+        // 所有回答都是"不选择" → 取消
+        if (nonSkipAnswers.length === 0) {
+            return {
+                effectiveModel: clientModel,
+                originalModel: null,
+                interceptResponse: {
+                    ...buildTextResponse("model-select-cancelled", "已取消选择"),
+                    meta: { action: "取消模型选择" },
+                },
+            };
+        }
+        // 选择了多个 → 提示错误
+        if (nonSkipAnswers.length > 1) {
+            return {
+                effectiveModel: clientModel,
+                originalModel: null,
+                interceptResponse: {
+                    ...buildTextResponse("model-select-error", "选择错误：只能选择一个模型或提供商，请重新输入 /select-model 选择"),
+                    meta: { action: "选择错误" },
+                },
+            };
+        }
+        const answer = nonSkipAnswers[0];
+        // 两步式：用户选择了 provider → 返回该 provider 的模型列表
+        if (toolResult.isProviderSelection) {
+            const allModels = buildDisplayModels(db, request.routerKey?.allowed_models ?? null);
+            const providerModels = getModelsForProvider(allModels, answer);
+            if (providerModels.length === 0) {
                 return {
-                    effectiveModel: toolResult.selectedModel,
+                    effectiveModel: clientModel,
                     originalModel: null,
                     interceptResponse: {
-                        ...buildTextResponse("model-selected", `已选择模型: ${toolResult.selectedModel}`),
-                        meta: { action: "模型选择", detail: toolResult.selectedModel },
+                        ...buildTextResponse("error", `未找到 provider: ${answer}`),
+                        meta: { action: "模型选择失败", detail: answer },
                     },
                 };
             }
+            const questions = buildModelQuestions(providerModels);
             return {
                 effectiveModel: clientModel,
                 originalModel: null,
                 interceptResponse: {
-                    ...buildTextResponse("error", `未找到模型: ${toolResult.selectedModel}`),
-                    meta: { action: "模型选择失败", detail: toolResult.selectedModel },
+                    ...buildAskUserQuestionPayload(questions, false, providerModels),
+                    meta: { action: `模型列表(provider=${answer})` },
                 },
             };
         }
-        // tool_result 匹配前缀但无法提取模型名，降级处理
-        return nullResult;
+        // 模型选择（直接或两步式第二步）
+        const resolvedClientModel = resolveProviderModel(db, answer);
+        if (resolvedClientModel) {
+            modelState.set(routerKeyId, answer, sessionId, clientModel, "command");
+            return {
+                effectiveModel: answer,
+                originalModel: null,
+                interceptResponse: {
+                    ...buildTextResponse("model-selected", `已选择模型: ${answer}`),
+                    meta: { action: "模型选择", detail: answer },
+                },
+            };
+        }
+        return {
+            effectiveModel: clientModel,
+            originalModel: null,
+            interceptResponse: {
+                ...buildTextResponse("error", `未找到模型: ${answer}`),
+                meta: { action: "模型选择失败", detail: answer },
+            },
+        };
     }
     // 清理历史消息中的 <router-response> 标签
     const cleaned = cleanRouterResponses(request.body);
@@ -144,11 +185,46 @@ export function applyEnhancement(db, request, clientModel, sessionId) {
                     },
                 };
             }
+            // >= TWO_STEP_THRESHOLD 且多个 provider → 两步式：先选 provider
+            if (displayModels.length >= TWO_STEP_THRESHOLD) {
+                const providers = getUniqueProviders(displayModels);
+                if (providers.length >= 2) {
+                    const providerQs = buildProviderQuestions(providers);
+                    return {
+                        effectiveModel: clientModel,
+                        originalModel: null,
+                        interceptResponse: {
+                            ...buildAskUserQuestionPayload(providerQs, true, displayModels),
+                            meta: { action: "Provider列表(AskUserQuestion)" },
+                        },
+                    };
+                }
+                // 单 provider 且模型过多 → AskUserQuestion 显示前 6 个 + 文本列出剩余
+                const capped = displayModels.slice(0, MODELS_PER_GROUP * 2);
+                const questions = buildModelQuestions(capped);
+                const payload = buildAskUserQuestionPayload(questions, false);
+                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];
+                }
+                return {
+                    effectiveModel: clientModel,
+                    originalModel: null,
+                    interceptResponse: {
+                        ...payload,
+                        meta: { action: "模型列表(AskUserQuestion)" },
+                    },
+                };
+            }
+            // < TWO_STEP_THRESHOLD → AskUserQuestion 2 组
+            const questions = buildModelQuestions(displayModels);
             return {
                 effectiveModel: clientModel,
                 originalModel: null,
                 interceptResponse: {
-                    ...buildAskUserQuestionResponse(displayModels),
+                    ...buildAskUserQuestionPayload(questions, false),
                     meta: { action: "模型列表(AskUserQuestion)" },
                 },
             };
@@ -205,6 +281,27 @@ function buildTextResponse(type, inner) {
     };
     return { statusCode: 200, body };
 }
+/** 从 "provider/model" 列表中提取去重的 provider 名称 */
+function getUniqueProviders(models) {
+    const seen = new Set();
+    const result = [];
+    for (const m of models) {
+        const sep = m.indexOf("/");
+        if (sep > 0) {
+            const p = m.substring(0, sep);
+            if (!seen.has(p)) {
+                seen.add(p);
+                result.push(p);
+            }
+        }
+    }
+    return result;
+}
+/** 按 provider 筛选模型列表 */
+function getModelsForProvider(models, provider) {
+    const prefix = provider + "/";
+    return models.filter(m => m.startsWith(prefix));
+}
 /** 查询所有可用的 provider_model 并构造文本列表响应 */
 function buildSelectModelResponse(db, allowedModelsRaw, selectedModel) {
     const displayModels = buildDisplayModels(db, allowedModelsRaw);
@@ -224,17 +321,15 @@ function buildSelectModelResponse(db, allowedModelsRaw, selectedModel) {
     }
     return buildTextResponse(responseType, inner);
 }
-/** 将模型列表分块为 AskUserQuestion 的 questions（每组 2-4 个选项，最多 4 组） */
+/** 将模型列表分成最多 2 组 AskUserQuestion（每组 ≤3 个模型 + 1 个"不选择"） */
 function buildModelQuestions(models) {
-    if (models.length <= 4) {
+    if (models.length <= MODELS_PER_GROUP) {
         const options = models.map(m => {
             const sep = m.indexOf("/");
             const provider = sep > 0 ? m.substring(0, sep) : "";
             return { label: m, description: provider || "模型" };
         });
-        if (options.length === 1) {
-            options.push({ label: "保持当前", description: "不切换模型" });
-        }
+        options.push({ label: SKIP_LABEL, description: "不切换模型" });
         return [{
                 question: "请选择要使用的模型",
                 header: "模型选择",
@@ -242,40 +337,75 @@ function buildModelQuestions(models) {
                 multiSelect: false,
             }];
     }
-    // 均匀分配到最多 4 个 question，每个 2-4 个选项
-    const numChunks = Math.min(4, Math.ceil(models.length / 4));
-    const chunks = Array.from({ length: numChunks }, () => []);
-    for (let i = 0; i < models.length; i++) {
-        chunks[i % numChunks].push(models[i]);
-    }
-    return chunks.map((chunk, idx) => ({
-        question: "请选择要使用的模型",
-        header: idx === 0 ? "模型选择" : "更多模型",
-        options: chunk.map(m => {
+    const g1 = models.slice(0, MODELS_PER_GROUP);
+    const g2 = models.slice(MODELS_PER_GROUP, MODELS_PER_GROUP * 2);
+    return [g1, g2].map((group, idx) => {
+        const options = group.map(m => {
             const sep = m.indexOf("/");
             const provider = sep > 0 ? m.substring(0, sep) : "";
             return { label: m, description: provider || "模型" };
-        }),
-        multiSelect: false,
-    }));
+        });
+        options.push({ label: SKIP_LABEL, description: "不切换模型" });
+        return {
+            question: `请选择要使用的模型（第${idx + 1}组）`,
+            header: idx === 0 ? "模型选择" : "更多模型",
+            options,
+            multiSelect: false,
+        };
+    });
+}
+/** 构建 provider 选择的 AskUserQuestion questions（两步式第一步，每组 ≤3 个 provider + "不选择"） */
+function buildProviderQuestions(providers) {
+    if (providers.length <= 3) {
+        const options = providers.map(p => ({ label: p, description: `${p} 的模型` }));
+        options.push({ label: SKIP_LABEL, description: "不切换模型" });
+        return [{
+                question: "请先选择模型提供商",
+                header: "Provider",
+                options,
+                multiSelect: false,
+            }];
+    }
+    const chunks = [];
+    for (let i = 0; i < providers.length && chunks.length < 4; i += 3) {
+        chunks.push(providers.slice(i, i + 3));
+    }
+    return chunks.map((chunk, idx) => {
+        const options = chunk.map(p => ({ label: p, description: `${p} 的模型` }));
+        options.push({ label: SKIP_LABEL, description: "不切换模型" });
+        return {
+            question: chunks.length === 1
+                ? "请先选择模型提供商"
+                : `请选择模型提供商（第${idx + 1}组）`,
+            header: idx === 0 ? "Provider" : `Provider(${idx + 1})`,
+            options,
+            multiSelect: false,
+        };
+    });
 }
-/** 构造 AskUserQuestion synthetic tool_use 响应 */
-function buildAskUserQuestionResponse(displayModels) {
-    const capped = displayModels.slice(0, 16);
-    const questions = buildModelQuestions(capped);
-    const toolUseId = `${TOOL_USE_ID_PREFIX}${randomUUID()}`;
+/** 构造「文本列表 + AskUserQuestion」组合响应 */
+function buildAskUserQuestionPayload(questions, isProvider, allModels) {
+    const prefix = isProvider ? TOOL_USE_ID_PROVIDER_PREFIX : TOOL_USE_ID_PREFIX;
+    const toolUseId = `${prefix}${randomUUID()}`;
+    const content = [];
+    // 先输出完整模型列表文本
+    if (allModels && allModels.length > 0) {
+        const list = allModels.map((m, i) => `${i + 1}. ${m}`).join("\n");
+        content.push({ type: "text", text: `可用模型列表:\n${list}` });
+    }
+    content.push({
+        type: "tool_use",
+        id: toolUseId,
+        name: "AskUserQuestion",
+        input: { questions },
+    });
     return {
         statusCode: 200,
         body: {
             id: `msg-${randomUUID()}`,
             type: "message",
             role: "assistant",
-            content: [{
-                    type: "tool_use",
-                    id: toolUseId,
-                    name: "AskUserQuestion",
-                    input: { questions },
-                }],
+            content,
             model: "router",
             stop_reason: "tool_use",
             stop_sequence: null,

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

@@ -1,3 +1,3 @@
 export { applyEnhancement, buildModelInfoTag } from "./enhancement-handler.js";
-export { parseDirective, parseToolResult, TOOL_USE_ID_PREFIX } from "./directive-parser.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/enhancement/index.js

@@ -1,3 +1,3 @@
 export { applyEnhancement, buildModelInfoTag } from "./enhancement-handler.js";
-export { parseDirective, parseToolResult, TOOL_USE_ID_PREFIX } from "./directive-parser.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/enhancement-config.d.ts

@@ -0,0 +1,6 @@
+import Database from "better-sqlite3";
+export interface EnhancementConfig {
+    claude_code_enabled: boolean;
+}
+/** 集中加载 proxy_enhancement 配置，避免多处重复 getSetting + JSON.parse */
+export declare function loadEnhancementConfig(db: Database.Database): EnhancementConfig;

package/dist/proxy/enhancement-config.js

@@ -0,0 +1,19 @@
+import { getSetting } from "../db/settings.js";
+const DEFAULT_CONFIG = {
+    claude_code_enabled: false,
+};
+/** 集中加载 proxy_enhancement 配置，避免多处重复 getSetting + JSON.parse */
+export function loadEnhancementConfig(db) {
+    const raw = getSetting(db, "proxy_enhancement");
+    if (!raw)
+        return { ...DEFAULT_CONFIG };
+    try {
+        const parsed = JSON.parse(raw);
+        return {
+            claude_code_enabled: parsed.claude_code_enabled ?? false,
+        };
+    }
+    catch {
+        return { ...DEFAULT_CONFIG };
+    }
+}