foliko 1.0.87 → 1.1.1

package/src/utils/index.js

@@ -161,86 +161,104 @@ async function retry(fn, options = {}) {
   throw lastError;
 }
 
-function filterAndCleanMessages(messages) {
-  // 先配对
-  const pairedIds = new Set();
-  const toolCallToAssistant = new Map(); // toolCallId -> assistant index
+/**
+ * 安全序列化工具结果，移除循环引用
+ * 处理 Error 对象、函数等无法 JSON 序列化的内容
+ */
+function sanitizeForJSON(obj) {
+  if (obj === null || obj === undefined) {
+    return null;
+  }
 
-  // 收集所有 assistant 的 tool-call
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i];
-    if (msg.role === 'assistant' && msg.content) {
-      const content = Array.isArray(msg.content) ? msg.content : [msg.content];
-      for (const item of content) {
-        if (item.type === 'tool-call' && item.toolCallId) {
-          toolCallToAssistant.set(item.toolCallId, i);
-        }
-      }
-    }
+  if (typeof obj === 'string') {
+    return obj;
   }
 
-  // 找出配对的 tool result
-  for (const msg of messages) {
-    if (msg.role === 'tool' && msg.toolCallId) {
-      if (toolCallToAssistant.has(msg.toolCallId)) {
-        pairedIds.add(msg.toolCallId);
-      }
-    }
+  if (typeof obj === 'number' || typeof obj === 'boolean') {
+    return obj;
   }
 
-  // 过滤并清理消息
-  const cleaned = [];
-  for (const msg of messages) {
-    let shouldKeep = true;
-    let cleanedMsg = { ...msg };
+  if (obj instanceof Error) {
+    return `Error: ${obj.message}`;
+  }
 
-    if (msg.role === 'assistant' && msg.content) {
-      let content = Array.isArray(msg.content) ? msg.content : [msg.content];
+  if (typeof obj === 'function' || typeof obj === 'symbol') {
+    return '[Unserializable]';
+  }
 
-      // 过滤掉未配对的 tool-call
-      const filteredContent = content.filter((item) => {
-        if (item.type === 'tool-call') {
-          return pairedIds.has(item.toolCallId);
-        }
-        return true; // 保留 text 类型
-      });
+  if (Array.isArray(obj)) {
+    return obj.map((item) => sanitizeForJSON(item));
+  }
 
-      // 检查过滤后是否还有有效内容
-      if (filteredContent.length === 0) {
-        shouldKeep = false; // 丢弃空消息
-      } else {
-        cleanedMsg.content = filteredContent;
+  if (typeof obj === 'object') {
+    // 检测并处理循环引用
+    const seen = new WeakSet();
+    const result = {};
+
+    for (const [key, value] of Object.entries(obj)) {
+      if (value === obj) continue; // 跳过自身引用
+      if (seen.has(value)) {
+        result[key] = '[Circular]';
+        continue;
+      }
+      if (typeof value === 'object' && value !== null) {
+        seen.add(value);
+      }
+      try {
+        result[key] = sanitizeForJSON(value);
+      } catch (e) {
+        result[key] = '[Unserializable]';
       }
     }
+    return result;
+  }
 
-    if (msg.role === 'tool') {
-      shouldKeep = pairedIds.has(msg.toolCallId);
-    }
+  return String(obj);
+}
 
-    if (shouldKeep && cleanedMsg.content) {
-      // 确保 content 不为空
-      if (Array.isArray(cleanedMsg.content) && cleanedMsg.content.length > 0) {
-        cleaned.push(cleanedMsg);
-      } else if (typeof cleanedMsg.content === 'string' && cleanedMsg.content.trim()) {
-        cleaned.push(cleanedMsg);
-      } else if (
-        cleanedMsg.content &&
-        typeof cleanedMsg.content !== 'string' &&
-        !Array.isArray(cleanedMsg.content)
-      ) {
-        // 处理其他类型的 content
-        cleaned.push(cleanedMsg);
-      }
-      // 否则跳过空消息
-    }
+/**
+ * 清理工具结果内容，确保可安全序列化
+ */
+function sanitizeToolResult(result) {
+  if (result === null || result === undefined) {
+    return null;
+  }
+
+  // 如果已经是字符串，直接返回
+  if (typeof result === 'string') {
+    return result.substring(0, 50000); // 限制长度
+  }
+
+  // 如果是纯数据对象，直接序列化
+  if (typeof result === 'number' || typeof result === 'boolean') {
+    return result;
   }
 
-  return cleaned;
+  // 尝试安全序列化
+  try {
+    const sanitized = sanitizeForJSON(result);
+    const str = JSON.stringify(sanitized);
+    // 验证可以再次解析
+    JSON.parse(str);
+    return sanitized;
+  } catch (e) {
+    // 序列化失败，转换为字符串
+    return String(result).substring(0, 50000);
+  }
 }
 
 // 更激进的方法：确保所有消息都有有效的 content
-function validateAndFixMessages(messages) {
+// 接收 pairedIds 参数用于过滤未配对的 tool 消息
+function validateAndFixMessages(messages, pairedIds = null) {
   return messages.filter((msg) => {
+    // 如果提供了 pairedIds，检查 tool 消息是否配对
+    if (pairedIds && msg.role === 'tool' && msg.toolCallId) {
+      if (!pairedIds.has(msg.toolCallId)) {
+        console.log(`丢弃消息: role=tool, toolCallId=${msg.toolCallId} 未配对`);
+        return false;
+      }
+    }
+
     // 检查 content 是否存在且非空
     if (!msg.content) {
       console.log(`丢弃消息: role=${msg.role}, 无 content`);
@@ -286,11 +304,166 @@ function validateAndFixMessages(messages) {
 
 // 完整处理流程
 function prepareMessagesForAPI(rawMessages) {
-  // 1. 先配对
-  const paired = filterAndCleanMessages(rawMessages);
+  // 辅助函数：从消息中提取 toolCallId（兼容两种格式）
+  // 格式1: msg.toolCallId (旧格式)
+  // 格式2: msg.content[0].toolCallId (AI SDK CoreMessage 格式)
+  function extractToolCallId(msg) {
+    if (msg.toolCallId) return msg.toolCallId;
+    if (Array.isArray(msg.content) && msg.content.length > 0) {
+      const firstContent = msg.content[0];
+      if (firstContent && firstContent.toolCallId) return firstContent.toolCallId;
+    }
+    return null;
+  }
+
+  // 1. 先配对，收集配对的 toolCallId
+  const pairedIds = new Set();
+  const toolCallToAssistant = new Map();
+  const orphanedToolResults = []; // 用于调试：记录孤立的 tool results
+
+  // 收集所有 assistant 的 tool-call
+  for (let i = 0; i < rawMessages.length; i++) {
+    const msg = rawMessages[i];
+    if (msg.role === 'assistant' && msg.content) {
+      const content = Array.isArray(msg.content) ? msg.content : [msg.content];
+      for (const item of content) {
+        if (item.type === 'tool-call' && item.toolCallId) {
+          toolCallToAssistant.set(item.toolCallId, i);
+        }
+      }
+    }
+  }
+
+  // 找出配对的 tool result（兼容两种格式）
+  for (const msg of rawMessages) {
+    if (msg.role === 'tool') {
+      const toolCallId = extractToolCallId(msg);
+      if (toolCallId && toolCallToAssistant.has(toolCallId)) {
+        pairedIds.add(toolCallId);
+      } else if (toolCallId) {
+        // 记录孤立的 tool result（调试用）
+        orphanedToolResults.push({
+          toolCallId,
+          hasAssistantMessage: toolCallToAssistant.has(toolCallId),
+        });
+      }
+    }
+  }
+
+  // 调试：输出孤立 tool result 的信息（仅在有孤立结果时）
+  if (orphanedToolResults.length > 0 && pairedIds.size > 0) {
+    console.log(
+      `[prepareMessagesForAPI] Warning: ${orphanedToolResults.length} orphaned tool results detected:`
+    );
+    for (const orphan of orphanedToolResults) {
+      console.log(
+        `  - toolCallId=${orphan.toolCallId}, hasAssistantMessage=${orphan.hasAssistantMessage}`
+      );
+    }
+    console.log(`  Paired IDs: ${Array.from(pairedIds).join(', ')}`);
+    console.log(`  Assistant tool-call IDs: ${Array.from(toolCallToAssistant.keys()).join(', ')}`);
+  }
+
+  // 2. 过滤并清理空消息，同时过滤未配对的 tool 消息
+  const cleaned = [];
+  for (const msg of rawMessages) {
+    let shouldKeep = true;
+
+    if (msg.role === 'assistant' && msg.content) {
+      // 如果 content 是字符串（普通文本消息），保持不变
+      if (typeof msg.content === 'string') {
+        // 字符串内容不需要处理
+      } else if (Array.isArray(msg.content)) {
+        // content 是数组（包含 tool-call 等），进行过滤和清理
+        // 过滤：保留有 tool result 的 tool-call，保留 text 类型
+        const filteredContent = msg.content.filter((item) => {
+          if (item.type === 'tool-call') {
+            // 只保留有对应 tool result 的 tool call
+            return pairedIds.has(item.toolCallId);
+          }
+          return true; // 保留 text 类型
+        });
+
+        // 检查过滤后是否还有有效内容
+        if (filteredContent.length === 0) {
+          shouldKeep = false;
+        } else {
+          // 清理 tool-result 内容项（assistant 消息中不应该有 tool-result，但以防万一）
+          msg.content = filteredContent.map((item) => {
+            if (item && item.type === 'tool-result' && item.result !== undefined) {
+              return {
+                ...item,
+                result: sanitizeToolResult(item.result),
+              };
+            }
+            return item;
+          });
+        }
+      }
+    }
+
+    if (msg.role === 'tool') {
+      // 检查 tool message 是否有配对的 tool call
+      // 注意：一个 tool message 可能包含多个 tool-results，需要逐个检查
+      if (Array.isArray(msg.content)) {
+        // 过滤出有配对的 tool-results
+        const pairedResults = msg.content.filter((item) => {
+          if (item && item.type === 'tool-result' && item.toolCallId) {
+            return pairedIds.has(item.toolCallId);
+          }
+          // 保留非 tool-result 类型的内容（如 text）
+          return item && item.type !== 'tool-result';
+        });
+
+        // 检查是否有有效的 tool-results
+        const hasPairedResults = pairedResults.some(
+          (item) =>
+            item && item.type === 'tool-result' && item.toolCallId && pairedIds.has(item.toolCallId)
+        );
+
+        if (!hasPairedResults) {
+          // 所有 tool-results 都是orphaned，跳过整个消息
+          console.log(
+            `[prepareMessagesForAPI] Dropping tool message: all ${msg.content.length} tool-results are orphaned`
+          );
+          shouldKeep = false;
+        } else {
+          // 保留有配对的 tool-results，清理内容
+          msg.content = pairedResults.map((item) => {
+            if (item && item.type === 'tool-result' && item.result !== undefined) {
+              return {
+                ...item,
+                result: sanitizeToolResult(item.result),
+              };
+            }
+            return item;
+          });
+        }
+      } else {
+        // 非数组格式的 tool message（如旧格式）
+        const toolCallId = extractToolCallId(msg);
+        shouldKeep = toolCallId && pairedIds.has(toolCallId);
+        if (shouldKeep && msg.content) {
+          msg.content = sanitizeToolResult(msg.content);
+        }
+      }
+    }
 
-  // 2. 验证并清理空消息
-  const cleaned = validateAndFixMessages(paired);
+    // 验证 content 有效性
+    if (shouldKeep) {
+      if (!msg.content) {
+        shouldKeep = false;
+      } else if (Array.isArray(msg.content) && msg.content.length === 0) {
+        shouldKeep = false;
+      } else if (typeof msg.content === 'string' && !msg.content.trim()) {
+        shouldKeep = false;
+      }
+    }
+
+    if (shouldKeep) {
+      cleaned.push(msg);
+    }
+  }
 
   // 3. 确保消息交替顺序正确（user/assistant/tool）
   const finalMessages = [];
@@ -299,7 +472,6 @@ function prepareMessagesForAPI(rawMessages) {
   for (const msg of cleaned) {
     // 跳过连续的相同角色消息（除了 tool）
     if (msg.role === lastRole && msg.role !== 'tool') {
-      // 静默跳过，不打印日志
       continue;
     }
 

package/src/utils/plugin-helpers.js

@@ -65,10 +65,27 @@ function scanPluginNames(pluginsDir) {
     return [];
   }
 
+  // 忽略的目录/文件（无意义或系统文件）
+  const IGNORE_PATTERNS = new Set([
+    '__pycache__',
+    'node_modules',
+    '.git',
+    '.svn',
+    '.hg',
+    '__MACOSX',
+    '.DS_Store',
+    'Thumbs.db',
+  ]);
+
   const names = new Set();
   const entries = fs.readdirSync(pluginsDir, { withFileTypes: true });
 
   for (const entry of entries) {
+    // 跳过忽略列表中的条目
+    if (IGNORE_PATTERNS.has(entry.name)) {
+      continue;
+    }
+
     if (entry.isDirectory()) {
       // 文件夹插件
       names.add(entry.name);