foliko 1.1.63 → 1.1.64

package/src/core/subagent.js

@@ -8,8 +8,9 @@ const { EventEmitter } = require('../utils/event-emitter');
 const { cleanResponse } = require('../utils');
 const { generateText, tool, stepCountIs, isLoopFinished, RetryError, ToolLoopAgent } = require('ai');
 const { z } = require('zod');
-const fs=require('fs/promises')
 const { logger } = require('../utils/logger');
+const { validateAll } = require('../utils/message-validator');
+const { isNetworkError, calculateDelay } = require('../utils/retry');
 
 class Subagent extends EventEmitter {
   /**
@@ -94,64 +95,7 @@ class Subagent extends EventEmitter {
    * @private
    */
   _validateMessagesPairing(messages) {
-    // 收集所有 assistant 的 tool-call IDs
-    const assistantToolCallIds = new Set();
-    for (const msg of messages) {
-      if (msg.role === 'assistant') {
-        // 格式1: msg.content 中的 tool-call 块
-        if (Array.isArray(msg.content)) {
-          for (const item of msg.content) {
-            if ((item.type === 'tool-call' || item.type === 'tool-use') && item.toolCallId) {
-              assistantToolCallIds.add(item.toolCallId);
-            }
-          }
-        }
-        // 格式2: msg.tool_calls 数组 (OpenAI 格式)
-        if (Array.isArray(msg.tool_calls)) {
-          for (const tc of msg.tool_calls) {
-            if (tc.id) {
-              assistantToolCallIds.add(tc.id);
-            }
-          }
-        }
-      }
-    }
-
-    // 检查并删除没有配对的 tool result
-    let removedCount = 0;
-    for (const msg of messages) {
-      if (msg.role === 'tool' && Array.isArray(msg.content)) {
-        const originalLength = msg.content.length;
-        msg.content = msg.content.filter((item) => {
-          if (
-            item &&
-            (item.type === 'tool-result' || item.type === 'tool_result') &&
-            item.toolCallId
-          ) {
-            if (!assistantToolCallIds.has(item.toolCallId)) {
-              removedCount++;
-              return false;
-            }
-          }
-          return true;
-        });
-
-        if (msg.content.length === 0 && originalLength > 0) {
-          msg._orphaned = true;
-        }
-      }
-    }
-
-    const originalLength = messages.length;
-    const filtered = messages.filter((msg) => !(msg.role === 'tool' && msg._orphaned));
-
-    if (removedCount > 0 || filtered.length !== originalLength) {
-      logger.debug(
-        `[Subagent:${this.name}] _validateMessagesPairing: removed ${removedCount} orphaned tool-results, ${originalLength - filtered.length} orphaned tool messages`
-      );
-    }
-
-    return filtered;
+    return validateAll(messages);
   }
 
   /**
@@ -159,64 +103,8 @@ class Subagent extends EventEmitter {
    * @private
    */
   _validateToolCalls(messages) {
-    let fixedCount = 0;
-    const invalidatedToolCallIds = new Set();
-
-    for (const msg of messages) {
-      if (msg.role === 'assistant' && Array.isArray(msg.content)) {
-        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);
-            }
-            logger.warn(
-              `[Subagent:${this.name}] _validateToolCalls: invalid tool-call input="${input}", toolCallId=${item.toolCallId}`
-            );
-            item.type = 'text';
-            item.text = `（工具调用 ${item.toolName} 参数不完整，已跳过）`;
-            delete item.toolCallId;
-            delete item.toolName;
-            delete item.input;
-            fixedCount++;
-          }
-        }
-      }
-    }
-
-    if (invalidatedToolCallIds.size > 0) {
-      for (const msg of messages) {
-        if (msg.role === 'tool' && Array.isArray(msg.content)) {
-          const oldLen = msg.content.length;
-          msg.content = msg.content.filter((item) => {
-            if (item.type !== 'tool-result' && item.type !== 'tool_result') {
-              return true;
-            }
-            if (item.toolCallId && invalidatedToolCallIds.has(item.toolCallId)) {
-              logger.warn(
-                `[Subagent:${this.name}] _validateToolCalls: removing orphaned tool-result with toolCallId=${item.toolCallId}`
-              );
-              fixedCount++;
-              return false;
-            }
-            return true;
-          });
-        }
-      }
-    }
-
-    if (fixedCount > 0) {
-      logger.info(`[Subagent:${this.name}] _validateToolCalls: Fixed ${fixedCount} incomplete tool calls/results`);
-    }
+    // validateAll 内部已包含 validateMessagesPairing + validateToolCalls
+    // Subagent 的 chat() 中 _validateMessagesPairing 已调用 validateAll，所以这里不再重复
   }
 
   /**
@@ -327,8 +215,9 @@ class Subagent extends EventEmitter {
     }
 
     // 2. 主Agent的系统提示词
-    if (this.framework && this.framework._mainAgent) {
-      const mainPrompt = this.framework._mainAgent._originalPrompt;
+    const mainAgent = this.framework?.getMainAgent?.();
+    if (mainAgent) {
+      const mainPrompt = mainAgent.getOriginalPrompt();
       if (mainPrompt) {
         lines.push('## 主Agent的系统提示词');
         lines.push(mainPrompt);
@@ -472,18 +361,8 @@ class Subagent extends EventEmitter {
       } catch (err) {
         logger.warn(`[Subagent:${this.name}] generateText error: ${err.message}`);
         lastError = err;
-        const errName = err?.name || '';
-        const errMessage = err?.message || '';
-        const errCode = err?.code || err?.status;
-
-        // 判断是否是重试错误
-        const isRetryError =
-          RetryError.isInstance?.(err) ||
-          errName === 'AI_RetryError' ||
-          errName === 'RetryError' ||
-          err?.reason === 'maxRetriesExceeded';
-
-        if (isRetryError && attempt < maxRetries) {
+          // 统一使用 retry.js 的错误判断
+        if (isNetworkError(err) && attempt < maxRetries) {
           logger.warn(
             `[Subagent:${this.name}] AI 服务暂时不可用，正在重试 (${attempt + 1}/${maxRetries})`
           );
@@ -511,11 +390,13 @@ class Subagent extends EventEmitter {
    */
   _getFriendlyError(err) {
     const errName = err?.name || '';
+
+    // 先用 isNetworkError 统一判断
+    if (isNetworkError(err)) {
+      return 'AI 服务暂时不可用，请稍后重试';
+    }
+
     const errorMessages = {
-      AI_RetryError: 'AI 服务暂时不可用，请稍后重试',
-      AI_APICallError: err?.isRetryable
-        ? 'AI 服务暂时不可用，请稍后重试'
-        : err.message?.split('\n')[0] || 'AI 请求失败',
       AI_NoContentGeneratedError: 'AI 未生成有效内容，请重试',
       AI_NoSuchModelError: '指定的 AI 模型不存在',
       AI_NoSuchProviderError: 'AI 提供商配置错误',

package/src/core/tool-executor.js

@@ -9,6 +9,7 @@
 
 const { EventEmitter } = require('../utils/event-emitter');
 const { logger } = require('../utils/logger');
+const { validateToolCalls } = require('../utils/message-validator');
 
 class ToolExecutor extends EventEmitter {
   /**
@@ -183,76 +184,7 @@ class ToolExecutor extends EventEmitter {
    * @returns {Array} 验证后的消息
    */
   validateToolCalls(messages) {
-    let fixedCount = 0;
-    // 收集被跳过的 toolCallId，用于清理对应的 tool-result
-    const invalidatedToolCallIds = new Set();
-
-    for (const msg of messages) {
-      // 清理 assistant 消息中的不完整 tool-call
-      if (msg.role === 'assistant' && Array.isArray(msg.content)) {
-        for (const item of msg.content) {
-          // 兼容 tool-call 和 tool-use 两种类型
-          if (item.type !== 'tool-call' && item.type !== 'tool-use') {
-            continue;
-          }
-
-          const input = item.input;
-          if (typeof input !== 'string') {
-            continue;
-          }
-
-          // 检查 input 是否是有效的 JSON（不是不完整的）
-          const trimmed = input.trim();
-          if (trimmed === '{' || trimmed === '' || !trimmed.startsWith('{')) {
-            // 不完整的 JSON，移除这个 tool-call
-            // 记录 toolCallId，以便后续清理对应的 tool-result
-            if (item.toolCallId) {
-              invalidatedToolCallIds.add(item.toolCallId);
-            }
-            logger.warn(
-              `_validateToolCalls: invalid tool-call input="${input}", toolCallId=${item.toolCallId}, converting to text`
-            );
-            item.type = 'text';
-            item.text = `（工具调用 ${item.toolName} 参数不完整，已跳过）`;
-            delete item.toolCallId;
-            delete item.toolName;
-            delete item.input;
-            fixedCount++;
-          }
-        }
-      }
-    }
-
-    // 如果有无效的 tool-call，清理对应的 tool-result
-    if (invalidatedToolCallIds.size > 0) {
-      logger.warn(
-        `_validateToolCalls: removing ${invalidatedToolCallIds.size} tool-results with invalidated toolCallIds`
-      );
-      for (const msg of messages) {
-        if (msg.role === 'tool' && Array.isArray(msg.content)) {
-          // 过滤掉引用了无效 toolCallId 的 tool-result
-          const oldLen = msg.content.length;
-          msg.content = msg.content.filter((item) => {
-            if (item.type !== 'tool-result' && item.type !== 'tool_result') {
-              return true;
-            }
-            // 如果 tool-result 引用的 toolCallId 已被标记为无效，则移除
-            if (item.toolCallId && invalidatedToolCallIds.has(item.toolCallId)) {
-              logger.warn(
-                `_validateToolCalls: removing orphaned tool-result with toolCallId=${item.toolCallId}`
-              );
-              fixedCount++;
-              return false;
-            }
-            return true;
-          });
-        }
-      }
-    }
-
-    if (fixedCount > 0) {
-      logger.info(`_validateToolCalls: Fixed ${fixedCount} incomplete tool calls/results`);
-    }
+    return validateToolCalls(messages);
   }
 
   /**

package/src/executors/mcp-executor.js

@@ -610,7 +610,7 @@ class MCPExecutorPlugin extends Plugin {
    */
   _refreshAgentMCPPrompt(agent) {
     // 检查是否已刷新过（通过检查系统提示词是否已包含 MCP 描述）
-    const existingPrompt = agent._originalPrompt || '';
+    const existingPrompt = (typeof agent.getOriginalPrompt === 'function' ? agent.getOriginalPrompt() : agent._originalPrompt) || '';
     if (existingPrompt.includes('【MCP Servers】')) {
       return;
     }

package/src/utils/chat-queue.js

@@ -1,6 +1,7 @@
 const { EventEmitter } = require('./event-emitter');
 const { cleanResponse } = require('./index');
 const { logger } = require('./logger');
+const { isNetworkError, calculateDelay, PRESETS } = require('./retry');
 const log = logger.child('ChatQueue');
 // ChatQueueManager.js
 class ChatQueueManager extends EventEmitter {
@@ -118,10 +119,9 @@ class ChatQueueManager extends EventEmitter {
         if (result.error) {
           lastError = result.error;
           if (attempt < this.retryAttempts && this.isRetryableError(lastError)) {
-            await this.sleep(this.retryDelay * Math.pow(2, attempt - 1));
+            await this.sleep(calculateDelay(attempt, { baseDelay: this.retryDelay }));
             continue;
           }
-          // 重试耗尽，直接抛出 result.error
           throw lastError;
         }
 
@@ -130,7 +130,7 @@ class ChatQueueManager extends EventEmitter {
         log.warn('[ChatQueue] executeWithRetry: ', attempt, 'error:', error.message);
         lastError = error;
         if (attempt < this.retryAttempts && this.isRetryableError(error)) {
-          await this.sleep(this.retryDelay * Math.pow(2, attempt - 1));
+          await this.sleep(calculateDelay(attempt, { baseDelay: this.retryDelay }));
           continue;
         }
         break;
@@ -138,9 +138,7 @@ class ChatQueueManager extends EventEmitter {
     }
 
     // 将最后的错误转换为友好消息
-    const errName = lastError?.name || '';
-    const isRetryError = errName === 'AI_RetryError' || errName === 'RetryError';
-    const friendlyMessage = isRetryError
+    const friendlyMessage = isNetworkError(lastError)
       ? 'AI 服务暂时不可用，请稍后重试'
       : (lastError?.message || String(lastError)).split('\n')[0];
 
@@ -175,9 +173,7 @@ class ChatQueueManager extends EventEmitter {
     } catch (err) {
       // SDK 直接抛出错误（没有通过 chunk 传递）
       // 转换为友好错误消息
-      const errName = err?.name || '';
-      const isRetryError = errName === 'AI_RetryError' || errName === 'RetryError';
-      const friendlyMessage = isRetryError
+      const friendlyMessage = isNetworkError(err)
         ? 'AI 服务暂时不可用，请稍后重试'
         : (err.message || err.toString()).split('\n')[0];
 
@@ -225,20 +221,13 @@ class ChatQueueManager extends EventEmitter {
   /**
    * 判断错误是否可重试
    */
+  /**
+   * 判断错误是否可重试（委托给统一入口）
+   * @param {Error} error
+   * @returns {boolean}
+   */
   isRetryableError(error) {
-    const message = error.message || String(error);
-    return (
-      message.includes('负载较高') ||
-      message.includes('timeout') ||
-      message.includes('network') ||
-      message.includes('429') ||
-      message.includes('500') ||
-      message.includes('502') ||
-      message.includes('503') ||
-      message.includes('rate limit') ||
-      error.name === 'AI_RetryError' ||
-      error.name === 'AI_APICallError'
-    );
+    return isNetworkError(error);
   }
 
   /**

package/src/utils/download.js

@@ -6,6 +6,7 @@ const path = require('path');
 const crypto = require('crypto');
 const { fileTypeFromFile, fileTypeFromBuffer } = require('file-type');
 const { downloadAndDecryptMedia } = require('@chnak/weixin-bot');
+const { logger } = require('./logger');
 class FileDownloader {
   constructor(options = {}) {
     this.timeout = options.timeout || 30000;
@@ -318,7 +319,7 @@ class FileDownloader {
         });
       } catch (error) {
         lastError = error;
-        console.log(`下载失败，第 ${i + 1}/${retries} 次重试...`);
+        logger.warn(`[Download] 失败，第 ${i + 1}/${retries} 次重试...`);
         await this._sleep(1000 * (i + 1));
       }
     }
@@ -432,8 +433,8 @@ class FileDownloader {
 
           // 获取 Content-Type
           const contentType = response.headers['content-type'] || '';
-          console.log(`[Download] URL: ${url}`);
-          console.log(`[Download] Content-Type: ${contentType}`);
+          logger.debug(`[Download] URL: ${url}`);
+          logger.debug(`[Download] Content-Type: ${contentType}`);
 
           // 提取文件信息
           const { filename: autoFilename, extension } = this._extractFileInfo(
@@ -484,7 +485,7 @@ class FileDownloader {
           });
 
           req.on('error', (err) => {
-            console.log('下载请求错误:', err.message);
+            logger.error(`[Download] 请求错误: ${err.message}`);
             reject(err);
           });
 

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,
+};