deepspider 0.3.2 → 0.5.0

package/src/agent/middleware/report.js

@@ -1,6 +1,6 @@
 /**
  * DeepSpider - 报告中间件
- * 在 Agent 执行完成后自动检测并准备报告
+ * 检测文件保存事件，触发报告显示和面板通知
  */
 
 import { createMiddleware } from 'langchain';
@@ -14,89 +14,121 @@ const reportStateSchema = z.object({
 });
 
 /**
- * 检测并触发报告显示
+ * 从工具返回值中提取 .md 文件路径
+ * 兼容两种工具的返回格式：
+ *   artifact_save: { success, path: "/xxx/analysis.md" }
+ *   save_analysis_report: { success, paths: { markdown: "/xxx/analysis.md" }, dir }
  */
-async function detectAndTriggerReport(result, onReportReady) {
+function extractMdPath(content) {
+  if (!content?.success) return null;
+
+  // artifact_save 格式
+  if (content.path?.endsWith('.md')) return content.path;
+
+  // save_analysis_report 格式
+  if (content.paths?.markdown) return content.paths.markdown;
+
+  return null;
+}
+
+/**
+ * 从工具返回值中提取已保存的文件信息（用于面板通知）
+ * 返回 { path, type } 或 null
+ */
+function extractSavedFile(content) {
+  if (!content?.success) return null;
+
+  // artifact_save: 单文件
+  if (content.path) {
+    const ext = content.path.split('.').pop();
+    return { path: content.path, type: ext };
+  }
+
+  // save_analysis_report: 多文件
+  if (content.paths) {
+    return { path: content.dir || content.paths.markdown, type: 'report' };
+  }
+
+  return null;
+}
+
+function parseContent(result) {
   try {
-    const content = typeof result?.content === 'string'
+    return typeof result?.content === 'string'
       ? JSON.parse(result.content)
       : result?.content;
-
-    if (content?.success && content?.path?.endsWith('.md')) {
-      console.log('[reportMiddleware] 检测到 .md 文件:', content.path);
-
-      if (onReportReady) {
-        await onReportReady(content.path);
-      }
-      return true;
-    }
   } catch {
-    // 解析失败，忽略
+    return null;
   }
-  return false;
 }
 
 /**
  * 创建报告中间件
- * 在 wrapToolCall 中检测 artifact_save 工具调用结果，立即触发报告
- * 同时在 afterModel 和 afterAgent 中保留检测逻辑作为备选
+ * 监听 artifact_save 和 save_analysis_report，触发报告显示 + 面板通知
  */
 export function createReportMiddleware(options = {}) {
-  const { onReportReady } = options;
+  const { onReportReady, onFileSaved } = options;
+
+  const WATCHED_TOOLS = new Set(['artifact_save', 'save_analysis_report']);
 
   return createMiddleware({
     name: 'reportMiddleware',
     stateSchema: reportStateSchema,
 
-    // 工具调用包装器：在 artifact_save 完成时立即检测
     wrapToolCall: async (request, handler) => {
       const toolName = request.tool?.name ?? request.toolCall?.name;
       const result = await handler(request);
 
-      // 检测 artifact_save 工具返回的 .md 文件
-      if (toolName === 'artifact_save') {
-        await detectAndTriggerReport(result, onReportReady);
+      if (!WATCHED_TOOLS.has(toolName)) return result;
+
+      const content = parseContent(result);
+      if (!content) return result;
+
+      // 检测 .md 文件 → 触发报告显示
+      const mdPath = extractMdPath(content);
+      if (mdPath) {
+        console.log('[reportMiddleware] 检测到报告文件:', mdPath);
+        if (onReportReady) {
+          await onReportReady(mdPath);
+        }
+      }
+
+      // 通知文件已保存（面板可显示提示）
+      const saved = extractSavedFile(content);
+      if (saved && onFileSaved) {
+        await onFileSaved(saved);
       }
 
       return result;
     },
 
-    // 模型调用后，检测工具调用结果（备选方案）
+    // 备选：afterModel 检测 ToolMessage 中的报告文件
     afterModel: (state) => {
       const messages = state.messages;
-      if (!messages || messages.length === 0) return undefined;
+      if (!messages?.length) return undefined;
 
-      // 查找最近的 ToolMessage
       for (let i = messages.length - 1; i >= 0; i--) {
         const msg = messages[i];
-        if (ToolMessage.isInstance(msg)) {
-          try {
-            const content = typeof msg.content === 'string'
-              ? JSON.parse(msg.content)
-              : msg.content;
-
-            // 检测是否是 artifact_save 写入的 .md 文件
-            if (content.success && content.path?.endsWith('.md')) {
-              console.log('[reportMiddleware] afterModel 检测到 .md 文件:', content.path);
-              return { lastWrittenMdFile: content.path };
-            }
-          } catch {
-            // 解析失败，忽略
-          }
+        if (!ToolMessage.isInstance(msg)) continue;
+
+        const content = parseContent(msg);
+        if (!content) continue;
+
+        const mdPath = extractMdPath(content);
+        if (mdPath) {
+          console.log('[reportMiddleware] afterModel 检测到报告:', mdPath);
+          return { lastWrittenMdFile: mdPath };
         }
       }
       return undefined;
     },
 
-    // Agent 执行完成后（streamEvents 模式下可能不被调用）
+    // streamEvents 模式下可能不被调用
     afterAgent: async (state) => {
-      const mdFile = state.lastWrittenMdFile;
-
-      if (mdFile) {
-        console.log('[reportMiddleware] afterAgent: 准备显示报告:', mdFile);
+      if (state.lastWrittenMdFile) {
+        console.log('[reportMiddleware] afterAgent: 报告就绪:', state.lastWrittenMdFile);
         return { reportReady: true };
       }
-
       return undefined;
     },
   });

package/src/agent/middleware/subagent.js

@@ -175,7 +175,10 @@ function createEnhancedTaskTool(options) {
       schema: z.object({
         description: z.string().describe('The task to execute with the selected agent'),
         subagent_type: z.string().describe(`Name of the agent to use. Available: ${availableTypes}`),
-        context: z.record(z.string(), z.string()).optional().describe('Structured key-value context to pass to the subagent (e.g. site, requestId, targetParam)'),
+        // NOTE: 不用 z.record() 因为 Zod v4 toJSONSchema 会生成 propertyNames，
+        // 而 Anthropic API 不支持 propertyNames 关键字
+        // 改用 z.object({}) + additionalProperties 模式
+        context: z.object({}).passthrough().optional().describe('Structured key-value context to pass to the subagent (e.g. site, requestId, targetParam)'),
       }),
     },
   );

package/src/agent/middleware/toolAvailability.js

@@ -0,0 +1,37 @@
+/**
+ * DeepSpider - 工具可用性拦截中间件
+ * 拦截已知不可用的 stub/缺依赖工具，返回友好错误而非无意义结果
+ */
+
+import { createMiddleware } from 'langchain';
+import { ToolMessage } from '@langchain/core/messages';
+
+// 不可用工具清单及原因
+const UNAVAILABLE_TOOLS = {
+  captcha_ocr: '需要集成 OCR 服务（ddddocr 或打码平台），当前为占位实现',
+  captcha_slide_detect: '需要集成缺口检测算法（OpenCV），当前为占位实现',
+  proxy_test: '缺少依赖 https-proxy-agent，无法测试代理',
+};
+
+export function createToolAvailabilityMiddleware() {
+  return createMiddleware({
+    name: 'toolAvailabilityMiddleware',
+
+    wrapToolCall: async (request, handler) => {
+      const toolName = request.tool?.name ?? request.toolCall?.name;
+      const reason = UNAVAILABLE_TOOLS[toolName];
+
+      if (reason) {
+        return new ToolMessage({
+          content: JSON.stringify({
+            success: false,
+            error: `工具 ${toolName} 当前不可用：${reason}。请使用其他策略完成任务。`,
+          }),
+          tool_call_id: request.toolCall.id,
+        });
+      }
+
+      return handler(request);
+    },
+  });
+}

package/src/agent/middleware/toolGuard.js

@@ -1,71 +1,181 @@
 /**
- * DeepSpider - 工具连续失败检测中间件
- * 检测同一工具连续失败（超时、错误），在 ToolMessage 中追加警告引导 LLM 换策略
+ * DeepSpider - 工具调用守卫中间件
+ * 1. 连续失败检测（原有）
+ * 2. 重复调用检测：同一工具相同参数连续调用
+ * 3. 双工具循环检测：A→B→A→B 交替调用且参数不变
  */
 
 import { createMiddleware } from 'langchain';
+import { createHash } from 'crypto';
 
-// 默认配置
+// ── 默认配置 ──────────────────────────────────────────────
 const DEFAULTS = {
-  maxConsecutiveFailures: 3,  // 连续失败 N 次后触发强警告
-  warnAfter: 2,              // 连续失败 N 次后开始追加提示
-  resetOnSuccess: true,       // 成功时重置计数
+  // 连续失败检测
+  maxConsecutiveFailures: 3,
+  warnAfter: 2,
+  resetOnSuccess: true,
+
+  // 重复调用检测阈值
+  repeatWarnAt: 3,       // ≥3 次追加警告
+  repeatStrongWarnAt: 5, // ≥5 次强警告 + 换策略指令
+  repeatBlockAt: 8,      // ≥8 次阻断
+
+  // 双工具循环检测（A→B→A→B 算 2 轮）
+  loopWarnAt: 2,         // ≥2 轮警告
+  loopStrongWarnAt: 3,   // ≥3 轮强警告
+  loopBlockAt: 5,        // ≥5 轮阻断
 };
 
-/**
- * 判断 ToolMessage 是否表示失败
- */
+// ── 工具参数签名 ─────────────────────────────────────────
+function argsSignature(toolCall) {
+  const args = toolCall?.args ?? toolCall?.input ?? {};
+  const str = JSON.stringify(args, Object.keys(args).sort());
+  return createHash('md5').update(str).digest('hex').slice(0, 12);
+}
+
+// ── 判断 ToolMessage 是否表示失败 ────────────────────────
 function isToolFailure(result) {
-  // ToolMessage.status === 'error' (toolRetryMiddleware 设置)
   if (result?.status === 'error') return true;
-
-  // 工具返回的 JSON 中 success === false
   const content = typeof result?.content === 'string' ? result.content : '';
   if (!content.startsWith('{')) return false;
   try {
-    const parsed = JSON.parse(content);
-    return parsed.success === false;
+    return JSON.parse(content).success === false;
   } catch {
     return false;
   }
 }
 
+// ── 构造阻断 ToolMessage ─────────────────────────────────
+function makeBlockedResult(request, reason) {
+  const name = request.tool?.name || request.toolCall?.name || 'unknown';
+  return {
+    type: 'tool',
+    name,
+    content: `🚫 调用被阻断：${reason}\n你必须立即停止当前策略，换用完全不同的工具或方法。如果已经获得足够信息，请直接总结并返回结果。`,
+    tool_call_id: request.toolCall?.id || `blocked_${Date.now()}`,
+    status: 'error',
+  };
+}
+
+function appendToContent(result, text) {
+  if (typeof result.content === 'string') {
+    result.content += text;
+  }
+}
+
+/**
+ * 规范化双工具 pair key（字典序排列，避免 A|B ≠ B|A）
+ */
+function pairKey(nameA, sigA, nameB, sigB) {
+  const a = `${nameA}:${sigA}`;
+  const b = `${nameB}:${sigB}`;
+  return a <= b ? `${a}|${b}` : `${b}|${a}`;
+}
+
 /**
- * 创建工具连续失败检测中间件
+ * 创建工具调用守卫中间件
+ * - 连续失败检测（原有逻辑）
+ * - 重复调用检测（同工具同参数）
+ * - 双工具循环检测（A↔B 交替，用规范化 pair key 避免顺序翻转）
  */
 export function createToolGuardMiddleware(options = {}) {
-  const config = { ...DEFAULTS, ...options };
+  const cfg = { ...DEFAULTS, ...options };
 
-  // toolName → { count, lastArgs }
-  const failureTracker = new Map();
+  const failureTracker = new Map(); // toolName → { count }
+  const repeatTracker = new Map();  // toolName → { sig, count }
+
+  // 循环检测：只需记住上一次调用
+  let lastCall = null;   // { name, sig }
+  let loopCount = 0;
+  let loopKey = null;    // 规范化 pair key
 
   return createMiddleware({
     name: 'toolGuardMiddleware',
 
     wrapToolCall: async (request, handler) => {
       const toolName = request.tool?.name ?? request.toolCall?.name;
+      if (!toolName) return handler(request);
+
+      const sig = argsSignature(request.toolCall);
+
+      // ── 1) 重复调用检测（阻断优先） ──
+      const prev = repeatTracker.get(toolName);
+      if (prev && prev.sig === sig) {
+        prev.count++;
+      } else {
+        repeatTracker.set(toolName, { sig, count: 1 });
+      }
+      const repeatCount = repeatTracker.get(toolName).count;
+
+      if (repeatCount >= cfg.repeatBlockAt) {
+        return makeBlockedResult(request,
+          `工具 ${toolName} 以相同参数连续调用 ${repeatCount} 次（上限 ${cfg.repeatBlockAt}）`);
+      }
+
+      // ── 2) 双工具循环检测（阻断优先） ──
+      // 用规范化 pair key 检测 A→B→A→B 模式，不受窗口顺序影响
+      if (lastCall && lastCall.name !== toolName) {
+        const key = pairKey(lastCall.name, lastCall.sig, toolName, sig);
+        if (loopKey === key) {
+          loopCount++;
+        } else if (loopKey === null) {
+          // 首次出现双工具交替，开始追踪
+          loopKey = key;
+          loopCount = 1;
+        } else {
+          // 模式变了，重置
+          loopKey = key;
+          loopCount = 1;
+        }
+      } else if (lastCall && lastCall.name === toolName) {
+        // 同一工具连续调用不算循环，但也不重置（可能是 A→A→B→A→B）
+        // 只有当出现新的不同 pair 时才重置
+      }
+
+      if (loopCount >= cfg.loopBlockAt) {
+        lastCall = { name: toolName, sig };
+        return makeBlockedResult(request,
+          `检测到双工具循环模式已持续 ${loopCount} 轮（上限 ${cfg.loopBlockAt}）`);
+      }
+
+      // 更新 lastCall（在执行工具之前，确保阻断路径也更新）
+      lastCall = { name: toolName, sig };
+
+      // ── 3) 执行工具 ──
       const result = await handler(request);
 
-      if (!toolName) return result;
+      // ── 4) 重复调用警告（追加到结果） ──
+      if (repeatCount >= cfg.repeatStrongWarnAt) {
+        appendToContent(result,
+          `\n\n🚫 工具 ${toolName} 以相同参数已连续调用 ${repeatCount} 次（阻断阈值 ${cfg.repeatBlockAt}）。你必须立即换用其他策略，不要再以相同参数调用此工具。`);
+      } else if (repeatCount >= cfg.repeatWarnAt) {
+        appendToContent(result,
+          `\n\n⚠️ 工具 ${toolName} 以相同参数已连续调用 ${repeatCount} 次。建议考虑替代方案，避免重复操作。`);
+      }
+
+      // ── 5) 循环模式警告 ──
+      if (loopCount >= cfg.loopStrongWarnAt && loopCount < cfg.loopBlockAt) {
+        appendToContent(result,
+          `\n\n🚫 检测到双工具循环模式已持续 ${loopCount} 轮（阻断阈值 ${cfg.loopBlockAt}）。你必须立即停止这个循环，换用完全不同的分析策略。`);
+      } else if (loopCount >= cfg.loopWarnAt && loopCount < cfg.loopStrongWarnAt) {
+        appendToContent(result,
+          `\n\n⚠️ 检测到可能的双工具循环模式（${loopCount} 轮）。如果你在重复相同操作，请考虑换一种方法。`);
+      }
 
+      // ── 6) 连续失败检测（原有逻辑） ──
       if (isToolFailure(result)) {
         const tracker = failureTracker.get(toolName) || { count: 0 };
         tracker.count++;
         failureTracker.set(toolName, tracker);
 
-        // 追加警告到 ToolMessage content
-        if (tracker.count >= config.maxConsecutiveFailures) {
-          const warning = `\n\n🚫 工具 ${toolName} 已连续失败 ${tracker.count} 次。请停止使用该工具重试相同逻辑，必须换用其他工具或策略。`;
-          if (typeof result.content === 'string') {
-            result.content += warning;
-          }
-        } else if (tracker.count >= config.warnAfter) {
-          const warning = `\n\n⚠️ 工具 ${toolName} 已连续失败 ${tracker.count} 次（上限 ${config.maxConsecutiveFailures}）。如果继续失败将被限制使用，建议考虑替代方案。`;
-          if (typeof result.content === 'string') {
-            result.content += warning;
-          }
+        if (tracker.count >= cfg.maxConsecutiveFailures) {
+          appendToContent(result,
+            `\n\n🚫 工具 ${toolName} 已连续失败 ${tracker.count} 次。请停止使用该工具重试相同逻辑，必须换用其他工具或策略。`);
+        } else if (tracker.count >= cfg.warnAfter) {
+          appendToContent(result,
+            `\n\n⚠️ 工具 ${toolName} 已连续失败 ${tracker.count} 次（上限 ${cfg.maxConsecutiveFailures}）。如果继续失败将被限制使用，建议考虑替代方案。`);
         }
-      } else if (config.resetOnSuccess) {
+      } else if (cfg.resetOnSuccess) {
         failureTracker.delete(toolName);
       }
 

package/src/agent/prompts/system.js

@@ -8,6 +8,61 @@
  */
 export const systemPrompt = `你是 DeepSpider，一个智能爬虫 Agent。你的目标是帮助用户分析网站、理解加密逻辑、回答爬虫相关问题。
 
+## 核心工作循环（Agent Loop）
+
+每次收到用户请求后，按以下循环执行，直到任务完成：
+
+\`\`\`
+分析 → 规划 → 执行 → 验证 → 反思
+  ↑                              ↓
+  └──────── 未通过则回到 ────────┘
+\`\`\`
+
+1. **分析**：理解用户意图，收集已有信息（已捕获的请求、memo、todo 状态）
+2. **规划**：拆解任务为具体步骤，创建/更新 todo 清单
+3. **执行**：调用工具或委托子代理，优先并行调用无依赖的操作
+4. **验证**：检查执行结果是否符合预期，端到端验证代码可运行
+5. **反思**：总结本轮收获，save_memo 保存关键进度，判断是否需要下一轮
+
+**每轮只推进一步，不要跳步。验证未通过不要继续推进。**
+
+## Think/Reflect — 关键决策前暂停
+
+遇到以下场景时，必须先在回复中输出思考过程，再采取行动：
+
+- 用户需求模糊或有多种理解方式时
+- 前一步执行结果与预期不符时
+- 即将委托子代理执行不可逆操作时
+- 连续 2 次工具调用失败时
+- 需要在多个候选方案中选择时
+
+格式：先用一段文字说明你的判断和理由，再调用工具。不要默默行动。
+
+## 信息优先级
+
+做决策时，按以下优先级使用信息：
+
+1. **已捕获的数据**（浏览器拦截的请求/响应、Hook 记录）— 最可靠
+2. **用户提供的信息**（选中的元素、补充说明）— 直接采信
+3. **工具实时获取**（run_node_code / run_python_code 验证、get_request_detail 查看）— 需验证
+4. **模型推断**（基于经验猜测加密类型、参数含义）— 仅作参考，必须验证
+
+**禁止仅凭推断就下结论。所有关键判断必须有数据支撑。**
+
+## 代码执行能力
+
+你有两个代码执行工具可用：
+
+| 工具 | 用途 | 示例 |
+|------|------|------|
+| \`run_node_code\` | JS代码快速验证、加密库调用测试 | \`const CryptoJS = require('crypto-js'); ...\` |
+| \`run_python_code\` | Python代码验证、加密算法对比、数据处理 | \`from gmssl import sm2; ...\` |
+
+**使用原则**：
+- 快速验证假设时优先用 \`run_node_code\`（JS环境与浏览器更接近）
+- 需要验证 Python 加密实现时用 \`run_python_code\`
+- 复杂的加密代码转换仍需委托 js2python 子代理
+
 ## 浏览器面板
 
 当用户通过浏览器面板发送消息时（消息以"[浏览器已就绪]"开头）：
@@ -43,6 +98,44 @@ export const systemPrompt = `你是 DeepSpider，一个智能爬虫 Agent。你
 - **description 包含分析结论**：调用栈摘要、可疑参数、加密特征
 - 示例："调用栈：send@match/1:652 → oo0O0@match/1:960，可疑参数：m=<32位hex>"
 
+## 自主数据搜寻
+
+当用户描述数据抓取目标（如"抓取爆仓数据"、"获取商品列表"），而非选中具体元素时，
+你需要自主搜寻目标数据的 API 接口。
+
+### 识别条件
+
+同时满足以下条件时进入搜寻模式：
+1. 消息以 \`[浏览器已就绪]\` 开头
+2. 用户描述的是数据目标（如"抓取XX数据"），而非技术指令（如"分析这个加密参数"）
+3. 没有附带已选中的元素
+
+### 搜寻流程
+
+**第一步：搜索已捕获的请求**
+1. 从用户描述中提取关键词（中英文都试，如"爆仓"+"liquidation"）
+2. 用 \`search_in_responses\` 搜索
+3. 找到匹配 → 跳到第三步
+
+**第二步：交互触发请求**（仅在第一步无结果时）
+1. \`get_interactive_elements\` 了解页面结构
+2. 尝试操作触发 API：\`scroll_page\` 滚动、\`click_element\` 点击选项卡/按钮
+3. 每次交互后重新搜索检查新请求
+4. 最多 3 轮，避免无限循环
+
+**第三步：展示候选接口**
+1. \`get_request_detail\` 查看候选请求详情
+2. 向用户列出候选接口，每个包含：接口地址、方法、返回数据摘要
+3. 让用户确认目标接口后再进入下一步
+
+**第四步：用户确认后执行完整分析**
+按照完整分析流程执行：加密检测 → 逆向分析（如需）→ 端到端验证 → 生成爬虫脚本
+
+### 注意事项
+- 搜寻阶段只做发现和确认，不提前进入逆向分析
+- 多个候选接口时全部列出让用户选择
+- 3 轮交互仍无结果时，建议用户手动操作页面触发目标请求后重试
+
 ## 禁止行为（必须遵守）
 
 **你禁止自己编写代码**。当用户需要代码时，你必须：
@@ -64,7 +157,55 @@ export const systemPrompt = `你是 DeepSpider，一个智能爬虫 Agent。你
 
 **错误示例**：
 - ❌ 在回复中直接写 "\`\`\`python\\nimport requests\\n..." 代码块
-- ❌ 说"这是一个简单的示例代码"然后输出代码`;
+- ❌ 说"这是一个简单的示例代码"然后输出代码
+
+## 工具并行调用
+
+无数据依赖的工具调用必须并行，不要串行等待。
+
+**并行场景**：同时搜索多个关键词、同时获取多个请求详情、同时分析多个脚本。
+**原则**：除非 A 的输出是 B 的输入，否则默认并行。
+
+## 循环检测与脱困
+
+**同一操作最多重试 3 次。** 第 3 次失败后必须：
+
+1. 停下来，分析失败模式（不是简单重试）
+2. 尝试替代方案（换工具、换参数、换思路）
+3. 如果替代方案也失败，向用户说明情况并请求指导
+
+**常见脱困策略**：
+- 搜索无结果 → 换关键词（中英文、缩写、同义词）
+- 工具报错 → 检查参数格式，查看错误信息中的线索
+- 子代理失败 → 检查传递的 context 是否完整，简化任务描述重试
+- 加密分析卡住 → 换入口点，或建议用户手动触发更多请求
+
+**禁止**：无脑重复同一个失败的操作。
+
+## 经验记忆（save_memo）
+
+save_memo 不只是保存进度，更是积累可复用的经验。
+
+**必须保存的时机**：
+1. 发现关键接口后 — 接口地址、方法、参数结构
+2. 识别加密算法后 — 算法类型、关键函数名、调用链路
+3. 子代理返回结果后 — 核心结论（不要等到最后）
+4. 每完成一个分析阶段后 — 阶段总结和下一步计划
+5. **发现可复用的模式时** — 如"该网站的签名算法是 HMAC-SHA256 + 时间戳"
+
+**memo 格式建议**：用结构化的 key-value，方便后续检索。
+不要等系统提醒。主动保存是你的责任，丢失进度意味着重复工作。
+
+## 任务规划（todo）
+
+多步骤任务必须在开始前创建 todo 清单，执行中实时更新：
+
+- **开始前**：拆解为具体步骤，创建 todo
+- **执行中**：每完成一步立即标记，不要攒批
+- **遇到变化时**：及时更新或新增 todo 项
+- **完成后**：确认所有 todo 项已完成或标记为跳过（附原因）
+
+todo 是你的工作记忆，不用 todo 规划的复杂任务容易遗漏步骤。`;
 
 /**
  * 完整分析专用提示 - 仅在用户请求完整分析时使用
@@ -72,6 +213,8 @@ export const systemPrompt = `你是 DeepSpider，一个智能爬虫 Agent。你
 export const fullAnalysisPrompt = `
 ## 完整分析任务要求
 
+如果目标请求已在搜寻阶段确认，跳过步骤1直接从步骤2（识别加密类型）开始。
+
 这是一个完整分析任务，你需要完成以下所有步骤：
 
 ### 分析思路