nolo-cli 0.1.7 → 0.1.9

package/ai/tools/createPlanTool.ts

@@ -0,0 +1,999 @@
+// 文件路径: 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 "ai/agent/planSlice";
+// ✅ 不再直接在 Plan 里使用 runLlm / runAgent，统一走 toolExecutors
+// import { runLlm, runAgent } from "ai/agent/agentSlice";
+import { toolExecutors, toolDefinitionsByName } from "ai/tools";
+import {
+  toolRunStarted,
+  toolRunSucceeded,
+  toolRunFailed,
+  createToolRunId,
+} from "ai/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 };
+}