foliko 1.1.63 → 1.1.65

package/src/utils/message-validator.js

@@ -0,0 +1,283 @@
+/**
+ * 消息验证工具
+ * 统一管理 tool-call / tool-result 配对验证
+ *
+ * 解决的问题：
+ * - 消除 4 处重复的消息配对验证逻辑
+ * - 统一 tool-call 输入格式验证
+ * - 减少消息数组多次遍历
+ */
+
+const { logger } = require('./logger');
+
+/**
+ * 收集所有 assistant 消息中的 tool-call ID
+ * @param {Array} messages - 消息数组
+ * @returns {Set<string>} tool-call ID 集合
+ */
+function collectToolCallIds(messages) {
+  const ids = new Set();
+  for (const msg of messages) {
+    if (msg.role !== 'assistant') continue;
+
+    // 格式1: msg.content 数组中的 tool-call 块 (AI SDK 格式)
+    if (Array.isArray(msg.content)) {
+      for (const item of msg.content) {
+        if ((item.type === 'tool-call' || item.type === 'tool-use') && item.toolCallId) {
+          ids.add(item.toolCallId);
+        }
+      }
+    }
+
+    // 格式2: msg.tool_calls 数组 (OpenAI 兼容格式)
+    if (Array.isArray(msg.tool_calls)) {
+      for (const tc of msg.tool_calls) {
+        if (tc.id) ids.add(tc.id);
+      }
+    }
+  }
+  return ids;
+}
+
+/**
+ * 验证消息配对 — 移除 orphaned tool-result（没有对应 tool-call 的）
+ * @param {Array} messages - 消息数组（会被修改）
+ * @param {Object} [options]
+ * @param {boolean} [options.log=true] - 是否记录日志
+ * @returns {Array} 过滤后的消息数组
+ */
+function validateMessagesPairing(messages, options = {}) {
+  const { log: shouldLog = true } = options;
+  const validToolCallIds = collectToolCallIds(messages);
+
+  let removedToolResultCount = 0;
+
+  for (const msg of messages) {
+    if (msg.role !== 'tool' || !Array.isArray(msg.content)) continue;
+
+    const originalLength = msg.content.length;
+    msg.content = msg.content.filter((item) => {
+      if (
+        item &&
+        (item.type === 'tool-result' || item.type === 'tool_result') &&
+        item.toolCallId &&
+        !validToolCallIds.has(item.toolCallId)
+      ) {
+        removedToolResultCount++;
+        return false;
+      }
+      return true;
+    });
+
+    // content 全被删除了，标记整个消息待删除
+    if (msg.content.length === 0 && originalLength > 0) {
+      msg._orphaned = true;
+    }
+  }
+
+  const originalLen = messages.length;
+  const filtered = messages.filter((msg) => !(msg.role === 'tool' && msg._orphaned));
+
+  if (shouldLog && (removedToolResultCount > 0 || filtered.length !== originalLen)) {
+    logger.debug(
+      `[validateMessagesPairing] removed ${removedToolResultCount} orphaned tool-results,` +
+        ` ${originalLen - filtered.length} orphaned tool messages`
+    );
+  }
+
+  return filtered;
+}
+
+/**
+ * 验证 tool-call 格式 — 修复不完整的 JSON 输入
+ * @param {Array} messages - 消息数组（会被修改）
+ * @param {Object} [options]
+ * @param {boolean} [options.log=true] - 是否记录日志
+ * @returns {number} 修复/移除的数量
+ */
+function validateToolCalls(messages, options = {}) {
+  const { log: shouldLog = true } = options;
+  let fixedCount = 0;
+  const invalidatedToolCallIds = new Set();
+
+  for (const msg of messages) {
+    if (msg.role !== 'assistant' || !Array.isArray(msg.content)) continue;
+
+    for (const item of msg.content) {
+      if (item.type !== 'tool-call' && item.type !== 'tool-use') continue;
+
+      const input = item.input;
+      if (typeof input !== 'string') continue;
+
+      const trimmed = input.trim();
+      if (trimmed === '{' || trimmed === '' || !trimmed.startsWith('{')) {
+        if (item.toolCallId) {
+          invalidatedToolCallIds.add(item.toolCallId);
+        }
+        if (shouldLog) {
+          logger.warn(
+            `[validateToolCalls] invalid input for "${item.toolName}", toolCallId=${item.toolCallId ||
+              '?'}, converting to text`
+          );
+        }
+        // 把无效的 tool-call 转换成 text 文本
+        item.type = 'text';
+        item.text = `（工具调用 ${item.toolName} 参数不完整，已跳过）`;
+        delete item.toolCallId;
+        delete item.toolName;
+        delete item.input;
+        fixedCount++;
+      }
+    }
+  }
+
+  // 清理引用了无效 toolCallId 的 tool-result
+  if (invalidatedToolCallIds.size > 0) {
+    for (const msg of messages) {
+      if (msg.role !== 'tool' || !Array.isArray(msg.content)) continue;
+
+      msg.content = msg.content.filter((item) => {
+        if (
+          item &&
+          (item.type === 'tool-result' || item.type === 'tool_result') &&
+          item.toolCallId &&
+          invalidatedToolCallIds.has(item.toolCallId)
+        ) {
+          fixedCount++;
+          return false;
+        }
+        return true;
+      });
+    }
+  }
+
+  if (shouldLog && fixedCount > 0) {
+    logger.info(`[validateToolCalls] Fixed ${fixedCount} incomplete tool calls/results`);
+  }
+
+  return fixedCount;
+}
+
+/**
+ * 一次遍历完成配对验证 + tool-call 格式验证
+ * 相比分别调用减少消息数组迭代次数
+ * @param {Array} messages - 消息数组（会被修改）
+ * @returns {Array} 过滤后的消息数组
+ */
+function validateAll(messages) {
+  // 1. 先修复 tool-call 格式（避免无效 ID 干扰后续配对验证）
+  validateToolCalls(messages);
+  // 2. 再移除 orphaned tool-result
+  return validateMessagesPairing(messages);
+}
+
+/**
+ * 过滤消息，保留配对的 tool-call → tool-result 链条
+ * 用于上下文压缩后保留完整的工具调用链路
+ * @param {Array} messages - 消息数组
+ * @param {number} [keepRecentAssistant=3] - 保留最近几条无工具调用的 assistant 消息
+ * @returns {Array} 过滤后的消息数组
+ */
+function filterPairedMessages(messages, keepRecentAssistant = 3) {
+  // 第一遍：收集所有 tool-call 及对应的 result
+  const assistantToolCalls = new Map(); // toolCallId → assistant index
+  const toolResults = new Map(); // toolCallId → [result indices]
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role === 'assistant') {
+      const content = Array.isArray(msg.content) ? msg.content : [msg.content];
+      for (const item of content) {
+        if ((item.type === 'tool-call' || item.type === 'tool-use') && item.toolCallId) {
+          assistantToolCalls.set(item.toolCallId, i);
+        }
+      }
+      if (Array.isArray(msg.tool_calls)) {
+        for (const tc of msg.tool_calls) {
+          if (tc.id) assistantToolCalls.set(tc.id, i);
+        }
+      }
+    }
+    if (msg.role === 'tool' && Array.isArray(msg.content)) {
+      for (const item of msg.content) {
+        if ((item.type === 'tool-result' || item.type === 'tool_result') && item.toolCallId) {
+          if (!toolResults.has(item.toolCallId)) {
+            toolResults.set(item.toolCallId, []);
+          }
+          toolResults.get(item.toolCallId).push(i);
+        }
+      }
+    }
+  }
+
+  // 第二遍：决定哪些 assistant 消息需要保留
+  const assistantIndicesToKeep = new Set();
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role !== 'assistant') continue;
+
+    // 检查是否有 tool-call
+    let hasToolCall = false;
+    const content = Array.isArray(msg.content) ? msg.content : [msg.content];
+    for (const item of content) {
+      if (item.type === 'tool-call' || item.type === 'tool-use') {
+        hasToolCall = true;
+        break;
+      }
+    }
+    if (!hasToolCall && Array.isArray(msg.tool_calls)) {
+      hasToolCall = msg.tool_calls.some((tc) => tc.id);
+    }
+
+    if (hasToolCall) {
+      assistantIndicesToKeep.add(i);
+    } else if (i >= messages.length - keepRecentAssistant) {
+      // 保留最近几条非工具调用的 assistant 消息
+      assistantIndicesToKeep.add(i);
+    }
+  }
+
+  // 保存有 tool-call 但没有 result 的 assistant（防止切掉半截链条）
+  for (const [toolCallId, assistantIdx] of assistantToolCalls) {
+    if (!toolResults.has(toolCallId)) {
+      assistantIndicesToKeep.add(assistantIdx);
+    }
+  }
+
+  // 第三遍：决定哪些 tool-result 要保留（只保留有对应 assistant 的）
+  const indicesToKeep = new Set();
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role === 'tool') {
+      const content = Array.isArray(msg.content) ? msg.content : [msg.content];
+      const hasPairedAssistant = content.some(
+        (item) =>
+          (item.type === 'tool-result' || item.type === 'tool_result') &&
+          item.toolCallId &&
+          assistantToolCalls.has(item.toolCallId) &&
+          assistantIndicesToKeep.has(assistantToolCalls.get(item.toolCallId))
+      );
+      if (hasPairedAssistant) {
+        indicesToKeep.add(i);
+      }
+    } else if (msg.role === 'assistant') {
+      if (assistantIndicesToKeep.has(i)) {
+        indicesToKeep.add(i);
+      }
+    } else {
+      // user, system 等角色默认保留
+      indicesToKeep.add(i);
+    }
+  }
+
+  return Array.from(indicesToKeep)
+    .sort((a, b) => a - b)
+    .map((i) => messages[i]);
+}
+
+module.exports = {
+  validateMessagesPairing,
+  validateToolCalls,
+  validateAll,
+  filterPairedMessages,
+};

