llm-simple-router 0.11.1 → 0.11.4

package/config/recommended-retry-rules.json

@@ -8,5 +8,6 @@
   { "name": "ZAI SSE 错误 (HTTP 200, code 500)", "status_code": 200, "body_pattern": "\"error\".*\"code\"\\s*:\\s*\"500\"", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 10, "max_delay_ms": 60000, "providers": ["智谱"] },
   { "name": "ZAI SSE 错误 (HTTP 200, code 1234)", "status_code": 200, "body_pattern": "\"error\".*\"code\"\\s*:\\s*\"1234\"", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 10, "max_delay_ms": 60000, "providers": ["智谱"] },
   { "name": "ZAI 模型过载 (HTTP 200, code 1305)", "status_code": 200, "body_pattern": "\"error\".*\"code\"\\s*:\\s*\"1305\"", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 10, "max_delay_ms": 60000, "providers": ["智谱"] },
-  { "name": "KIMI 401 认证错误", "status_code": 401, "body_pattern": ".*authentication_error.*", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 3, "max_delay_ms": 60000, "providers": ["月之暗面"] }
+  { "name": "KIMI 401 认证错误", "status_code": 401, "body_pattern": ".*authentication_error.*", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 3, "max_delay_ms": 60000, "providers": ["月之暗面"] },
+  { "name": "DeepSeek 并发限流 (429)", "status_code": 429, "body_pattern": "Too many requests.*concurrency", "retry_strategy": "exponential", "retry_delay_ms": 2000, "max_retries": 5, "max_delay_ms": 120000, "providers": ["DeepSeek", "OpenCode"] }
 ]

package/dist/admin/monitor.js

