foliko 2.0.10 → 2.0.12

package/src/utils/message-validator.js

@@ -114,17 +114,21 @@ function validateToolCalls(messages, options = {}) {
       if (typeof input !== 'string') continue;
 
       const trimmed = input.trim();
-      if (trimmed === '{' || trimmed === '' || !trimmed.startsWith('{')) {
-        if (item.toolCallId) {
-          invalidatedToolCallIds.add(item.toolCallId);
-        }
+      // 只有真正无法解析为 JSON 的才标记为 invalid
+      let invalid = false;
+      if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
+        try { JSON.parse(trimmed); } catch { invalid = true; }
+      } else if (trimmed !== '') {
+        invalid = true;
+      }
+
+      if (invalid) {
+        if (item.toolCallId) invalidatedToolCallIds.add(item.toolCallId);
         if (shouldLog) {
           logger.warn(
-            `[validateToolCalls] invalid input for "${item.toolName}", toolCallId=${item.toolCallId ||
-              '?'}, converting to text`
+            `[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;
@@ -155,43 +159,148 @@ function validateToolCalls(messages, options = {}) {
     }
   }
 
-  if (shouldLog && fixedCount > 0) {
-    // logger.info(`[validateToolCalls] Fixed ${fixedCount} incomplete tool calls/results`);
-  }
+  if (shouldLog && fixedCount > 0) {}
 
   return fixedCount;
 }
 
 /**
- * 一次遍历完成配对验证 + tool-call 格式验证
- * 相比分别调用减少消息数组迭代次数
+ * 单次遍历完成所有验证和规范化：
+ * 1. 修复 tool-call 格式（不完整 JSON → text）
+ * 2. 收集有效 toolCallId（content[] 和 tool_calls[]）
+ * 3. 规范化 error-text/error-json → text/json
+ * 4. 移除 orphaned tool-result（没有对应 tool-call 的）
+ * 5. 移除整个 orphaned tool 消息（content 被清空的）
+ *
+ * 比分别调用减少 3-4 次消息数组遍历
  * @param {Array} messages - 消息数组（会被修改）
  * @returns {Array} 过滤后的消息数组
  */
 function validateAll(messages) {
-  // 1. 先修复 tool-call 格式（避免无效 ID 干扰后续配对验证）
-  validateToolCalls(messages);
-  // 2. 再移除 orphaned tool-result
-  return validateMessagesPairing(messages);
+  const VALID_OUTPUT_TYPES = new Set(['text', 'json', 'execution-denied', 'content']);
+  const validToolCallIds = new Set();
+  const invalidatedIds = new Set();
+
+  // 第一遍：收集有效 ID + 修复格式 + 规范化 error 类型
+  for (const msg of messages) {
+    if (msg.role === 'assistant') {
+      const content = msg.content;
+      if (Array.isArray(content)) {
+        for (const item of content) {
+          if (item && (item.type === 'tool-call' || item.type === 'tool-use')) {
+            const input = item.input;
+            // 检查 input 是否为不完整的 JSON：空字符串、或只有 { 或 }
+            // 有效 input 应能被 JSON.parse（即使是 {}）
+            let invalid = false;
+            if (typeof input === 'string') {
+              const trimmed = input.trim();
+              // 有效 input：能解析为 JSON 的字符串（包括 '{}'）
+              if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
+                try { JSON.parse(trimmed); } catch { invalid = true; }
+              } else if (trimmed !== '') {
+                // 非空且不是 {} 开头：无效
+                invalid = true;
+              }
+              // 空字符串 '' 单独放过（无参数工具是合法的）
+            } else if (input === undefined || input === null) {
+              // input 为 null/undefined 时：只有当工具 schema 要求必填时才应该报错
+              // 但我们无法在此判断工具是否必填，统一放行让后续验证处理
+              // invalid = true;
+            }
+            if (invalid) {
+              logger.debug(`[validateAll] INVALID detected: toolName=${item.toolName}, input=${JSON.stringify(input)}, typeof=${typeof input}`);
+              // 无效输入 → 转 text，标记为 invalid
+              item.type = 'text';
+              item.text = `（工具调用 ${item.toolName} 参数不完整，已跳过）`;
+              if (item.toolCallId) invalidatedIds.add(item.toolCallId);
+              delete item.toolCallId;
+              delete item.toolName;
+              delete item.input;
+            } else if (item.toolCallId) {
+              validToolCallIds.add(item.toolCallId);
+            }
+          } else if (item && item.type === 'tool-result') {
+            // 规范化 tool-result output
+            const out = item.output;
+            if (out === undefined || out === null || typeof out !== 'object') {
+              item.output = { type: 'text', value: String(out ?? 'undefined') };
+            } else if (!VALID_OUTPUT_TYPES.has(out.type)) {
+              if (out.type === 'error-text' || out.type === 'error_text') {
+                item.output = { type: 'text', value: typeof out.value === 'string' ? out.value : String(out.value ?? '') };
+              } else if (out.type === 'error-json' || out.type === 'error_json') {
+                item.output = { type: 'json', value: out.value ?? null };
+              } else {
+                try { item.output = { type: 'text', value: JSON.stringify(out) }; }
+                catch { item.output = { type: 'text', value: String(out) }; }
+              }
+            }
+          }
+        }
+      }
+      // tool_calls[] 格式（OpenAI 兼容）
+      if (Array.isArray(msg.tool_calls)) {
+        for (const tc of msg.tool_calls) {
+          if (tc.id && !invalidatedIds.has(tc.id)) validToolCallIds.add(tc.id);
+        }
+      }
+    } else if (msg.role === 'tool') {
+      // 规范化 tool 消息 output
+      if (Array.isArray(msg.content)) {
+        for (const item of msg.content) {
+          if (item && item.type === 'tool-result') {
+            const out = item.output;
+            if (out === undefined || out === null || typeof out !== 'object') {
+              item.output = { type: 'text', value: String(out ?? 'undefined') };
+            } else if (!VALID_OUTPUT_TYPES.has(out.type)) {
+              if (out.type === 'error-text' || out.type === 'error_text') {
+                item.output = { type: 'text', value: typeof out.value === 'string' ? out.value : String(out.value ?? '') };
+              } else if (out.type === 'error-json' || out.type === 'error_json') {
+                item.output = { type: 'json', value: out.value ?? null };
+              } else {
+                try { item.output = { type: 'text', value: JSON.stringify(out) }; }
+                catch { item.output = { type: 'text', value: String(out) }; }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // 第二遍：过滤 orphaned tool-result + orphaned tool messages
+  const toolMessageIndicesToRemove = new Set();
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role !== 'tool') continue;
+
+    let hasValidResult = false;
+    if (Array.isArray(msg.content)) {
+      const originalLen = msg.content.length;
+      msg.content = msg.content.filter((item) => {
+        if (!item || (item.type !== 'tool-result' && item.type !== 'tool_result')) return true;
+        const id = item.toolCallId;
+        if (!id || (!validToolCallIds.has(id) && !invalidatedIds.has(id))) return false;
+        hasValidResult = true;
+        return true;
+      });
+      if (msg.content.length === 0 && originalLen > 0) {
+        toolMessageIndicesToRemove.add(i);
+      }
+    } else if (msg.tool_call_id && !validToolCallIds.has(msg.tool_call_id)) {
+      toolMessageIndicesToRemove.add(i);
+    }
+  }
+
+  if (toolMessageIndicesToRemove.size > 0) {
+    messages = messages.filter((_, i) => !toolMessageIndicesToRemove.has(i));
+  }
+
+  return messages;
 }
 
 // AI SDK v6 ToolResultOutput 允许的类型（用于 ModelMessage[] 输入 schema）
 const VALID_OUTPUT_TYPES = new Set(['text', 'json', 'execution-denied', 'content']);
 
-/**
- * 规范化 tool-result 的 output 字段。
- * AI SDK v6 响应中允许 'error-text' / 'error-json'（表示工具执行失败），
- * 但 ModelMessage 输入 schema 不接受这两类。需要在发送前 / 持久化前转换。
- *
- * 转换规则：
- * - error-text → text
- * - error-json → json
- * - 任何未知 type → text（保留 value 字段）
- * - output 缺失或非对象 → 包装为 text 'null'
- *
- * @param {Array} messages - 消息数组（会被修改）
- * @returns {number} 规范化次数
- */
 function normalizeToolOutputs(messages) {
   let fixed = 0;
   for (const msg of messages) {
@@ -232,6 +341,60 @@ function normalizeToolOutputs(messages) {
   return fixed;
 }
 
+/**
+ * 把 assistant 消息里"已不可用工具"的 tool-call 转成 text，
+ * 防止 LLM 在新会话里看到历史 tool-call 后重试不存在的工具。
+ *
+ * 典型场景：
+ * - 工作流文件被删除/改名后，chat log 里仍保留对该工作流的 tool-call
+ * - 插件被禁用后，chat log 里保留该插件工具的 tool-call
+ *
+ * 转换后的 text 形如 "（工具 xxx 已不可用，原 tool-call 已跳过）"，
+ * 紧接的 tool-result 如果是正常的成功结果会被保留；如果是失败结果
+ * （error-text 已 normalize 为 text），orphan 的 tool-result 会被
+ * `_stripOrphanedToolMessages` / `validateMessagesPairing` 自然清理。
+ *
+ * @param {Array} messages - 消息数组（会被修改）
+ * @param {Set<string>|Array<string>} availableToolNames - 当前可用的工具名集合
+ * @returns {number} 转换的 tool-call 数量
+ */
+function filterOrphanToolCalls(messages, availableToolNames) {
+  if (!Array.isArray(messages) || !availableToolNames) return 0;
+  const available = availableToolNames instanceof Set
+    ? availableToolNames
+    : new Set(availableToolNames);
+  let converted = 0;
+
+  for (const msg of messages) {
+    if (msg.role !== 'assistant' || !Array.isArray(msg.content)) continue;
+    // 收集本条消息中所有 tool-call ID，便于在转换后保留
+    const newContent = [];
+    for (const part of msg.content) {
+      if (!part || (part.type !== 'tool-call' && part.type !== 'tool-use')) {
+        newContent.push(part);
+        continue;
+      }
+      if (part.toolName && available.has(part.toolName)) {
+        newContent.push(part);
+        continue;
+      }
+      // tool 不可用 → 转成 text 提示
+      converted++;
+      const reason = part.toolName
+        ? `（工具 ${part.toolName} 当前不可用，原 tool-call 已跳过）`
+        : `（工具调用参数不完整，已跳过）`;
+      newContent.push({
+        type: 'text',
+        text: reason,
+      });
+      // 注意：原 part 的 toolCallId 不再出现在新 content 里，
+      // _stripOrphanedToolMessages 会把对应的 tool-result 视为 orphan 并清理
+    }
+    msg.content = newContent;
+  }
+  return converted;
+}
+
 /**
  * 过滤消息，保留配对的 tool-call → tool-result 链条
  * 用于上下文压缩后保留完整的工具调用链路
@@ -341,5 +504,6 @@ module.exports = {
   validateToolCalls,
   validateAll,
   normalizeToolOutputs,
+  filterOrphanToolCalls,
   filterPairedMessages,
 };