package/src/utils/retry.js

@@ -1,12 +1,42 @@
 /**
  * Foliko Retry Strategy - 重试策略系统
  * 提供多种重试策略，支持指数退避、抖动等
+ *
+ * 统一的重试入口，取代以下分散的重试逻辑：
+ * - ChatQueueManager.executeWithRetry() (utils/chat-queue.js)
+ * - Subagent.chat() 中的重试循环 (core/subagent.js)
+ * - utils/index.js 中的 retry() 函数
  */
 
 const { logger } = require('./logger');
 
 const log = logger.child('RetryStrategy');
 
+/**
+ * 网络错误码列表
+ */
+const NETWORK_ERROR_CODES = [
+  'ECONNREFUSED',
+  'ECONNRESET',
+  'ETIMEDOUT',
+  'ENOTFOUND',
+  'EAI_AGAIN',
+  'EPIPE',
+  'ERR_CONNECTION_REFUSED',
+  'ERR_CONNECTION_RESET',
+  'ERR_CONNECTION_TIMEOUT',
+];
+
+/**
+ * API 可重试的 HTTP 状态码
+ */
+const RETRYABLE_HTTP_CODES = [429, 500, 502, 503, 504];
+
+/**
+ * AI SDK 错误名称（可重试）
+ */
+const AI_RETRYABLE_ERRORS = ['AI_RetryError', 'RetryError', 'AI_APICallError'];
+
 /**
  * 重试策略配置
  * @typedef {Object} RetryConfig
@@ -63,16 +93,32 @@ const PRESETS = {
     factor: 1.5,
     jitter: 0.05,
   },
-  /** 空闲连接保活（适合长时间运行的连接检查） */
-  idle: {
+  /** AI API 重试（包含 AI SDK 特定错误判断） */
+  ai: {
     maxAttempts: 3,
-    baseDelay: 5000,
+    baseDelay: 2000,
     maxDelay: 15000,
-    factor: 1.5,
-    jitter: 0.1,
+    factor: 2,
+    jitter: 0.2,
+    shouldRetry: (error) => {
+      if (!error) return false;
+      const name = error.name || '';
+      if (AI_RETRYABLE_ERRORS.includes(name)) return true;
+      // 也检查标准网络错误
+      return isNetworkError(error);
+    },
+  },
+  /** API 调用重试（适合第三方API） */
+  api: {
+    maxAttempts: 4,
+    baseDelay: 500,
+    maxDelay: 8000,
+    factor: 2,
+    jitter: 0.15,
     shouldRetry: (error) => {
-      const networkCodes = ['ECONNREFUSED', 'ECONNRESET', 'ETIMEDOUT', 'ENOTFOUND'];
-      return error.code && networkCodes.includes(error.code);
+      const status = error.status || error.statusCode;
+      if (status && (status >= 500 || status === 429)) return true;
+      return isNetworkError(error);
     },
   },
   /** 数据库重试（适合数据库连接） */
@@ -104,19 +150,119 @@ const PRESETS = {
       return dbKeywords.some((k) => msg.includes(k));
     },
   },