@@ -16,15 +16,12 @@ export const adminMonitorRoutes = (app, options, done) => {
     app.get("/admin/api/monitor/stream", (request, reply) => {
         // hijack() 让 Fastify 完全放弃响应管理，避免 onSend hook 向 SSE 流注入信封 JSON
         reply.hijack();
-        const sseClient = adaptSSEClient(reply.raw);
-        tracker.addClient(sseClient);
-        // 在 writeHead 之前注册 close 处理器，避免竞态导致 tracker 泄漏
-        reply.raw.on("close", () => {
-            tracker.removeClient(sseClient);
-        });
         // 客户端在 hijack 之前已断连，无需发送响应头
         if (reply.raw.destroyed)
             return;
+        // writeHead 必须在 addClient 之前调用，否则 sendInitialSnapshot 的 write()
+        // 会触发 Node.js 隐式 header 发送（Content-Type 默认非 text/event-stream），
+        // 导致浏览器 EventSource 解析失败、不断重连。
         try {
             reply.raw.writeHead(HTTP_OK, {
                 "Content-Type": "text/event-stream",
@@ -34,7 +31,13 @@ export const adminMonitorRoutes = (app, options, done) => {
         }
         catch {
             request.log.debug("client disconnected before writeHead");
+            return;
         }
+        const sseClient = adaptSSEClient(reply.raw);
+        tracker.addClient(sseClient);
+        reply.raw.on("close", () => {
+            tracker.removeClient(sseClient);
+        });
     });
     app.get("/admin/api/monitor/request/:id", async (request, reply) => {
         const { id } = request.params;

package/dist/admin/proxy-enhancement.js

@@ -6,6 +6,10 @@ const UpdateProxyEnhancementSchema = Type.Object({
     stream_loop_enabled: Type.Boolean(),
     tool_round_limit_enabled: Type.Boolean(),
     tool_error_logging_enabled: Type.Boolean(),
+    ai_retry_config: Type.Optional(Type.Union([
+        Type.Null(),
+        Type.Object({ provider_id: Type.String({ minLength: 1 }), model: Type.String({ minLength: 1 }) }),
+    ])),
 });
 export const adminProxyEnhancementRoutes = (app, options, done) => {
     const { db } = options;
@@ -25,18 +29,34 @@ export const adminProxyEnhancementRoutes = (app, options, done) => {
             }
             catch { /* eslint-disable-line taste/no-silent-catch -- invalid JSON, return defaults */ }
         }
-        return reply.send(config);
+        const aiConfigRaw = getSetting(db, "ai_retry_config");
+        let aiRetryConfig = null;
+        if (aiConfigRaw) {
+            try {
+                aiRetryConfig = JSON.parse(aiConfigRaw);
+            }
+            catch (e) {
+                console.error('proxyEnhancement.parseAiConfig:', e);
+                aiRetryConfig = null; // 损坏的 JSON 回退为 null
+            }
+        }
+        return reply.send({ ...config, ai_retry_config: aiRetryConfig });
     });
     app.put("/admin/api/proxy-enhancement", { schema: { body: UpdateProxyEnhancementSchema } }, async (request, reply) => {
         const body = request.body;
+        const { ai_retry_config, ...enhancementFields } = body;
         const config = {
-            tool_call_loop_enabled: body.tool_call_loop_enabled,
-            stream_loop_enabled: body.stream_loop_enabled,
-            tool_round_limit_enabled: body.tool_round_limit_enabled,
-            tool_error_logging_enabled: body.tool_error_logging_enabled,
+            tool_call_loop_enabled: enhancementFields.tool_call_loop_enabled,
+            stream_loop_enabled: enhancementFields.stream_loop_enabled,
+            tool_round_limit_enabled: enhancementFields.tool_round_limit_enabled,
+            tool_error_logging_enabled: enhancementFields.tool_error_logging_enabled,
         };
         setSetting(db, "proxy_enhancement", JSON.stringify(config));
         clearEnhancementConfigCache();
+        // ai_retry_config is stored in a separate settings key
+        if (ai_retry_config !== undefined) {
+            setSetting(db, "ai_retry_config", ai_retry_config ? JSON.stringify(ai_retry_config) : "");
+        }
         return reply.send({ success: true });
     });
     done();

package/dist/admin/retry-rules.js

@@ -1,7 +1,18 @@
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 import { Type } from "@sinclair/typebox";
 import { getAllRetryRules, getRetryRuleById, createRetryRule, updateRetryRule, deleteRetryRule, } from "../db/index.js";
-import { HTTP_BAD_REQUEST, HTTP_CREATED, HTTP_NOT_FOUND } from "./constants.js";
+import { callLLM } from "../utils/llm-client.js";
+import { getActiveRetryRules } from "../db/retry-rules.js";
+import { getRequestLogById } from "../db/logs.js";
+import { getProviderById } from "../db/providers.js";
+import { getSetting } from "../db/settings.js";
+import { decrypt } from "../utils/crypto.js";
+import { HTTP_OK, HTTP_BAD_REQUEST, HTTP_CREATED, HTTP_NOT_FOUND } from "./constants.js";
 import { API_CODE, apiError } from "./api-response.js";
+// 加载 AI 重试规则的 system prompt 模板（独立文件，避免模板字面量转义问题）
+const AI_RETRY_PROMPT_TEMPLATE = readFileSync(join(dirname(fileURLToPath(import.meta.url)), "ai-retry-prompt.md"), "utf-8");
 const DEFAULT_RETRY_DELAY_MS = 5000;
 const DEFAULT_MAX_RETRIES = 10;
 const DEFAULT_MAX_DELAY_MS = 60000;
@@ -34,6 +45,121 @@ function validateBodyPattern(pattern) {
         return "Invalid body_pattern regex";
     }
 }
+// ---------- AI Retry Rule Generation Helpers ----------
+const MAX_RESPONSE_CHARS = 4000;
+const STATUS_CODE_MIN = 100;
+const STATUS_CODE_MAX = 599;
+const MAX_RETRIES_UPPER = 100;
+/** 从日志中提取响应文本，优先 upstream_response，回退 stream_text_content */
+function extractResponseText(log) {
+    const raw = log.upstream_response || log.stream_text_content || "";
+    if (raw.length <= MAX_RESPONSE_CHARS)
+        return raw;
+    const TRUNCATION_SUFFIX = "\n...(truncated)";
+    const truncated = raw.substring(0, MAX_RESPONSE_CHARS - TRUNCATION_SUFFIX.length);
+    // 在 JSON 边界处截断，避免破坏键值对导致 AI 生成无效正则
+    const lastBrace = truncated.lastIndexOf("}");
+    const lastBracket = truncated.lastIndexOf("]");
+    const cutPoint = Math.max(lastBrace, lastBracket);
+    const MIN_RATIO_FOR_BOUNDARY_CUT = 0.5;
+    return cutPoint > truncated.length * MIN_RATIO_FOR_BOUNDARY_CUT ? truncated.substring(0, cutPoint + 1) + TRUNCATION_SUFFIX : truncated + TRUNCATION_SUFFIX;
+}
+/** 检查文本是否包含错误特征关键词（case-insensitive） */
+function hasErrorFeatures(text) {
+    if (!text)
+        return false;
+    const lower = text.toLowerCase();
+    return lower.includes("error");
+}
+/** 解析 AI 返回的 JSON，支持 ```json 代码块包裹 */
+function parseAIContent(content) {
+    const codeBlockMatch = content.match(/```json\s*([\s\S]*?)```/);
+    const jsonStr = codeBlockMatch ? codeBlockMatch[1].trim() : content.trim();
+    try {
+        return JSON.parse(jsonStr);
+    }
+    catch {
+        return null;
+    }
+}
+/** 从 AI 返回的 error 字段提取可读错误信息（兼容 string 和 object 两种格式） */
+function extractErrorMessage(error) {
+    if (typeof error === "string")
+        return error;
+    const obj = error;
+    const msg = obj.message;
+    return typeof msg === "string" ? msg : JSON.stringify(error);
+}
+/** 校验 AI 生成的规则字段，返回错误描述或 null */
+function validateAIRule(parsed) {
+    if (typeof parsed.summary !== "string" || parsed.summary.trim() === "") {
+        return "summary is required";
+    }
+    if (typeof parsed.name !== "string" || parsed.name.trim() === "") {
+        return "name is required";
+    }
+    if (typeof parsed.status_code !== "number" || !Number.isInteger(parsed.status_code) || parsed.status_code < STATUS_CODE_MIN || parsed.status_code > STATUS_CODE_MAX) {
+        return "status_code must be 100-599";
+    }
+    if (typeof parsed.body_pattern !== "string") {
+        return "body_pattern is required";
+    }
+    try {
+        new RegExp(parsed.body_pattern);
+    }
+    catch {
+        return "body_pattern is not a valid regex";
+    }
+    // ReDoS 防护：限制正则长度 + 检测已知危险模式
+    const MAX_PATTERN_LENGTH = 500;
+    if (parsed.body_pattern.length > MAX_PATTERN_LENGTH) {
+        return `Rule validation failed: body_pattern too long (max ${MAX_PATTERN_LENGTH} chars)`;
+    }
+    const DANGEROUS_REGEX_PATTERNS = [
+        /\([^)]*\+[^)]*\+/, // 嵌套量词如 (a+b+)+
+        /\([^)]*[*+][^)]*\)\s*[*+]/, // 重复分组 + 量词
+        /\(\.\*[^)]*\)\s*[*+]/, // (.*)+ 类型
+    ];
+    for (const dangerous of DANGEROUS_REGEX_PATTERNS) {
+        if (dangerous.test(parsed.body_pattern)) {
+            return "Rule validation failed: body_pattern contains potentially catastrophic regex";
+        }
+    }
+    if (parsed.retry_strategy !== "fixed" && parsed.retry_strategy !== "exponential") {
+        return "retry_strategy must be 'fixed' or 'exponential'";
+    }
+    if (typeof parsed.retry_delay_ms !== "number" || !Number.isInteger(parsed.retry_delay_ms) || parsed.retry_delay_ms <= 0) {
+        return "retry_delay_ms must be a positive integer";
+    }
+    if (typeof parsed.max_retries !== "number" || !Number.isInteger(parsed.max_retries) || parsed.max_retries < 0 || parsed.max_retries > MAX_RETRIES_UPPER) {
+        return "max_retries must be 0-100";
+    }
+    if (typeof parsed.max_delay_ms !== "number" || !Number.isInteger(parsed.max_delay_ms) || parsed.max_delay_ms <= 0) {
+        return "max_delay_ms must be a positive integer";
+    }
+    return null;
+}
+const MAX_PROMPT_RULES = 20;
+/** 构造 system prompt，基于外部模板文件 + 现有规则列表 */
+function buildSystemPrompt(existingRules) {
+    const displayRules = existingRules.slice(0, MAX_PROMPT_RULES);
+    const rulesList = displayRules.length > 0
+        ? displayRules.map((r) => `- ${r.name}: status=${r.status_code}, pattern=${r.body_pattern}`).join("\n")
+        : "(none)";
+    const truncateHint = existingRules.length > MAX_PROMPT_RULES ? `\n... and ${existingRules.length - MAX_PROMPT_RULES} more rules` : "";
+    return `${AI_RETRY_PROMPT_TEMPLATE}\n\n${rulesList}${truncateHint}\n\nNote: The Response Body may be truncated. Generate body_pattern based only on the complete key-value pairs you can see.`;
+}
+/** 构造 user prompt，使用 provider_name 而非 provider_id */
+function buildUserPrompt(log, responseText) {
+    const providerDisplayName = log.provider_name || log.provider_id || "unknown";
+    return `Provider: ${providerDisplayName}
+Model: ${log.model ?? "unknown"}
+Status Code: ${log.status_code ?? "N/A"}
+Error Message: ${log.error_message ?? "N/A"}
+
+Response Body:
+${responseText}`;
+}
 export const adminRetryRuleRoutes = (app, options, done) => {
     const { db, stateRegistry } = options;
     app.get("/admin/api/retry-rules", async (_request, reply) => {
@@ -97,5 +223,122 @@ export const adminRetryRuleRoutes = (app, options, done) => {
         stateRegistry?.refreshRetryRules();
         return reply.send({ success: true });
     });
+    const AiGenerateBodySchema = Type.Object({
+        log_id: Type.String({ minLength: 1 }),
+    });
+    // AI generate retry rule endpoint
+    app.post("/admin/api/retry-rules/ai-generate", { schema: { body: AiGenerateBodySchema } }, async (request, reply) => {
+        const { log_id } = request.body;
+        // All responses let onSend hook wrap in { code, message, data } envelope
+        // Frontend request<T>() auto-unwraps body.data
+        // 1. Check AI config
+        const aiConfigRaw = getSetting(db, "ai_retry_config");
+        if (!aiConfigRaw) {
+            return reply.send({ success: false, error: "AI retry config not set" });
+        }
+        let aiConfig;
+        try {
+            aiConfig = JSON.parse(aiConfigRaw);
+        }
+        catch {
+            return reply.send({ success: false, error: "AI config is invalid JSON" });
+        }
+        if (!aiConfig.provider_id || !aiConfig.model) {
+            return reply.send({ success: false, error: "AI config is incomplete" });
+        }
+        // 2. Look up the log
+        const log = getRequestLogById(db, log_id);
+        if (!log) {
+            return reply.send({ success: false, error: "Log not found" });
+        }
+        // 3. Extract response text
+        const responseText = extractResponseText(log);
+        // 4. Pre-check: reject 2xx responses without error features
+        const HTTP_MULTIPLE_CHOICES = 300;
+        const is2xx = log.status_code !== null && log.status_code >= HTTP_OK && log.status_code < HTTP_MULTIPLE_CHOICES;
+        if (is2xx && !log.error_message && !hasErrorFeatures(responseText)) {
+            return reply.send({ success: false, error: "Cannot generate retry rule for a successful response" });
+        }
+        // 5. Get the configured AI provider
+        const provider = getProviderById(db, aiConfig.provider_id);
+        if (!provider) {
+            return reply.send({ success: false, error: "AI provider not found" });
+        }
+        // 6. Decrypt API key
+        const encryptionKey = getSetting(db, "encryption_key");
+        if (!encryptionKey) {
+            return reply.send({ success: false, error: "Encryption key not set" });
+        }
+        let apiKey;
+        try {
+            apiKey = decrypt(provider.api_key, encryptionKey);
+        }
+        catch {
+            return reply.send({ success: false, error: "Failed to decrypt API key" });
+        }
+        // 7. Build prompts
+        const existingRules = getActiveRetryRules(db);
+        const systemPrompt = buildSystemPrompt(existingRules);
+        const userPrompt = buildUserPrompt(log, responseText);
+        // 8. Call LLM
+        let llmResult;
+        try {
+            llmResult = await callLLM({
+                baseUrl: provider.base_url,
+                upstreamPath: provider.upstream_path,
+                apiKey,
+                model: aiConfig.model,
+                messages: [
+                    { role: "system", content: systemPrompt },
+                    { role: "user", content: userPrompt },
+                ],
+                maxTokens: 2048,
+                timeoutMs: 30_000,
+            });
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : "Unknown error";
+            if (!(e instanceof Error)) {
+                request.log.error({ err: e }, "LLM call failed with non-Error");
+            }
+            return reply.send({ success: false, error: `LLM call failed: ${msg}` });
+        }
+        // 9. Parse AI response
+        const parsed = parseAIContent(llmResult.content);
+        if (!parsed) {
+            // Check if the raw content is an error/refusal message
+            const lowerContent = llmResult.content.toLowerCase().trim();
+            if (lowerContent.startsWith("error") || lowerContent.includes("unable to")) {
+                return reply.send({ success: false, error: "AI returned an error exit" });
+            }
+            return reply.send({ success: false, error: "Failed to parse AI response as JSON" });
+        }
+        // 10. AI exit check — parsed object has an error field
+        if (parsed.error != null) {
+            const errorMsg = typeof parsed.error === "string"
+                ? parsed.error
+                : extractErrorMessage(parsed.error);
+            return reply.send({ success: false, error: errorMsg });
+        }
+        // 11. Validate fields
+        const validationError = validateAIRule(parsed);
+        if (validationError) {
+            return reply.send({ success: false, error: `Rule validation failed: ${validationError}` });
+        }
+        // 12. Return success
+        return reply.send({
+            success: true,
+            rule: {
+                name: parsed.name,
+                status_code: parsed.status_code,
+                body_pattern: parsed.body_pattern,
+                retry_strategy: parsed.retry_strategy,
+                retry_delay_ms: parsed.retry_delay_ms,
+                max_retries: parsed.max_retries,
+                max_delay_ms: parsed.max_delay_ms,
+            },
+            summary: parsed.summary,
+        });
+    });
     done();
 };

package/dist/config/model-context.js

@@ -144,8 +144,17 @@ let directoryContextWindows = {};
  */
 export function loadModelDirectory(configDir) {
     try {
-        // 默认相对于当前文件所在目录（dist/config/ 或 src/config/），而非 process.cwd()
-        const dir = configDir ?? path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "config");
+        // 优先使用传入的 configDir，否则自动检测：
+        // - 生产 (dist/config/model-context.js): 上溯一级到 dist/ → dist/config/ (postbuild 已复制)
+        // - 开发 (src/config/model-context.ts): 上溯二级到包根 → config/
+        let dir = configDir;
+        if (!dir) {
+            const fileDir = path.dirname(fileURLToPath(import.meta.url));
+            const prodDir = path.resolve(fileDir, "..", "config");
+            dir = fs.existsSync(path.join(prodDir, "model-directory.json"))
+                ? prodDir
+                : path.resolve(fileDir, "..", "..", "config");
+        }
         const filePath = path.join(dir, "model-directory.json");
         const raw = fs.readFileSync(filePath, "utf-8");
         const data = JSON.parse(raw);
@@ -155,11 +164,11 @@ export function loadModelDirectory(configDir) {
         if (data.context_windows && typeof data.context_windows === "object") {
             directoryContextWindows = data.context_windows;
         }
-        // eslint-disable-next-line taste/no-silent-catch -- 加载失败不影响启动，使用硬编码白名单兆底。但记录到 stderr 供诊断
     }
     catch (err) {
-        // 加载失败不影响启动，使用硬编码白名单兆底。但记录到 stderr 供诊断
-        console.error('loadModelDirectory: failed to load, using hardcoded fallback', err);
+        const msg = err instanceof Error ? err.message : typeof err === 'string' ? err : JSON.stringify(err);
+        console.warn(`loadModelDirectory: failed to load (${msg}), using hardcoded fallback`);
+        console.debug(err);
     }
 }
 /** 查询模型 capabilities：显式配置 > model-directory.json > 硬编码白名单 > ["text"] */

package/dist/config/recommended-retry-rules.json

@@ -8,5 +8,6 @@
   { "name": "ZAI SSE 错误 (HTTP 200, code 500)", "status_code": 200, "body_pattern": "\"error\".*\"code\"\\s*:\\s*\"500\"", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 10, "max_delay_ms": 60000, "providers": ["智谱"] },
   { "name": "ZAI SSE 错误 (HTTP 200, code 1234)", "status_code": 200, "body_pattern": "\"error\".*\"code\"\\s*:\\s*\"1234\"", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 10, "max_delay_ms": 60000, "providers": ["智谱"] },
   { "name": "ZAI 模型过载 (HTTP 200, code 1305)", "status_code": 200, "body_pattern": "\"error\".*\"code\"\\s*:\\s*\"1305\"", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 10, "max_delay_ms": 60000, "providers": ["智谱"] },
-  { "name": "KIMI 401 认证错误", "status_code": 401, "body_pattern": ".*authentication_error.*", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 3, "max_delay_ms": 60000, "providers": ["月之暗面"] }
+  { "name": "KIMI 401 认证错误", "status_code": 401, "body_pattern": ".*authentication_error.*", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 3, "max_delay_ms": 60000, "providers": ["月之暗面"] },
+  { "name": "DeepSeek 并发限流 (429)", "status_code": 429, "body_pattern": "Too many requests.*concurrency", "retry_strategy": "exponential", "retry_delay_ms": 2000, "max_retries": 5, "max_delay_ms": 120000, "providers": ["DeepSeek", "OpenCode"] }
 ]

