deepspider 0.3.1 → 0.4.0

package/src/agent/core/StreamHandler.js

@@ -1,8 +1,9 @@
 /**
  * DeepSpider - 流式输出处理器
- * 处理 Agent 的流式事件
+ * 处理 Agent 的流式事件，支持 interrupt HITL 交互
  */
 
+import { Command } from '@langchain/langgraph';
 import { isApiServiceError, isToolSchemaError } from '../errors/ErrorClassifier.js';
 import { RetryManager, sleep } from './RetryManager.js';
 
@@ -12,6 +13,31 @@ function cleanDSML(text) {
   return text ? text.replace(DSML_PATTERN, '') : text;
 }
 
+// 流式事件停滞超时（单个事件间隔上限）
+const STALL_TIMEOUT_MS = 150000; // 150s — 超过此时间无新事件则中断流
+
+/**
+ * 包装异步迭代器，每个 next() 加独立超时
+ * 防止 LLM API 或 middleware 无响应时 for-await 永久挂起
+ */
+async function* withStallTimeout(asyncIterator, timeoutMs = STALL_TIMEOUT_MS) {
+  while (true) {
+    let timer;
+    const result = await Promise.race([
+      asyncIterator.next(),
+      new Promise((_, reject) => {
+        timer = setTimeout(
+          () => reject(new Error(`Stream timeout: no events for ${Math.round(timeoutMs / 1000)}s`)),
+          timeoutMs,
+        );
+      }),
+    ]);
+    clearTimeout(timer);
+    if (result.done) break;
+    yield result.value;
+  }
+}
+
 // 人工介入配置
 const INTERVENTION_CONFIG = {
   idleTimeoutMs: 120000,  // 2分钟无响应触发提示
@@ -26,6 +52,7 @@ export class StreamHandler {
     this.riskTools = riskTools;
     this.debug = debug;
     this.retryManager = new RetryManager();
+    this.fullResponse = '';
   }
 
   /**
@@ -37,8 +64,8 @@ export class StreamHandler {
     let eventCount = 0;
     let lastToolCall = null;
 
-    // 重置面板状态
-    this.panelBridge.reset();
+    // 重置状态
+    this.fullResponse = '';
     await this.panelBridge.setBusy(true);
 
     this.debug(`chatStream: 开始处理, 输入长度=${input.length}`);
@@ -61,7 +88,7 @@ export class StreamHandler {
       );
 
       this.debug('chatStream: 开始遍历事件');
-      for await (const event of eventStream) {
+      for await (const event of withStallTimeout(eventStream)) {
         lastEventTime = Date.now();
         eventCount++;
 
@@ -71,10 +98,12 @@ export class StreamHandler {
 
         await this._handleStreamEvent(event);
 
-        if (event.event === 'on_chat_model_end' && event.name === 'ChatOpenAI') {
+        if (event.event === 'on_chat_model_end') {
           const output = event.data?.output;
           if (output?.content) {
-            finalResponse = output.content;
+            finalResponse = typeof output.content === 'string'
+              ? output.content
+              : output.content.filter(c => c.type === 'text').map(c => c.text).join('');
             this.debug(`chatStream: 收到最终响应, 长度=${finalResponse.length}`);
           }
         }
@@ -83,8 +112,17 @@ export class StreamHandler {
       clearInterval(heartbeat);
       console.log(`\n[完成] 共处理 ${eventCount} 个事件`);
 
-      await this.panelBridge.flushPanelText();
-      await this.panelBridge.finalizeMessage('assistant');
+      // 发送剩余累积文本
+      const flushed = await this._flushFullResponse();
+
+      // 检测 interrupt 并渲染到面板
+      const hasInterrupt = await this._checkAndRenderInterrupt();
+
+      // 兜底：如果没有文本输出也没有 interrupt，发送完成通知
+      if (!flushed && !hasInterrupt && eventCount > 0 && lastToolCall) {
+        await this.panelBridge.sendToPanel('system', '✅ 任务完成');
+      }
+
       await this.panelBridge.setBusy(false);
 
       this.debug(`chatStream: 完成, 响应长度=${finalResponse.length}`);
@@ -96,16 +134,97 @@ export class StreamHandler {
   }
 
   /**
-   * 从检查点恢复流式对话
+   * 用 Command({ resume }) 恢复被 interrupt 暂停的 graph
+   */
+  async resumeInterrupt(value) {
+    let finalResponse = '';
+    let lastEventTime = Date.now();
+    let eventCount = 0;
+
+    this.fullResponse = '';
+    await this.panelBridge.setBusy(true);
+    this.debug(`resumeInterrupt: 恢复 interrupt, value=${value}`);
+
+    const heartbeat = setInterval(() => {
+      const elapsed = Math.round((Date.now() - lastEventTime) / 1000);
+      if (elapsed > 30) {
+        console.log(`\n[心跳] 恢复中，已等待 ${elapsed}s`);
+      }
+    }, 30000);
+
+    try {
+      const eventStream = await this.agent.streamEvents(
+        new Command({ resume: value }),
+        { ...this.config, version: 'v2' }
+      );
+
+      for await (const event of withStallTimeout(eventStream)) {
+        lastEventTime = Date.now();
+        eventCount++;
+        await this._handleStreamEvent(event);
+
+        if (event.event === 'on_chat_model_end') {
+          const output = event.data?.output;
+          if (output?.content) {
+            finalResponse = typeof output.content === 'string'
+              ? output.content
+              : output.content.filter(c => c.type === 'text').map(c => c.text).join('');
+          }
+        }
+      }
+
+      clearInterval(heartbeat);
+
+      const flushed = await this._flushFullResponse();
+      const hasInterrupt = await this._checkAndRenderInterrupt();
+
+      // 兜底：如果没有文本输出也没有 interrupt，发送完成通知
+      if (!flushed && !hasInterrupt && eventCount > 0) {
+        await this.panelBridge.sendToPanel('system', '✅ 任务完成');
+      }
+
+      await this.panelBridge.setBusy(false);
+
+      console.log(`\n[恢复完成] 共处理 ${eventCount} 个事件`);
+      return finalResponse || '[无响应]';
+    } catch (error) {
+      clearInterval(heartbeat);
+      await this.panelBridge.setBusy(false);
+      const errMsg = error.message || String(error);
+      console.error(`\n[恢复失败] ${errMsg}`);
+      return `恢复失败: ${errMsg}`;
+    }
+  }
+
+  /**
+   * 从检查点恢复流式对话（错误重试用）
    */
   async chatStreamResume(retryCount = 0) {
     let finalResponse = '';
     let lastEventTime = Date.now();
     let eventCount = 0;
 
+    this.fullResponse = '';
     await this.panelBridge.setBusy(true);
     this.debug(`chatStreamResume: 从检查点恢复, retryCount=${retryCount}`);
 
+    // 恢复前：检查 checkpoint 是否有实际消息
+    if (retryCount === 0) {
+      try {
+        const state = await this.agent.getState(this.config);
+        const messages = state?.values?.messages;
+        if (!messages?.length) {
+          console.log('[恢复] checkpoint 无历史消息，跳过恢复');
+          await this.panelBridge.sendToPanel('system', '该会话无历史记录，请重新开始分析');
+          await this.panelBridge.setBusy(false);
+          return '[无历史消息]';
+        }
+        await this._restoreHistoryToPanel(messages);
+      } catch (e) {
+        this.debug('chatStreamResume: getState 失败:', e.message);
+      }
+    }
+
     const heartbeat = setInterval(() => {
       const elapsed = Math.round((Date.now() - lastEventTime) / 1000);
       if (elapsed > 30) {
@@ -119,22 +238,32 @@ export class StreamHandler {
         { ...this.config, version: 'v2' }
       );
 
-      for await (const event of eventStream) {
+      for await (const event of withStallTimeout(eventStream)) {
         lastEventTime = Date.now();
         eventCount++;
         await this._handleStreamEvent(event);
 
-        if (event.event === 'on_chat_model_end' && event.name === 'ChatOpenAI') {
+        if (event.event === 'on_chat_model_end') {
           const output = event.data?.output;
           if (output?.content) {
-            finalResponse = output.content;
+            finalResponse = typeof output.content === 'string'
+              ? output.content
+              : output.content.filter(c => c.type === 'text').map(c => c.text).join('');
           }
         }
       }
 
       clearInterval(heartbeat);
-      await this.panelBridge.flushPanelText();
+
+      const flushed2 = await this._flushFullResponse();
+      const hasInterrupt2 = await this._checkAndRenderInterrupt();
+
+      if (!flushed2 && !hasInterrupt2 && eventCount > 0) {
+        await this.panelBridge.sendToPanel('system', '✅ 任务完成');
+      }
+
       await this.panelBridge.setBusy(false);
+
       console.log(`\n[恢复完成] 共处理 ${eventCount} 个事件`);
       return finalResponse || '[无响应]';
     } catch (error) {
@@ -154,6 +283,97 @@ export class StreamHandler {
     }
   }
 
+  /**
+   * 从 checkpoint 恢复历史消息到前端面板
+   */
+  async _restoreHistoryToPanel(messages) {
+    try {
+      if (!messages?.length) return;
+      this.debug(`_restoreHistoryToPanel: ${messages.length} 条历史消息`);
+
+      const batch = [];
+      for (const msg of messages) {
+        const type = msg._getType?.() || msg.constructor?.name;
+        const content = Array.isArray(msg.content)
+          ? msg.content.filter(c => c.type === 'text').map(c => c.text).join('')
+          : (typeof msg.content === 'string' ? msg.content : '');
+        if (!content.trim()) continue;
+
+        if (type === 'human') {
+          batch.push({ type: 'user', data: { content } });
+        } else if (type === 'ai') {
+          batch.push({ type: 'text', data: { content } });
+        } else if (type === 'tool') {
+          const summary = content.length > 200 ? content.slice(0, 200) + '...' : content;
+          batch.push({ type: 'system', data: { content: `[工具结果] ${summary}` } });
+        }
+      }
+      await this.panelBridge.sendBatch(batch);
+    } catch (e) {
+      this.debug('_restoreHistoryToPanel 失败:', e.message);
+    }
+  }
+
+  /**
+   * 发送剩余累积文本到面板
+   * 返回 true 如果有文本被发送
+   */
+  async _flushFullResponse() {
+    if (this.fullResponse?.trim()) {
+      await this.panelBridge.sendToPanel('assistant', this.fullResponse);
+      this.fullResponse = '';
+      return true;
+    }
+    this.fullResponse = '';
+    return false;
+  }
+
+  /**
+   * 检测 graph interrupt 状态，将 interrupt payload 渲染为面板结构化消息
+   *
+   * interrupt payload 协议：
+   *   { type: 'choices', question, options: [{id, label, description?}] }
+   *   { type: 'confirm', question, confirmText?, cancelText? }
+   */
+  async _checkAndRenderInterrupt() {
+    try {
+      const state = await this.agent.getState(this.config);
+      this.debug(`_checkAndRenderInterrupt: state.next=${JSON.stringify(state?.next)}, tasks=${state?.tasks?.length ?? 'undefined'}`);
+
+      if (!state?.tasks) {
+        this.debug('_checkAndRenderInterrupt: state.tasks 为空，尝试检查 next');
+        // 某些 LangGraph 版本用 next 为空数组表示 interrupt
+        // 如果 next 不为空，说明 graph 正常结束，无 interrupt
+        return false;
+      }
+
+      let found = false;
+      for (const task of state.tasks) {
+        this.debug(`_checkAndRenderInterrupt: task id=${task.id}, interrupts=${task.interrupts?.length ?? 0}`);
+        if (!task.interrupts?.length) continue;
+        for (const intr of task.interrupts) {
+          const payload = intr.value;
+          this.debug(`_checkAndRenderInterrupt: interrupt payload=${JSON.stringify(payload)?.slice(0, 200)}`);
+          if (!payload?.type) continue;
+
+          console.log(`\n[交互] 等待用户 ${payload.type === 'choices' ? '选择' : '确认'}...`);
+
+          if (payload.type === 'choices' || payload.type === 'confirm') {
+            // 删除面板中 interrupt 工具调用前 LLM 输出的冗余描述文字
+            await this.panelBridge.removeLastAssistantMessage();
+            await this.panelBridge.sendMessage(payload.type, payload);
+            found = true;
+          }
+        }
+      }
+      return found;
+    } catch (e) {
+      this.debug('_checkAndRenderInterrupt 失败:', e.message);
+      console.log(`[DEBUG] _checkAndRenderInterrupt error: ${e.message}`);
+      return false;
+    }
+  }
+
   /**
    * 创建心跳检测定时器
    */
@@ -197,15 +417,20 @@ export class StreamHandler {
         let chunk = data?.chunk?.content;
         if (chunk && typeof chunk === 'string') {
           chunk = cleanDSML(chunk);
+          // CLI 侧仍流式输出
           process.stdout.write(chunk);
-          await this.panelBridge.appendToPanel(chunk);
+          // 面板侧只累积，不推送
+          this.fullResponse = (this.fullResponse || '') + chunk;
         }
         break;
 
       case 'on_tool_start':
-        this.debug('handleStreamEvent: 工具开始，先刷新缓冲区');
-        await this.panelBridge.flushPanelText();
-        this.panelBridge.hasStartedAssistantMsg = false;
+        // 工具调用前，先把已累积的 LLM 文字发送到面板
+        if (this.fullResponse?.trim()) {
+          await this.panelBridge.sendToPanel('assistant', this.fullResponse);
+          this.fullResponse = '';
+        }
+        this.debug('handleStreamEvent: 工具开始');
         const input = data?.input || {};
         const inputStr = typeof input === 'string' ? input : JSON.stringify(input);
         const preview = inputStr.length > 100 ? inputStr.slice(0, 100) + '...' : inputStr;
@@ -250,11 +475,10 @@ export class StreamHandler {
       }
 
       if (isToolSchemaError(errMsg)) {
-        console.log(`\n[重试 ${retryCount + 1}/${this.retryManager.maxRetries}] 工具参数错误，发送修正请求...`);
+        console.log(`\n[重试 ${retryCount + 1}/${this.retryManager.maxRetries}] 工具参数错误，从检查点恢复...`);
         await this.panelBridge.sendToPanel('system',
           `工具调用失败，正在修正 (${retryCount + 1}/${this.retryManager.maxRetries})`);
-        const resumeInput = `工具调用失败: ${errMsg}\n请检查参数格式并重试。`;
-        return this.chatStream(resumeInput, retryCount + 1);
+        return this.chatStreamResume(retryCount + 1);
       }
     }
 

package/src/agent/index.js

@@ -1,18 +1,29 @@
 /**
  * DeepSpider - DeepAgent 主入口
- * 基于 DeepAgents 最佳实践重构
+ * 使用 createAgent 手动组装 middleware 栈，替换 createDeepAgent
+ * 目的：用自定义 subagent middleware 支持 context 结构化传递
  */
 
 import 'dotenv/config';
-import { createDeepAgent, StateBackend, FilesystemBackend } from 'deepagents';
-import { ChatOpenAI } from '@langchain/openai';
-import { MemorySaver } from '@langchain/langgraph';
+import { StateBackend, FilesystemBackend, createFilesystemMiddleware, createPatchToolCallsMiddleware } from 'deepagents';
+import { createAgent, toolRetryMiddleware, summarizationMiddleware, anthropicPromptCachingMiddleware, todoListMiddleware, humanInTheLoopMiddleware } from 'langchain';
+import { ChatAnthropic } from '@langchain/anthropic';
+import { SqliteSaver } from '@langchain/langgraph-checkpoint-sqlite';
 
 import { coreTools } from './tools/index.js';
 import { allSubagents } from './subagents/index.js';
 import { systemPrompt } from './prompts/system.js';
 import { createReportMiddleware } from './middleware/report.js';
 import { createFilterToolsMiddleware } from './middleware/filterTools.js';
+import { createCustomSubAgentMiddleware } from './middleware/subagent.js';
+import { createToolGuardMiddleware } from './middleware/toolGuard.js';
+import { createToolCallLimitMiddleware } from './subagents/factory.js';
+import { createValidationWorkflowMiddleware } from './middleware/validationWorkflow.js';
+import { createMemoryFlushMiddleware } from './middleware/memoryFlush.js';
+import { createToolAvailabilityMiddleware } from './middleware/toolAvailability.js';
+
+// createDeepAgent 内部拼接的 BASE_PROMPT
+const BASE_PROMPT = 'In order to complete the objective that the user asks of you, you have access to a number of standard tools.';
 
 // 从环境变量读取配置
 const config = {
@@ -21,9 +32,48 @@ const config = {
   model: process.env.DEEPSPIDER_MODEL || 'gpt-4o',
 };
 
+/**
+ * 递归移除 JSON Schema 中 Anthropic API 不支持的关键字
+ * Zod v4 的 toJSONSchema 会生成 $schema 和 propertyNames，Anthropic 拒绝
+ * additionalProperties: {} 空对象也不被接受，改成 true
+ */
+function stripUnsupportedSchemaKeys(obj) {
+  if (!obj || typeof obj !== 'object') return obj;
+  if (Array.isArray(obj)) return obj.map(stripUnsupportedSchemaKeys);
+  const res = {};
+  for (const k in obj) {
+    if (k === '$schema' || k === 'propertyNames') continue;
+    // additionalProperties: {} → true (空对象等于"任意类型"，但Anthropic不接受空对象)
+    if (k === 'additionalProperties' && obj[k] !== null && typeof obj[k] === 'object' && Object.keys(obj[k]).length === 0) {
+      res[k] = true;
+      continue;
+    }
+    res[k] = stripUnsupportedSchemaKeys(obj[k]);
+  }
+  return res;
+}
+
+/**
+ * 自定义 fetch：拦截 LLM API 请求，strip 工具 schema 中 Zod v4 生成的不兼容字段
+ * 保留作为安全网，防止 $schema / propertyNames / additionalProperties:{} 泄漏到 API
+ */
+const _origFetch = globalThis.fetch;
+globalThis.fetch = async function(url, opts) {
+  if (opts?.body && typeof opts.body === 'string' && opts.body.includes('"tools"')) {
+    try {
+      const body = JSON.parse(opts.body);
+      if (body.tools) {
+        body.tools = stripUnsupportedSchemaKeys(body.tools);
+        opts = { ...opts, body: JSON.stringify(body) };
+      }
+    } catch { /* ignore parse errors on non-LLM requests */ }
+  }
+  return _origFetch(url, opts);
+};
+
 /**
  * 创建 LLM 模型实例
- * 使用 ChatOpenAI 兼容 OpenAI 格式的任意供应商
+ * 使用 ChatAnthropic 发送原生 Anthropic 格式，避免代理的 OpenAI→Anthropic 转换引入 schema 错误
  */
 function createModel(options = {}) {
   const {
@@ -32,10 +82,13 @@ function createModel(options = {}) {
     baseUrl = config.baseUrl,
   } = options;
 
-  return new ChatOpenAI({
+  // ChatAnthropic 的 baseURL 不含 /v1（SDK 自动拼接）
+  const anthropicBaseUrl = baseUrl?.replace(/\/v1\/?$/, '') || undefined;
+
+  return new ChatAnthropic({
     model,
-    apiKey,
-    configuration: baseUrl ? { baseURL: baseUrl } : undefined,
+    anthropicApiKey: apiKey,
+    anthropicApiUrl: anthropicBaseUrl,
     temperature: 0,
   });
 }
@@ -51,18 +104,27 @@ export function createDeepSpiderAgent(options = {}) {
     enableMemory = true,
     enableInterrupt = false,
     onReportReady = null,  // 报告就绪回调
+    onFileSaved = null,    // 文件保存通知回调
+    checkpointer,
   } = options;
 
-  // 创建 LLM 模型实例
+  // 创建 LLM 模型实例（加 timeout 防止 API 无响应时 streamEvents 永久挂起）
   const llm = createModel({ model, apiKey, baseUrl });
+  llm.timeout = 120000; // 120s — 主 LLM 超时
+
+  // 摘要专用 LLM：故意不设 timeout
+  // 原因：summarizationMiddleware 的 createSummary 有 try-catch，超时会返回错误字符串，
+  // 但 beforeModel 仍会用这个错误字符串替换所有原始消息（REMOVE_ALL_MESSAGES），导致数据丢失。
+  // 安全网由 StreamHandler.withStallTimeout (150s) 提供 — 它在 BeforeModelNode 完成前触发，
+  // 不会写入 checkpoint，原始数据得以保留。
+  const summaryLlm = createModel({ model, apiKey, baseUrl });
 
   // 后端配置：使用文件系统持久化
   const backend = enableMemory
     ? new FilesystemBackend({ rootDir: './.deepspider-agent' })
     : new StateBackend();
 
-  // Checkpointer：保存对话状态，支持断点恢复
-  const checkpointer = new MemorySaver();
+  const resolvedCheckpointer = checkpointer ?? SqliteSaver.fromConnString(':memory:');
 
   // 人机交互配置
   const interruptOn = enableInterrupt
@@ -72,26 +134,61 @@ export function createDeepSpiderAgent(options = {}) {
       }
     : undefined;
 
-  // 中间件配置
-  const middleware = [
-    createFilterToolsMiddleware(),  // 过滤内置的 write_file/read_file
-    createReportMiddleware({ onReportReady }),
+  // 框架级子代理默认中间件（对照 createDeepAgent 内部的 subagentMiddleware）
+  const subagentDefaultMiddleware = [
+    todoListMiddleware(),
+    createFilesystemMiddleware({ backend }),
+    summarizationMiddleware({ model: summaryLlm, trigger: { tokens: 100000 }, keep: { messages: 6 } }),
+    anthropicPromptCachingMiddleware({ unsupportedModelBehavior: 'ignore' }),
+    createPatchToolCallsMiddleware(),
   ];
 
-  return createDeepAgent({
+  // 组装完整 middleware 栈（对照 createDeepAgent 源码 dist/index.js:3791-3826）
+  return createAgent({
     name: 'deepspider',
     model: llm,
     tools: coreTools,
-    subagents: allSubagents,
-    systemPrompt,
-    backend,
-    checkpointer,
-    interruptOn,
-    middleware,
+    systemPrompt: `${systemPrompt}\n\n${BASE_PROMPT}`,
+    middleware: [
+      // === 框架内置 middleware ===
+      todoListMiddleware(),
+      createFilesystemMiddleware({ backend }),
+      createCustomSubAgentMiddleware({
+        defaultModel: llm,
+        defaultTools: coreTools,
+        subagents: allSubagents,
+        defaultMiddleware: subagentDefaultMiddleware,
+        generalPurposeAgent: false,
+        defaultInterruptOn: interruptOn,
+      }),
+      // === 预警 + 拦截（在 summarization 之前）===
+      createMemoryFlushMiddleware(),
+      createToolAvailabilityMiddleware(),
+      summarizationMiddleware({ model: summaryLlm, trigger: { tokens: 100000 }, keep: { messages: 6 } }),
+      anthropicPromptCachingMiddleware({ unsupportedModelBehavior: 'ignore' }),
+      createPatchToolCallsMiddleware(),
+      // === HITL（如果启用）===
+      ...(interruptOn ? [humanInTheLoopMiddleware({ interruptOn })] : []),
+      // === 自定义 middleware ===
+      toolRetryMiddleware({
+        maxRetries: 0,
+        onFailure: (err) => {
+          // GraphInterrupt / ParentCommand 等 LangGraph 内部控制流异常必须透传，不能吞掉
+          if (err?.is_bubble_up === true) throw err;
+          return `Tool call failed: ${err.message}\nPlease fix the arguments and retry.`;
+        },
+      }),
+      createToolGuardMiddleware(),
+      createToolCallLimitMiddleware(200),
+      createFilterToolsMiddleware(),
+      createValidationWorkflowMiddleware(),
+      createReportMiddleware({ onReportReady, onFileSaved }),
+    ],
+    checkpointer: resolvedCheckpointer,
   });
 }
 
-// 默认导出
+// 默认导出（内存模式，兼容 MCP 等非 CLI 场景）
 export const agent = createDeepSpiderAgent();
 
 export default agent;