-  /** API调用重试（适合第三方API） */
-  api: {
-    maxAttempts: 4,
-    baseDelay: 500,
-    maxDelay: 8000,
-    factor: 2,
-    jitter: 0.15,
-    shouldRetry: (error) => {
-      const status = error.status || error.statusCode;
-      if (status && (status >= 500 || status === 429)) return true;
-      const networkCodes = ['ECONNREFUSED', 'ECONNRESET', 'ETIMEDOUT', 'ENOTFOUND'];
-      if (error.code && networkCodes.includes(error.code)) return true;
-      return false;
-    },
-  },
+};
+
+/**
+ * 判断错误是否由网络/AI服务问题引起（统一入口）
+ * 替代 ChatQueueManager.isRetryableError() 和 Subagent 中的分类逻辑
+ * @param {Error} err
+ * @returns {boolean}
+ */
+function isNetworkError(err) {
+  if (!err) return false;
+
+  const code = err.code || err.status || err.statusCode;
+  const message = (err.message || '').toLowerCase();
+  const name = err.name || '';
+
+  // 检查网络错误码
+  if (code && NETWORK_ERROR_CODES.includes(code)) return true;
+
+  // 检查可重试 HTTP 状态码
+  if (typeof code === 'number' && RETRYABLE_HTTP_CODES.includes(code)) return true;
+
+  // 检查 AI SDK 重试错误
+  if (AI_RETRYABLE_ERRORS.includes(name)) return true;
+
+  // 检查消息关键词
+  const retryableKeywords = [
+    'timeout', 'network', 'econnrefused', 'econnreset', 'etimedout',
+    'enotfound', 'rate limit', '负载较高', '暂时不可用',
+    '429', '500', '502', '503', '504',
+  ];
+  return retryableKeywords.some((kw) => message.includes(kw));
+}
+
+/**
+ * 计算下次重试延迟（指数退避 + 随机抖动）
+ * @param {number} attempt - 当前尝试次数（从 1 开始）
+ * @param {RetryConfig} config - 重试配置
+ * @returns {number} 延迟毫秒数
+ */
+function calculateDelay(attempt, config = {}) {
+  const factor = config.factor || 2;
+  const baseDelay = config.baseDelay || 1000;
+  const maxDelay = config.maxDelay || 30000;
+  const jitter = config.jitter ?? 0.2;
+
+  // 指数退避: baseDelay * factor ^ (attempt - 1)
+  const exponentialDelay = baseDelay * Math.pow(factor, attempt - 1);
+
+  // 加上抖动: delay * (1 + random(-jitter, +jitter))
+  const jitterAmount = exponentialDelay * jitter * (Math.random() * 2 - 1);
+  const delay = Math.min(exponentialDelay + jitterAmount, maxDelay);
+
+  return Math.max(delay, 0);
+}
+
+/**
+ * 带重试策略的函数执行
+ * @param {Function} fn - 要执行的异步函数
+ * @param {RetryConfig} [config] - 重试配置（默认 standard）
+ * @returns {Promise<any>}
+ * @throws {Error} 所有重试耗尽后抛出最后一次错误
+ */
+async function withRetry(fn, config = {}) {
+  const merged = { ...PRESETS.standard, ...config };
+  const { maxAttempts, onRetry } = merged;
+
+  let lastError;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+
+      // 判断是否应重试
+      const shouldRetry = merged.shouldRetry || isNetworkError;
+      if (!shouldRetry(err)) {
+        throw err; // 不可重试的错误，立即抛出
+      }
+
+      if (attempt < maxAttempts) {
+        const delay = calculateDelay(attempt, merged);
+        if (onRetry) {
+          try { onRetry(err, attempt, delay); } catch { /* ignore */ }
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  }
+
+  throw lastError;
+}
+
+/**
+ * 装饰器：使函数可重试
+ * @param {RetryConfig} [config]
+ * @returns {Function} 装饰后的函数
+ */
+function retryable(config = {}) {
+  return function (fn) {
+    return async (...args) => {
+      return withRetry(() => fn(...args), config);
+    };
+  };
+}
+
+module.exports = {
+  withRetry,
+  retryable,
+  isNetworkError,
+  calculateDelay,
+  PRESETS,
+  NETWORK_ERROR_CODES,
+  RETRYABLE_HTTP_CODES,
+  AI_RETRYABLE_ERRORS,
 };