package/dist/core/monitor/stream-extractor.js

@@ -1,4 +1,8 @@
 const SSE_DATA_PREFIX = "data: ";
+// OpenAI stream block index 分配：reasoning/text/tools 使用不同区间避免混合
+const OPENAI_BLOCK_REASONING = 0;
+const OPENAI_BLOCK_TEXT = 1;
+const OPENAI_BLOCK_TOOLS = 2;
 export function extractStreamText(line, apiType) {
     const empty = { text: "", block: null };
     if (!line.startsWith(SSE_DATA_PREFIX))
@@ -16,8 +20,32 @@ export function extractStreamText(line, apiType) {
     if (apiType === "openai") {
         const choices = obj.choices;
         const delta = choices?.[0]?.delta;
-        const text = delta?.content ?? delta?.reasoning_content ?? "";
-        return { text, block: text ? { index: 0, type: "text", content: text } : null };
+        const text = delta?.content ?? "";
+        const reasoning = delta?.reasoning_content ?? "";
+        // OpenAI 不像 Anthropic 那样为不同 content type 分配独立 index。
+        // 策略：reasoning → OPENAI_BLOCK_REASONING, text → OPENAI_BLOCK_TEXT,
+        // tool_calls[N] → OPENAI_BLOCK_TOOLS + N。
+        // 这样不同类型的内容不会混在同一个 block 中。
+        if (reasoning) {
+            return { text: reasoning, block: { index: OPENAI_BLOCK_REASONING, type: "thinking", content: reasoning } };
+        }
+        if (text) {
+            return { text, block: { index: OPENAI_BLOCK_TEXT, type: "text", content: text } };
+        }
+        const toolCalls = delta?.tool_calls;
+        if (toolCalls) {
+            const tc = toolCalls[0];
+            if (tc) {
+                const tcIndex = tc.index ?? 0;
+                const fn = tc.function;
+                const args = fn?.arguments ?? "";
+                const name = fn?.name ?? "";
+                if (args || name) {
+                    return { text: "", block: { index: OPENAI_BLOCK_TOOLS + tcIndex, type: "tool_use", content: args, name: name || undefined } };
+                }
+            }
+        }
+        return empty;
     }
     if (apiType === "openai-responses") {
         // Responses SSE uses named events, but line format is "data: {json}" (same as Anthropic)

package/dist/index.js

@@ -322,7 +322,7 @@ export async function buildApp(options) {
         });
     }
     else {
-        app.log.warn(`Frontend dist not found at ${frontendDist}, skipping static serving`);
+        app.log.debug(`Frontend dist not found at ${frontendDist}, skipping static serving`);
     }
     app.get("/health", async () => {
         return { status: "ok" };

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

@@ -19,12 +19,7 @@ import { SERVICE_KEYS } from "../../core/container.js";
 import { createPipelineContext } from "../pipeline/context.js";
 import { proxyPipeline } from "../pipeline/pipeline.js";
 import { executeFailoverLoop } from "./failover-loop.js";
-import { loadEnhancementConfig } from "../routing/enhancement-config.js";
-import { ToolLoopGuard } from "../../core/loop-prevention/index.js";
-import { HTTP_UNPROCESSABLE_ENTITY } from "../../core/constants.js";
 import { PipelineAbort } from "../pipeline/types.js";
-import { applyToolRoundLimit } from "../patch/tool-round-limiter.js";
-import { extractLastToolUse } from "./proxy-handler-utils.js";
 // ---------- Models handler (shared across openai/anthropic) ----------
 const ANTHROPIC_DEFAULT_PAGE_SIZE = 20;
 const ANTHROPIC_MAX_PAGE_SIZE = 1000;
@@ -98,60 +93,6 @@ function handleModelsRequest(db) {
         });
     };
 }
