evolclaw 2.3.0 → 2.5.0

package/dist/utils/error-utils.js

@@ -1,3 +1,7 @@
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths } from '../paths.js';
+import { logger } from './logger.js';
 export var ErrorType;
 (function (ErrorType) {
     ErrorType["SDK_TIMEOUT"] = "sdk_timeout";
@@ -62,32 +66,152 @@ export function isInfraError(subtype, terminalReason) {
 export function prefixErrorType(prefix, errorType) {
     return `${prefix}:${errorType}`;
 }
+// ── 错误字典 ──────────────────────────────────────────────────────────
+const VALID_ACTIONS = new Set(['retry', 'stop', 'ignore']);
+let _dictPath = null;
+let _rules = [];
+let _lastMtime = 0;
+function getDictPath() {
+    if (!_dictPath) {
+        _dictPath = path.join(resolvePaths().dataDir, 'error-dict.json');
+    }
+    return _dictPath;
+}
+/** 校验单条规则，返回错误原因（null = 合法） */
+function validateRule(r, index) {
+    if (!r || typeof r !== 'object')
+        return `rules[${index}]: 不是对象`;
+    if (!r.id || typeof r.id !== 'string')
+        return `rules[${index}]: 缺少 id 或类型不是 string`;
+    if (!r.match || typeof r.match !== 'string')
+        return `rules[${index}] (${r.id}): 缺少 match 或类型不是 string`;
+    if (!VALID_ACTIONS.has(r.action))
+        return `rules[${index}] (${r.id}): action 无效 "${r.action}"，允许值: retry/stop/ignore`;
+    if (r.type !== undefined && typeof r.type !== 'string')
+        return `rules[${index}] (${r.id}): type 类型不是 string`;
+    if (r.message !== undefined && typeof r.message !== 'string')
+        return `rules[${index}] (${r.id}): message 类型不是 string`;
+    return null;
+}
+/**
+ * 刷新字典：检查文件 mtime，有变化则重新读取并校验。
+ * 校验不通过 → 不更新内存数据，记录告警日志。
+ */
+function refreshDict() {
+    const dictPath = getDictPath();
+    let stat;
+    try {
+        stat = fs.statSync(dictPath);
+    }
+    catch {
+        // 文件不存在 → 清空规则（首次）或保持不变（之前有数据且文件被删）
+        if (_rules.length > 0) {
+            logger.warn('[error-dict] 字典文件已删除，清空规则: %s', dictPath);
+            _rules = [];
+            _lastMtime = 0;
+        }
+        return;
+    }
+    const mtime = stat.mtimeMs;
+    if (mtime === _lastMtime)
+        return; // 文件未变化，跳过
+    // 文件有变化，尝试加载
+    try {
+        const content = fs.readFileSync(dictPath, 'utf-8');
+        let raw;
+        try {
+            raw = JSON.parse(content);
+        }
+        catch (parseErr) {
+            logger.warn('[error-dict] JSON 解析失败，保留原有规则: %s — %s', dictPath, parseErr.message);
+            _lastMtime = mtime; // 标记已检查，避免重复读取
+            return;
+        }
+        if (!raw || typeof raw !== 'object' || !Array.isArray(raw.rules)) {
+            logger.warn('[error-dict] 字典格式错误（缺少 rules 数组），保留原有规则: %s', dictPath);
+            _lastMtime = mtime;
+            return;
+        }
+        // 逐条校验
+        const errors = [];
+        for (let i = 0; i < raw.rules.length; i++) {
+            const err = validateRule(raw.rules[i], i);
+            if (err)
+                errors.push(err);
+        }
+        if (errors.length > 0) {
+            logger.warn('[error-dict] 字典校验失败（%d 条错误），保留原有规则:\n  %s', errors.length, errors.join('\n  '));
+            _lastMtime = mtime;
+            return;
+        }
+        // 全部通过，更新
+        _rules = raw.rules;
+        _lastMtime = mtime;
+        logger.info('[error-dict] 已加载 %d 条规则: %s', _rules.length, dictPath);
+    }
+    catch (err) {
+        logger.warn('[error-dict] 读取失败，保留原有规则: %s — %s', dictPath, err.message);
+    }
+}
+/**
+ * 匹配错误消息，返回首条命中的规则。
+ * 每次调用自动检查文件变化（基于 mtime，无变化零开销）。
+ * @param errorMessage 已 toLowerCase 的错误消息
+ */
+export function matchErrorRule(errorMessage) {
+    refreshDict();
+    for (const rule of _rules) {
+        if (errorMessage.includes(rule.match.toLowerCase())) {
+            return rule;
+        }
+    }
+    return null;
+}
+/** 获取当前已加载的规则数量（供测试和状态查询使用） */
+export function getLoadedRuleCount() {
+    refreshDict();
+    return _rules.length;
+}
+/** 重置字典状态（仅供测试使用） */
+export function _resetDict() {
+    _rules = [];
+    _lastMtime = 0;
+    _dictPath = null;
+}
+/** 设置字典文件路径（仅供测试使用） */
+export function _setDictPath(p) {
+    _dictPath = p;
+    _lastMtime = 0; // 强制下次刷新
+}
+// ── 错误分类 / 重试 / 消息 ──────────────────────────────────────────
 export function classifyError(error) {
     const msg = (error?.message || '').toLowerCase();
-    if (msg.includes('上下文过长') || msg.includes('context too long')
-        || msg.includes('context_length_exceeded') || msg.includes('context_compact_failed')
-        || msg.includes('prompt is too long') || msg.includes('context limit')) {
+    // 字典优先 — 命中则直接返回
+    const rule = matchErrorRule(msg);
+    if (rule) {
+        if (rule.type)
+            return rule.type;
+        if (rule.action === 'retry')
+            return ErrorType.API_ERROR;
+        if (rule.action === 'stop')
+            return ErrorType.AUTH_ERROR;
+        return ErrorType.UNKNOWN;
+    }
+    // 内置兜底规则（结构性、稳定的错误模式）
+    if (msg.includes('context_length_exceeded') || msg.includes('context_compact_failed')
+        || msg.includes('context limit')) {
         return ErrorType.CONTEXT_TOO_LONG;
     }
-    // 认证错误（401 / Invalid API Key / key_not_found）— 不可恢复，不应触发安全模式
-    if (msg.includes('401') || msg.includes('invalid api key') || msg.includes('key_not_found')
-        || msg.includes('authentication_error') || msg.includes('failed to authenticate')) {
+    if (msg.includes('401') || msg.includes('authentication_error')) {
         return ErrorType.AUTH_ERROR;
     }
     if (msg.includes('timeout') || msg.includes('etimedout')) {
         return ErrorType.SDK_TIMEOUT;
     }
-    if (msg.includes('5') && (msg.includes('00') || msg.includes('02') || msg.includes('03') || msg.includes('04'))) {
-        return ErrorType.API_ERROR;
-    }
-    // "X is not valid JSON" — API 返回了非 JSON 响应（如算力池切换提示），属于 API 错误
-    if (msg.includes('is not valid json')) {
-        return ErrorType.API_ERROR;
-    }
-    if (msg.includes('enoent') || msg.includes('corrupt') || msg.includes('invalid json')) {
+    if (msg.includes('enoent') || msg.includes('corrupt')) {
         return ErrorType.FILE_CORRUPT;
     }
-    if (msg.includes('stream') || msg.includes('aborted') || msg.includes('interrupted')) {
+    if (msg.includes('aborted') || msg.includes('interrupted')) {
         return ErrorType.STREAM_ERROR;
     }
     return ErrorType.UNKNOWN;
@@ -100,26 +224,16 @@ export function classifyError(error) {
 export function isRetryableError(error) {
     const msg = error?.message || String(error);
     const lower = msg.toLowerCase();
-    // 认证错误不可重试：重试不会恢复无效/缺失凭据
-    if (lower.includes('401')
-        || lower.includes('invalid api key')
-        || lower.includes('key_not_found')
-        || lower.includes('authentication_error')
-        || lower.includes('failed to authenticate')
-        || (lower.includes('api error: 403') && (lower.includes('auth') || lower.includes('key') || lower.includes('token')))) {
-        return false;
+    // 字典优先 — 命中则直接返回
+    const rule = matchErrorRule(lower);
+    if (rule)
+        return rule.action === 'retry';
+    // 内置兜底规则（结构性错误码）
+    if (lower.includes('401') || lower.includes('authentication_error')) {
+        return false; // 认证错误不可重试
     }
-    if (msg.includes('API Error: 403'))
-        return true;
-    if (msg.includes('API Error: 429'))
-        return true;
-    if (msg.includes('API Error: 500'))
-        return true;
-    if (msg.includes('API Error: 502'))
-        return true;
-    if (msg.includes('API Error: 503'))
-        return true;
-    if (msg.includes('API Error: 504'))
+    // HTTP 5xx / 429 — 标准可重试状态码
+    if (/api error: (429|5\d{2})\b/.test(lower))
         return true;
     return false;
 }
@@ -148,34 +262,20 @@ export function getErrorMessage(error, terminalReason) {
     }
     // 回退到原有的错误消息匹配逻辑
     const msg = error?.message || String(error);
-    if (msg.includes('CONTEXT_COMPACT_FAILED')) {
+    // 字典优先 — 命中且有自定义消息则直接返回
+    const rule = matchErrorRule(msg.toLowerCase());
+    if (rule?.message)
+        return rule.message;
+    // 内置兜底规则（结构性错误）
+    if (msg.includes('CONTEXT_COMPACT_FAILED') || msg.includes('context_length_exceeded')
+        || msg.includes('Context limit')) {
         return '⚠️ 上下文过长，自动压缩失败，请手动输入 /compact 重试';
     }
-    if (msg.includes('上下文过长') || msg.includes('context too long') || msg.includes('context_length_exceeded')
-        || msg.includes('Prompt is too long') || msg.includes('Context limit')) {
-        return '⚠️ 上下文过长，自动压缩重试失败，请手动输入 /compact 重试';
-    }
-    if (msg.includes('API Error: 400')) {
-        return '❌ 请求格式错误，请检查输入内容';
-    }
-    if (msg.includes('401') || msg.includes('Invalid API key') || msg.includes('key_not_found')
-        || msg.includes('authentication_error')) {
+    if (msg.includes('401') || msg.includes('authentication_error')) {
         return '❌ API Key 无效，请检查密钥配置。使用 /status 查看当前配置';
     }
-    if (msg.includes('API Error: 500')) {
-        return '❌ API 服务暂时不可用，请稍后重试';
-    }
-    if (msg.includes('API Error: 403')) {
-        return '❌ API 认证失败，请检查密钥配置或稍后重试';
-    }
-    if (msg.includes('API Error: 429')) {
-        return '⚠️ 请求过于频繁，请稍后再试';
-    }
     if (msg.includes('timeout')) {
         return '⚠️ 请求超时，请重试';
     }
-    if (msg.includes('permission') || msg.includes('im:resource')) {
-        return '❌ 权限不足，请联系管理员配置应用权限';
-    }
     return '❌ 处理消息时出错，请稍后重试';
 }

package/dist/utils/format.js

@@ -0,0 +1,32 @@
+// ── Markdown → Plain Text ───────────────────────────────────────────────────
+export function markdownToPlainText(text) {
+    let result = text;
+    // Code blocks: strip fences, keep content
+    result = result.replace(/```[^\n]*\n?([\s\S]*?)```/g, (_, code) => code.trim());
+    // Images: remove entirely
+    result = result.replace(/!\[[^\]]*\]\([^)]*\)/g, '');
+    // Links: keep display text only
+    result = result.replace(/\[([^\]]+)\]\([^)]*\)/g, '$1');
+    // Tables: remove separator rows
+    result = result.replace(/^\|[\s:|-]+\|$/gm, '');
+    result = result.replace(/^\|(.+)\|$/gm, (_, inner) => inner.split('|').map(cell => cell.trim()).join('  '));
+    // Bold/italic
+    result = result.replace(/\*\*(.+?)\*\*/g, '$1');
+    result = result.replace(/\*(.+?)\*/g, '$1');
+    result = result.replace(/__(.+?)__/g, '$1');
+    result = result.replace(/_(.+?)_/g, '$1');
+    // Strikethrough
+    result = result.replace(/~~(.+?)~~/g, '$1');
+    // Inline code
+    result = result.replace(/`([^`]+)`/g, '$1');
+    // Headers
+    result = result.replace(/^#{1,6}\s+/gm, '');
+    // Blockquotes
+    result = result.replace(/^>\s?/gm, '');
+    // Horizontal rules
+    result = result.replace(/^[-*_]{3,}$/gm, '');
+    // List markers
+    result = result.replace(/^(\s*)[-*+]\s/gm, '$1');
+    result = result.replace(/^(\s*)\d+\.\s/gm, '$1');
+    return result.trim();
+}