nolo-cli 0.1.30 → 0.1.32

package/ai/tools/createPlanTool.ts

@@ -1,999 +0,0 @@
-// 文件路径: ai/tools/createPlanTool.ts
-// 完整的 createPlan 工具，支持普通步骤和反思步骤（reflect step）
-
-import { createAsyncThunk } from "@reduxjs/toolkit";
-import {
-  setPlan,
-  setSteps,
-  updateStep,
-  setCurrentStep,
-  selectSteps,
-  insertStepsAfter,
-  removeStepsAfter,
-  setExecutionConfig,
-  incrementReflectCount,
-  incrementStepsExecuted,
-  setStartTime,
-  selectPlanStats,
-  selectExecutionConfig,
-  type Step,
-  type ToolCall,
-  type ReflectDecision,
-  type PlanExecutionConfig,
-} from "../agent/planSlice";
-// ✅ 不再直接在 Plan 里使用 runLlm / runAgent，统一走 toolExecutors
-// import { runLlm, runAgent } from "../agent/agentSlice";
-import { toolExecutors, toolDefinitionsByName } from "../tools";
-import {
-  toolRunStarted,
-  toolRunSucceeded,
-  toolRunFailed,
-  createToolRunId,
-} from "../tools/toolRunSlice";
-import type { RootState } from "../../app/store";
-import { selectCurrentDialogConfig } from "../../chat/dialog/dialogSlice";
-import { messageStreamEnd, messageStreaming } from "../../chat/messages/messageSlice";
-import { extractCustomId } from "../../core/prefix";
-import { createDialogMessageKeyAndId } from "../../database/keys";
-import { callAgentFunc } from "./agent/callAgentTool";
-const PLAN_EXECUTOR_CYBOT_KEY = "PLAN_EXECUTOR";
-const PLAN_EXECUTOR_AGENT_CONFIG = { dbKey: PLAN_EXECUTOR_CYBOT_KEY } as any;
-
-// --- Schema ---
-
-export const createPlanFunctionSchema = {
-  name: "createPlan",
-  description:
-    "用于处理需要多个工具协作、有顺序依赖或可并行执行的复杂任务。当你发现一个请求无法通过单次工具调用完成时，应优先使用本工具来制定并执行一个清晰、可靠的多步骤计划。" +
-    "在 Plan 中，你可以调用任意已注册的工具（例如 youtubeScraper, addTableRow, callAgent, runStreamingAgent 等），" +
-    "并通过 steps.STEP_ID.result 在步骤之间传递数据。",
-  parameters: {
-    type: "object",
-    properties: {
-      planTitle: {
-        type: "string",
-        description: "为整个计划的目标设定一个简明扼要的标题。",
-      },
-      strategy: {
-        type: "string",
-        description:
-          "[至关重要] 详细阐述制定此计划的整体策略和思考过程。解释为什么选择这些步骤、它们如何协同工作、以及数据如何在步骤间传递，以最终达成目标。",
-      },
-      steps: {
-        type: "array",
-        description:
-          "一个有序的步骤数组。每个步骤可以是普通工具调用步骤（type: normal）或反思决策步骤（type: reflect）。",
-        items: {
-          type: "object",
-          properties: {
-            id: {
-              type: "string",
-              description:
-                "步骤的唯一标识符 (例如 'fetch_data', 'step_2', 'reflect_1')。此ID用于在后续步骤中引用本步骤的执行结果。",
-            },
-            title: {
-              type: "string",
-              description: "对该步骤目标的简短、人类可读的描述。",
-            },
-            type: {
-              type: "string",
-              enum: ["normal", "reflect"],
-              description:
-                "步骤类型。'normal' 是普通工具调用步骤，'reflect' 是反思决策步骤，用于根据前面步骤的结果动态调整计划。默认为 'normal'。",
-            },
-            calls: {
-              type: "array",
-              description:
-                "（仅 type='normal' 时使用）一个或多个工具调用的数组，它们将在本步骤内并行执行。",
-              items: {
-                type: "object",
-                properties: {
-                  tool_name: {
-                    type: "string",
-                    description:
-                      "要调用的工具名称（必须是系统中已注册的工具之一，例如 'youtubeScraper', 'addTableRow', 'callAgent', 'runStreamingAgent' 等）。",
-                  },
-                  parameters: {
-                    type: "object",
-                    description:
-                      "调用工具所需的参数对象。要引用先前步骤的结果，请使用占位符 '{{steps.STEP_ID.result}}' 或 '{{steps.STEP_ID.result[INDEX]}}' (当结果是数组时)。",
-                  },
-                },
-                required: ["tool_name", "parameters"],
-              },
-            },
-            reflectInput: {
-              type: "string",
-              description:
-                "（仅 type='reflect' 时使用）给反思 LLM 的提示，说明需要检查什么、基于什么条件做决策。反思 LLM 会看到所有已完成步骤的结果摘要，并决定是继续、停止还是插入新步骤。",
-            },
-          },
-          required: ["id", "title"],
-        },
-      },
-      executionConfig: {
-        type: "object",
-        description: "（可选）计划执行的边界控制配置。",
-        properties: {
-          maxReflectCount: {
-            type: "integer",
-            description: "最多允许执行多少次反思步骤。",
-          },
-          maxTotalSteps: {
-            type: "integer",
-            description: "最多执行多少个步骤（包括动态插入的）。",
-          },
-          maxTimeMs: {
-            type: "integer",
-            description: "最大执行时间（毫秒）。",
-          },
-        },
-      },
-    },
-    required: ["planTitle", "strategy", "steps"],
-  },
-};
-
-// --- 辅助函数 ---
-
-/**
- * 解析步骤参数中的占位符，替换为实际的步骤结果
- */
-const resolveParameters = (params: any, allSteps: Step[]): any => {
-  if (typeof params !== "string") {
-    if (Array.isArray(params)) {
-      return params.map((p) => resolveParameters(p, allSteps));
-    }
-    if (typeof params === "object" && params !== null) {
-      return Object.fromEntries(
-        Object.entries(params).map(([key, value]) => [
-          key,
-          resolveParameters(value, allSteps),
-        ])
-      );
-    }
-    return params;
-  }
-
-  return params.replace(
-    /\{\{steps\.([^}]+)\.result(\[\d+\])?\}\}/g,
-    (match, stepId, indexPart) => {
-      const referencedStep = allSteps.find((s) => s.id === stepId);
-      if (
-        !referencedStep ||
-        referencedStep.status !== "completed" ||
-        !referencedStep.result
-      ) {
-        console.warn(
-          `无法解析引用：步骤 "${stepId}" 未完成或没有结果。将返回原始占位符。`
-        );
-        return match;
-      }
-
-      let result = referencedStep.result;
-      if (indexPart) {
-        const index = parseInt(indexPart.slice(1, -1), 10);
-        if (Array.isArray(result) && index < result.length) {
-          result = result[index];
-        } else {
-          console.warn(
-            `无法解析引用：步骤 "${stepId}" 的结果中没有索引 ${index}。将返回原始占位符。`
-          );
-          return match;
-        }
-      }
-
-      if (typeof result === "object") {
-        return JSON.stringify(result);
-      }
-      return String(result);
-    }
-  );
-};
-
-/**
- * 格式化参数用于展示
- */
-function formatParameters(params: Record<string, any>): string {
-  if (!params || Object.keys(params).length === 0) return "无";
-  return Object.entries(params)
-    .map(([key, value]) => `  - \`${key}\`: \`${JSON.stringify(value)}\``)
-    .join("\n");
-}
-
-/**
- * 对步骤结果生成摘要，用于反思 LLM
- */
-function summarizeStepResult(result: any[] | undefined): any {
-  if (!result || result.length === 0) {
-    return { empty: true };
-  }
-
-  return result.map((item) => {
-    if (item === null || item === undefined) {
-      return { type: "null" };
-    }
-
-    if (Array.isArray(item)) {
-      return {
-        type: "array",
-        length: item.length,
-        sample: item.slice(0, 2),
-        fields:
-          item[0] && typeof item[0] === "object" ? Object.keys(item[0]) : [],
-      };
-    }
-
-    if (typeof item === "object") {
-      // 检查是否是错误对象
-      if (item.error) {
-        return {
-          type: "error",
-          message: item.message || item.error,
-        };
-      }
-
-      const keys = Object.keys(item);
-      const preview = JSON.stringify(item);
-      return {
-        type: "object",
-        keys,
-        preview: preview.length > 300 ? preview.slice(0, 300) + "..." : preview,
-      };
-    }
-
-    if (typeof item === "string") {
-      return {
-        type: "string",
-        length: item.length,
-        preview: item.length > 200 ? item.slice(0, 200) + "..." : item,
-      };
-    }
-
-    return {
-      type: typeof item,
-      value: item,
-    };
-  });
-}
-
-/**
- * 构建反思 LLM 的上下文输入
- */
-function buildReflectContext(
-  currentStep: Step,
-  allSteps: Step[],
-  originalRequest?: string
-): string {
-  const completedSteps = allSteps
-    .filter((s) => s.status === "completed" && s.id !== currentStep.id)
-    .map((s) => ({
-      id: s.id,
-      title: s.title,
-      type: s.type || "normal",
-      resultSummary: summarizeStepResult(s.result),
-    }));
-
-  const pendingSteps = allSteps
-    .filter((s) => s.status === "pending" && s.id !== currentStep.id)
-    .map((s) => ({
-      id: s.id,
-      title: s.title,
-      type: s.type || "normal",
-    }));
-
-  const failedSteps = allSteps
-    .filter((s) => s.status === "failed")
-    .map((s) => ({
-      id: s.id,
-      title: s.title,
-      result: s.result,
-    }));
-
-  return `
-## 当前 Plan 执行状态
-
-### 已完成的步骤 (${completedSteps.length})
-${completedSteps.length > 0 ? JSON.stringify(completedSteps, null, 2) : "（暂无）"}
-
-### 失败的步骤 (${failedSteps.length})
-${failedSteps.length > 0 ? JSON.stringify(failedSteps, null, 2) : "（暂无）"}
-
-### 待执行的步骤 (${pendingSteps.length})
-${pendingSteps.length > 0 ? JSON.stringify(pendingSteps, null, 2) : "（暂无）"}
-
-### 反思任务
-${currentStep.reflectInput || "请检查当前执行状态，决定下一步行动。"}
-
----
-
-请根据以上信息，决定下一步行动。你必须返回一个 JSON 对象，格式如下：
-
-\`\`\`json
-{
-  "action": "continue" | "stop" | "insert_steps",
-  "reason": "你的决策原因",
-  "steps": []  // 仅当 action 是 "insert_steps" 时需要填写新步骤
-}
-\`\`\`
-
-**action 说明：**
-- "continue"：继续执行剩余的待执行步骤
-- "stop"：停止执行，当前结果已足够或无法继续
-- "insert_steps"：需要插入新的步骤来完成任务
-
-**如果 action 是 "insert_steps"，steps 数组中的每个步骤格式：**
-\`\`\`json
-{
-  "id": "新步骤的唯一ID",
-  "title": "步骤描述",
-  "type": "normal",
-  "calls": [
-    {
-      "tool_name": "工具名称",
-      "parameters": { ... }
-    }
-  ]
-}
-\`\`\`
-
-请只返回 JSON，不要有其他内容。
-`.trim();
-}
-
-/**
- * 解析反思 LLM 的输出
- */
-function parseReflectDecision(llmOutput: string): ReflectDecision {
-  // 尝试从输出中提取 JSON
-  let jsonStr = llmOutput;
-
-  // 如果输出包含 markdown 代码块，提取其中的 JSON
-  const jsonMatch = llmOutput.match(/```(?:json)?\s*([\s\S]*?)```/);
-  if (jsonMatch) {
-    jsonStr = jsonMatch[1].trim();
-  }
-
-  try {
-    const parsed = JSON.parse(jsonStr);
-
-    // 验证必需字段
-    if (
-      !parsed.action ||
-      !["continue", "stop", "insert_steps"].includes(parsed.action)
-    ) {
-      console.warn("反思 LLM 输出的 action 无效，默认继续执行");
-      return {
-        action: "continue",
-        reason: "反思输出格式无效，默认继续",
-      };
-    }
-
-    // 如果是 insert_steps，验证 steps 数组
-    if (parsed.action === "insert_steps") {
-      if (!Array.isArray(parsed.steps) || parsed.steps.length === 0) {
-        console.warn(
-          "反思 LLM 输出 insert_steps 但没有提供 steps，改为继续执行"
-        );
-        return {
-          action: "continue",
-          reason: parsed.reason || "未提供新步骤，继续执行原计划",
-        };
-      }
-
-      // 确保每个新步骤都有必需字段
-      const validatedSteps = parsed.steps.map((s: any, index: number) => ({
-        id: s.id || `inserted_step_${Date.now()}_${index}`,
-        title: s.title || `插入的步骤 ${index + 1}`,
-        type: s.type || "normal",
-        calls: s.calls || [],
-        status: "pending" as const,
-        result: [],
-      }));
-
-      return {
-        action: "insert_steps",
-        reason: parsed.reason || "需要插入新步骤",
-        steps: validatedSteps,
-      };
-    }
-
-    return {
-      action: parsed.action,
-      reason: parsed.reason || "",
-    };
-  } catch (e) {
-    console.error("解析反思 LLM 输出失败:", e, "原始输出:", llmOutput);
-    return {
-      action: "continue",
-      reason: "解析反思输出失败，默认继续执行",
-    };
-  }
-}
-
-/**
- * 检查是否超出执行边界
- */
-function checkExecutionBoundary(
-  config: PlanExecutionConfig | null,
-  stats: {
-    reflectCount: number;
-    totalStepsExecuted: number;
-    startTime: number | null;
-  },
-  isReflectStep: boolean
-): { exceeded: boolean; reason?: string } {
-  if (!config) {
-    return { exceeded: false };
-  }
-
-  if (config.maxTimeMs && stats.startTime) {
-    const elapsed = Date.now() - stats.startTime;
-    if (elapsed > config.maxTimeMs) {
-      return {
-        exceeded: true,
-        reason: `执行时间超过限制 (${config.maxTimeMs}ms)`,
-      };
-    }
-  }
-
-  if (
-    config.maxTotalSteps &&
-    stats.totalStepsExecuted >= config.maxTotalSteps
-  ) {
-    return {
-      exceeded: true,
-      reason: `执行步骤数超过限制 (${config.maxTotalSteps})`,
-    };
-  }
-
-  if (
-    isReflectStep &&
-    config.maxReflectCount &&
-    stats.reflectCount >= config.maxReflectCount
-  ) {
-    return {
-      exceeded: true,
-      reason: `反思次数超过限制 (${config.maxReflectCount})`,
-    };
-  }
-
-  return { exceeded: false };
-}
-
-// --- 异步 Thunk: 计划执行器 ---
-
-interface RunPlanArgs {
-  dialogKey: string;
-  planCybotId?: string; // 用于反思的 cybot ID，如果不传则使用当前对话的主 cybot
-}
-
-export const runPlanSteps = createAsyncThunk(
-  "plan/runPlanSteps",
-  async ({ dialogKey, planCybotId }: RunPlanArgs, thunkApi) => {
-    const { getState, dispatch, signal } = thunkApi;
-
-    // 设置开始时间
-    dispatch(setStartTime(Date.now()));
-
-    const dialogId = extractCustomId(dialogKey);
-
-    // 获取反思用的 cybot ID
-    const state = getState() as RootState;
-    const currentDialog = selectCurrentDialogConfig(state);
-    const reflectCybotId = planCybotId || currentDialog?.cybots?.[0];
-
-    // 使用 while 循环而不是 for，因为 steps 可能会动态变化
-    while (true) {
-      if (signal.aborted) {
-        throw new DOMException("Aborted", "AbortError");
-      }
-
-      // 每次循环都重新获取最新的 steps
-      const currentState = getState() as RootState;
-      const allSteps = selectSteps(currentState);
-      const config = selectExecutionConfig(currentState);
-      const stats = selectPlanStats(currentState);
-
-      // 找到下一个待执行的步骤
-      const nextStep = allSteps.find((s) => s.status === "pending");
-      if (!nextStep) {
-        console.log("[runPlanSteps] 所有步骤已完成");
-        break;
-      }
-
-      const isReflectStep = nextStep.type === "reflect";
-
-      // 检查执行边界
-      const boundaryCheck = checkExecutionBoundary(
-        config,
-        stats,
-        isReflectStep
-      );
-      if (boundaryCheck.exceeded) {
-        console.log(`[runPlanSteps] 超出执行边界: ${boundaryCheck.reason}`);
-
-        // 创建一条消息通知用户
-        const { key: msgKey, messageId: boundaryMessageId } =
-          createDialogMessageKeyAndId(dialogId);
-
-        dispatch(
-          messageStreaming({
-            id: boundaryMessageId,
-            dialogId,
-            dbKey: msgKey,
-            role: "assistant",
-            content: `⚠️ **计划执行已停止**\n\n原因: ${boundaryCheck.reason}`,
-            cybotKey: PLAN_EXECUTOR_CYBOT_KEY,
-            isStreaming: true,
-          })
-        );
-
-        await dispatch(
-          messageStreamEnd({
-            finalContentBuffer: [
-              {
-                type: "text",
-                text: `⚠️ **计划执行已停止**\n\n原因: ${boundaryCheck.reason}`,
-              },
-            ],
-            msgKey,
-            dialogId,
-            dialogKey,
-            messageId: boundaryMessageId,
-            totalUsage: null,
-            agentConfig: PLAN_EXECUTOR_AGENT_CONFIG,
-            reasoningBuffer: "",
-          })
-        );
-
-        break;
-      }
-
-      // 更新当前步骤状态
-      dispatch(setCurrentStep(nextStep.id));
-      dispatch(
-        updateStep({ id: nextStep.id, updates: { status: "in-progress" } })
-      );
-      dispatch(incrementStepsExecuted());
-
-      // 创建步骤执行消息
-      const { key: msgKey, messageId: stepMessageId } =
-        createDialogMessageKeyAndId(dialogId);
-
-      if (isReflectStep) {
-        // ===== 反思步骤 =====
-        dispatch(incrementReflectCount());
-
-        dispatch(
-          messageStreaming({
-            id: stepMessageId,
-            dialogId,
-            dbKey: msgKey,
-            role: "assistant",
-            content: `🤔 **正在反思: ${nextStep.title}**`,
-            cybotKey: PLAN_EXECUTOR_CYBOT_KEY,
-            isStreaming: true,
-          })
-        );
-
-        try {
-          // 构建反思上下文
-          const reflectContext = buildReflectContext(nextStep, allSteps);
-
-          if (!reflectCybotId) {
-            throw new Error("无法确定反思 LLM 的 cybot ID");
-          }
-
-          // 这里仍然可以用 runLlm/ runAgent 封装，暂不改动
-          // 为了不引入新的依赖，这里可以简单使用全上下文 Agent，
-          // 也可以在后续将其改造成独立的反思 Agent。
-          const reflectState = getState() as RootState;
-          const reflectDialog = selectCurrentDialogConfig(reflectState);
-          const reflectAgentId = reflectCybotId || reflectDialog?.cybots?.[0];
-          if (!reflectAgentId) {
-            throw new Error("反思步骤: 找不到可用的 Agent。");
-          }
-
-          // 这里简单调用当前 Agent，一次性 LLM（无历史）
-          // 你也可以改为调用单独的 runLlm / runAgent 封装
-          const llmResult = await callAgentFunc(
-            {
-              agentKey: reflectAgentId,
-              task: reflectContext,
-              mode: "subtask",
-            },
-            thunkApi,
-            { parentMessageId: stepMessageId }
-          ).then((res) => res.rawData ?? "");
-
-
-          const decision = parseReflectDecision(llmResult as string);
-          console.log("[runPlanSteps] 反思决策:", decision);
-
-          if (decision.action === "stop") {
-            dispatch(
-              updateStep({
-                id: nextStep.id,
-                updates: { status: "completed", result: [decision] },
-              })
-            );
-
-            await dispatch(
-              messageStreamEnd({
-                finalContentBuffer: [
-                  {
-                    type: "text",
-                    text: `🛑 **反思决定: 停止执行**\n\n原因: ${decision.reason}`,
-                  },
-                ],
-                msgKey,
-                dialogId,
-                dialogKey,
-                messageId: stepMessageId,
-                totalUsage: null,
-                agentConfig: PLAN_EXECUTOR_AGENT_CONFIG,
-                reasoningBuffer: "",
-              })
-            );
-
-            // 移除后续待执行步骤
-            dispatch(removeStepsAfter(nextStep.id));
-            break;
-          }
-
-          if (
-            decision.action === "insert_steps" &&
-            decision.steps &&
-            decision.steps.length > 0
-          ) {
-            const newSteps: Step[] = decision.steps.map((s) => ({
-              ...s,
-              status: "pending" as const,
-              result: [],
-            }));
-
-            dispatch(insertStepsAfter({ afterStepId: nextStep.id, newSteps }));
-
-            dispatch(
-              updateStep({
-                id: nextStep.id,
-                updates: { status: "completed", result: [decision] },
-              })
-            );
-
-            const newStepsSummary = newSteps
-              .map((s, i) => `${i + 1}. ${s.title}`)
-              .join("\n");
-
-            await dispatch(
-              messageStreamEnd({
-                finalContentBuffer: [
-                  {
-                    type: "text",
-                    text: `🔄 **反思决定: 插入新步骤**\n\n原因: ${decision.reason}\n\n新增步骤:\n${newStepsSummary}`,
-                  },
-                ],
-                msgKey,
-                dialogId,
-                dialogKey,
-                messageId: stepMessageId,
-                totalUsage: null,
-                agentConfig: PLAN_EXECUTOR_AGENT_CONFIG,
-                reasoningBuffer: "",
-              })
-            );
-          } else {
-            dispatch(
-              updateStep({
-                id: nextStep.id,
-                updates: { status: "completed", result: [decision] },
-              })
-            );
-
-            await dispatch(
-              messageStreamEnd({
-                finalContentBuffer: [
-                  {
-                    type: "text",
-                    text: `✅ **反思完成: 继续执行**\n\n${decision.reason}`,
-                  },
-                ],
-                msgKey,
-                dialogId,
-                dialogKey,
-                messageId: stepMessageId,
-                totalUsage: null,
-                agentConfig: PLAN_EXECUTOR_AGENT_CONFIG,
-                reasoningBuffer: "",
-              })
-            );
-          }
-        } catch (e: any) {
-          console.error(`反思步骤 ${nextStep.id} 执行失败:`, e);
-
-          dispatch(
-            updateStep({
-              id: nextStep.id,
-              updates: { status: "failed", result: [{ error: e.message }] },
-            })
-          );
-
-          await dispatch(
-            messageStreamEnd({
-              finalContentBuffer: [
-                {
-                  type: "text",
-                  text: `❌ **反思失败: ${nextStep.title}**\n\n错误: ${e.message}\n\n将继续执行剩余步骤...`,
-                },
-              ],
-              msgKey,
-              dialogId,
-              dialogKey,
-              messageId: stepMessageId,
-              totalUsage: null,
-              agentConfig: PLAN_EXECUTOR_AGENT_CONFIG,
-              reasoningBuffer: "",
-            })
-          );
-
-          // 反思失败不中断整个计划，继续执行
-        }
-      } else {
-        // ===== 普通步骤 =====
-        const calls = nextStep.calls || [];
-
-        dispatch(
-          messageStreaming({
-            id: stepMessageId,
-            dialogId,
-            dbKey: msgKey,
-            role: "assistant",
-            content: `🔄 **正在执行: ${nextStep.title}** (${calls.length}个任务${calls.length > 1 ? "并行" : ""})`,
-            cybotKey: PLAN_EXECUTOR_CYBOT_KEY,
-            isStreaming: true,
-          })
-        );
-
-        try {
-          // 并行执行当前步骤的所有调用
-          const latestSteps = selectSteps(getState() as RootState);
-
-          const callPromises = calls.map(async (call: ToolCall) => {
-            const resolvedParameters = resolveParameters(
-              call.parameters,
-              latestSteps
-            );
-
-            const toolRunId = createToolRunId();
-            const def = toolDefinitionsByName[call.tool_name];
-            const behavior = def?.behavior;
-            const inputSummary = JSON.stringify(resolvedParameters).slice(
-              0,
-              400
-            );
-
-            // 启动 ToolRun 记录
-            (dispatch as any)(
-              toolRunStarted({
-                id: toolRunId,
-                messageId: stepMessageId,
-                toolName: call.tool_name,
-                behavior,
-                inputSummary,
-              })
-            );
-
-            try {
-              const executor = toolExecutors[call.tool_name];
-              if (!executor) {
-                throw new Error(`未知工具: ${call.tool_name}`);
-              }
-
-              const toolResult = await executor(
-                resolvedParameters,
-                thunkApi,
-                {
-                  parentMessageId: stepMessageId,
-                }
-              );
-
-              const rawData = toolResult?.rawData ?? toolResult;
-              const displayData =
-                toolResult?.displayData ||
-                `**${call.tool_name}**: 执行成功`;
-
-              (dispatch as any)(
-                toolRunSucceeded({
-                  id: toolRunId,
-                  outputSummary: displayData,
-                })
-              );
-
-              return { rawData, displayData };
-            } catch (e: any) {
-              (dispatch as any)(
-                toolRunFailed({
-                  id: toolRunId,
-                  error: e?.message || String(e),
-                })
-              );
-              throw e;
-            }
-          });
-
-          const toolResults = await Promise.all(callPromises);
-
-          // 更新步骤状态为 completed 并保存结果
-          dispatch(
-            updateStep({
-              id: nextStep.id,
-              updates: {
-                status: "completed",
-                result: toolResults.map((res) => res.rawData),
-              },
-            })
-          );
-
-          // 构建完成消息
-          const finalContent = `✅ **${nextStep.title} 完成**\n\n${toolResults
-            .map((r) => r.displayData || "执行成功")
-            .join("\n")}`;
-
-          await dispatch(
-            messageStreamEnd({
-              finalContentBuffer: [{ type: "text", text: finalContent }],
-              msgKey,
-              dialogId,
-              dialogKey,
-              messageId: stepMessageId,
-              totalUsage: null,
-              agentConfig: PLAN_EXECUTOR_AGENT_CONFIG,
-              reasoningBuffer: "",
-            })
-          );
-        } catch (e: any) {
-          console.error(`步骤 ${nextStep.id} 执行失败:`, e);
-
-          dispatch(
-            updateStep({
-              id: nextStep.id,
-              updates: { status: "failed", result: [{ error: e.message }] },
-            })
-          );
-
-          await dispatch(
-            messageStreamEnd({
-              finalContentBuffer: [
-                {
-                  type: "text",
-                  text: `❌ **${nextStep.title} 失败**\n\n错误: ${e.message}`,
-                },
-              ],
-              msgKey,
-              dialogId,
-              dialogKey,
-              messageId: stepMessageId,
-              totalUsage: null,
-              agentConfig: PLAN_EXECUTOR_AGENT_CONFIG,
-              reasoningBuffer: "",
-            })
-          );
-
-          // 普通步骤失败，中断整个计划
-          break;
-        }
-      }
-    }
-
-    // 所有步骤执行完毕，重置当前步骤
-    dispatch(setCurrentStep(null));
-  }
-);
-
-// --- 工具主函数 ---
-
-export async function createPlanAndOrchestrateFunc(
-  args: any,
-  thunkApi: any
-): Promise<{ rawData: string; displayData: string }> {
-  const { dispatch, getState } = thunkApi;
-  const { planTitle, strategy, steps: stepBlueprints, executionConfig } = args;
-
-  if (
-    !planTitle ||
-    !strategy ||
-    !Array.isArray(stepBlueprints) ||
-    stepBlueprints.length === 0
-  ) {
-    throw new Error(
-      "创建计划需要 'planTitle', 'strategy', 以及至少一个 'steps'。"
-    );
-  }
-
-  // 处理步骤，设置默认值
-  const processedSteps: Step[] = stepBlueprints.map((blueprint: any) => ({
-    id: blueprint.id,
-    title: blueprint.title,
-    type: blueprint.type || "normal",
-    status: "pending" as const,
-    calls: blueprint.calls || [],
-    reflectInput: blueprint.reflectInput,
-    result: [],
-  }));
-
-  // TODO: 可以在这里检查当前是否已有 Plan 在执行，必要时只返回 Plan 描述而不自动执行
-
-  // 设置计划
-  dispatch(setPlan({ planDetails: strategy, currentProgress: 0 }));
-  dispatch(setSteps(processedSteps));
-
-  // 设置执行配置（如果有）
-  if (executionConfig) {
-    dispatch(setExecutionConfig(executionConfig));
-  }
-
-  // 获取 dialogKey 并启动执行
-  const state = getState() as RootState;
-  const dialogKey = (state as any).dialog.currentDialogKey;
-
-  if (dialogKey) {
-    dispatch(runPlanSteps({ dialogKey }));
-  } else {
-    console.error("无法执行计划: 未能获取到 currentDialogKey。");
-    const errorMarkdown = `\n\n**严重错误:** 找不到当前对话。计划已创建但**不会被执行**。`;
-    return { rawData: errorMarkdown, displayData: errorMarkdown };
-  }
-
-  // 构建展示用的 Markdown
-  const normalSteps = processedSteps.filter((s) => s.type !== "reflect");
-  const reflectSteps = processedSteps.filter((s) => s.type === "reflect");
-
-  const markdownResult = `
-### 计划已创建: ${planTitle}
-
-**策略:**
-${strategy}
-
----
-
-**执行步骤 (${processedSteps.length} 步，其中 ${reflectSteps.length} 个反思点):**
-
-${processedSteps
-      .map((step, index) => {
-        if (step.type === "reflect") {
-          return `
-**${index + 1}. 🤔 ${step.title}** (\`ID: ${step.id}\`, 类型: 反思)
-- **反思任务:** ${step.reflectInput || "检查执行状态并决定下一步"}`;
-        }
-
-        return `
-**${index + 1}. ${step.title}** (\`ID: ${step.id}\`)
-${(step.calls || [])
-            .map(
-              (call) => `
-- **工具:** \`${call.tool_name}\`
-- **参数:**
-${formatParameters(call.parameters)}`
-            )
-            .join("")}`;
-      })
-      .join("\n---\n")}
-
-${executionConfig
-      ? `
----
-**执行限制:**
-${executionConfig.maxReflectCount ? `- 最大反思次数: ${executionConfig.maxReflectCount}` : ""}
-${executionConfig.maxTotalSteps ? `- 最大步骤数: ${executionConfig.maxTotalSteps}` : ""}
-${executionConfig.maxTimeMs ? `- 最大执行时间: ${executionConfig.maxTimeMs}ms` : ""}
-`
-      : ""
-    }
-
----
-**计划已开始自动执行...**
-`;
-
-  return { rawData: markdownResult, displayData: markdownResult };
-}