-// ---------- Enhancement preprocessing (extracted from old handleProxyRequest) ----------
-const TIER2_LOOP_THRESHOLD = 2;
-function applyEnhancementPreprocess(request, reply, ctx, db, container) {
-    const enhancementConfig = loadEnhancementConfig(db);
-    const apiType = ctx.apiType;
-    const sessionId = ctx.metadata.get("session_id");
-    // 工具轮数限制
-    if (enhancementConfig.tool_round_limit_enabled) {
-        const roundResult = applyToolRoundLimit(ctx.body, apiType);
-        if (roundResult.injected) {
-            ctx.body = roundResult.body;
-            ctx.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");
-        }
-    }
-    // 工具循环检测
-    if (!enhancementConfig.tool_call_loop_enabled || !sessionId)
-        return;
-    const sessionTracker = container.resolve(SERVICE_KEYS.sessionTracker);
-    if (!sessionTracker)
-        return;
-    const routerKeyId = request.routerKey?.id ?? null;
-    const sessionKey = routerKeyId ? `${routerKeyId}:${sessionId}` : sessionId;
-    const lastToolUse = extractLastToolUse(ctx.body);
-    if (!lastToolUse)
-        return;
-    const toolGuard = new ToolLoopGuard(sessionTracker, {
-        enabled: true,
-        minConsecutiveCount: 3,
-        detectorConfig: { n: 6, windowSize: 500, repeatThreshold: 5 },
-    });
-    const checkResult = toolGuard.check(sessionKey, lastToolUse);
-    if (!checkResult.detected)
-        return;
-    const loopCount = sessionTracker.getLoopCount(sessionKey);
-    if (loopCount === 1) {
-        ctx.body = toolGuard.injectLoopBreakPrompt(ctx.body, apiType, lastToolUse.toolName);
-        ctx.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");
-    }
-    else if (loopCount === TIER2_LOOP_THRESHOLD) {
-        throw new PipelineAbort(HTTP_UNPROCESSABLE_ENTITY, {
-            error: {
-                type: "tool_call_loop_detected",
-                message: `检测到工具调用循环（连续重复调用 "${lastToolUse.toolName}"）。请求已中断。`,
-                suggestion: "请回顾对话历史，停止重复调用工具，直接告知用户当前的进展和遇到的问题。",
-            },
-        });
-    }
-    else {
-        request.log.warn({ sessionId, toolName: lastToolUse.toolName, loopCount }, "Tool call loop detected, hard disconnecting");
-        throw new PipelineAbort(HTTP_CLIENT_CLOSED, { _disconnect: true });
-    }
-}
 // ---------- Factory ----------
 export function createProxyHandler(config) {
     const { apiType, paths } = config;
@@ -214,13 +155,10 @@ export function createProxyHandler(config) {
             const ctx = createPipelineContext(request, reply, apiType);
             // 注入 DB 到 metadata（hooks 需要访问 settings/写入数据）
             ctx.metadata.set("db", db);
+            ctx.metadata.set("container", container);
             // 执行 pre_route 阶段 hooks（client-detection 在此阶段设置 client_type / session_id）
-            await proxyPipeline.emit("pre_route", ctx).catch(err => {
-                request.log.error({ err }, "pre_route hook failed");
-            });
-            // 增强预处理（工具轮数限制 + 工具循环检测）
             try {
-                applyEnhancementPreprocess(request, reply, ctx, db, container);
+                await proxyPipeline.emit("pre_route", ctx);
             }
             catch (e) {
                 if (e instanceof PipelineAbort) {
@@ -230,6 +168,7 @@ export function createProxyHandler(config) {
                     }
                     return reply.code(e.statusCode).send(e.body);
                 }
+                request.log.error({ err: e }, "pre_route hook failed");
                 throw e;
             }
             const deps = {

package/dist/proxy/orchestration/resilience.js

@@ -172,7 +172,7 @@ export class ResilienceLayer {
                 transportResult = await fn(currentTarget);
             }
             catch (err) {
-                const errMsg = err instanceof Error ? err.message : err instanceof Error ? err.message : JSON.stringify(err);
+                const errMsg = err instanceof Error ? err.message : JSON.stringify(err);
                 transportResult = { kind: "throw", error: err instanceof Error ? err : new Error(errMsg) };
             }
             lastResult = transportResult;

package/dist/proxy/proxy-logging.js

@@ -18,6 +18,35 @@ export function sanitizeHeadersForLog(headers) {
     }
     return sanitized;
 }
+/** 从上游响应 body 中提取错误信息，用于 error_message 为空但上游返回了非 200 的场景 */
+function extractErrorMessageFromResponse(responseBody) {
+    if (!responseBody)
+        return null;
+    const MAX_TEXT_LENGTH = 200;
+    try {
+        const parsed = JSON.parse(responseBody);
+        // OpenAI / DeepSeek 格式: { error: { message: "..." } }
+        const openaiMsg = parsed?.error?.message;
+        if (typeof openaiMsg === "string")
+            return openaiMsg;
+        // Cloudflare 格式: { title: "...", detail: "..." }
+        if (typeof parsed?.title === "string") {
+            const detail = parsed?.detail;
+            return typeof detail === "string" ? `${parsed.title}: ${detail}` : parsed.title;
+        }
+        // 兜底：直接 message 字段
+        if (typeof parsed?.message === "string")
+            return parsed.message;
+    }
+    catch {
+        // 非 JSON（如 HTML），截取前 200 字符
+        const text = responseBody.trim();
+        if (text.length > MAX_TEXT_LENGTH)
+            return text.slice(0, MAX_TEXT_LENGTH) + "...";
+        return text || null;
+    }
+    return null;
+}
 // ---------- Logging helpers (extracted from proxy-core) ----------
 // ---------- New-architecture logging ----------
 export function logResilienceResult(db, params, attempts, result, startTime) {
@@ -77,7 +106,7 @@ export function logResilienceResult(db, params, attempts, result, startTime) {
                 id: attemptLogId, api_type: params.apiType, model: params.model,
                 provider_id: attempt.target.provider_id,
                 status_code: attempt.statusCode, latency_ms: attempt.latencyMs,
-                is_stream: params.isStream ? 1 : 0, error_message: null,
+                is_stream: params.isStream ? 1 : 0, error_message: extractErrorMessageFromResponse(attempt.responseBody),
                 created_at: new Date().toISOString(),
                 client_request: params.clientReq, upstream_request: params.upstreamReqBase,
                 upstream_response: JSON.stringify({ statusCode: attempt.statusCode, headers: attempt.responseHeaders, body: attempt.responseBody }),