nolo-cli 0.1.23 → 0.1.29

package/chat/messages/toolThunks.ts

@@ -0,0 +1,625 @@
+// 文件路径: chat/messages/toolThunks.ts
+
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import { DataType } from "../../create/types";
+import { write } from "../../database/dbSlice";
+import { createDialogMessageKeyAndId } from "../../database/keys";
+import type { AppThunkApi } from "../../app/store";
+
+import { findToolExecutor, toolDefinitionsByName } from "../../ai/tools";
+import { getToolResultErrorData } from "../../ai/tools/toolResultError";
+import {
+  toolRunStarted,
+  toolRunSucceeded,
+  toolRunFailed,
+  createToolRunId,
+  toolRunSetPending,
+} from "../../ai/tools/toolRunSlice";
+import { streamAgentChatTurn } from "../../ai/agent/agentSlice";
+import { startParallelAgentStreams } from "../../ai/agent/startParallelAgentStreams";
+
+import type { Message, ToolPayload, ToolErrorPayload } from "./types";
+import { addToolMessage, updateToolMessage } from "./messageSlice";
+
+const TOOL_ARGS_SENTINELS = [
+  "<|tool_calls_section_end|>",
+  "<|tool_calls_end|>",
+  "<|endofjson|>",
+];
+
+function cleanToolArguments(argStr: string): string {
+  if (!argStr) return argStr;
+
+  let cleaned = argStr;
+  for (const s of TOOL_ARGS_SENTINELS) {
+    const idx = cleaned.indexOf(s);
+    if (idx >= 0) {
+      cleaned = cleaned.slice(0, idx);
+    }
+  }
+
+  return cleaned.trim();
+}
+
+const defaultSummary = (toolName: string, status: ToolPayload["status"]) => {
+  if (status === "pending") return `⏸️ ${toolName} 等待确认/授权`;
+  if (status === "running") return `⏳ ${toolName} 执行中…`;
+  if (status === "failed") return `❌ ${toolName} 执行失败`;
+  return `✅ ${toolName} 执行完成`;
+};
+
+interface ProcessToolDataPayload {
+  toolCall: any;
+  parentMessageId: string;
+  toolRunId: string;
+}
+
+export interface HandleToolCallsPayload {
+  accumulatedCalls: any[];
+  currentContentBuffer: any[];
+  agentConfig: any;
+  messageId: string;
+  dialogId: string;
+  dialogKey?: string;
+  parallelSessionId?: string;
+  parallelBranchId?: string;
+  parallelLabel?: string;
+  parallelIndex?: number;
+}
+
+const processToolData = createAsyncThunk(
+  "message/processToolData",
+  async (args: ProcessToolDataPayload, thunkApi: AppThunkApi) => {
+    const { toolCall, parentMessageId, toolRunId } = args;
+    const { dispatch, rejectWithValue } = thunkApi;
+
+    const func = toolCall.function;
+    if (!func || !func.name) {
+      throw new Error(
+        "Invalid tool call data: missing function or function.name"
+      );
+    }
+
+    const toolCallId =
+      toolCall.id ||
+      `call_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+
+    const rawToolName = func.name;
+    let toolArgs = func.arguments;
+
+    const found = findToolExecutor(rawToolName);
+    const canonicalName = found.canonicalName;
+
+    const def = toolDefinitionsByName[canonicalName];
+    const behavior = def?.behavior;
+    const interaction = def?.interaction ?? "auto";
+
+    if (typeof toolArgs === "string") {
+      const cleaned = cleanToolArguments(toolArgs);
+      try {
+        toolArgs = JSON.parse(cleaned);
+      } catch (e) {
+        console.error(
+          "[ToolThunks/processToolData] toolArgs JSON.parse failed:",
+          toolArgs
+        );
+        throw new Error(`Failed to parse tool arguments JSON: ${e}`);
+      }
+    }
+
+    const inputSummary = JSON.stringify(toolArgs).slice(0, 400);
+
+    dispatch(
+      toolRunStarted({
+        id: toolRunId,
+        messageId: parentMessageId,
+        toolName: canonicalName,
+        behavior,
+        inputSummary,
+        interaction,
+        input: toolArgs,
+      })
+    );
+
+    // ========= 分支一：confirm / authorize 工具，走预览（暂停） =========
+    if (interaction === "confirm" || interaction === "authorize") {
+      try {
+        dispatch(toolRunSetPending({ id: toolRunId }));
+
+        const previewExecutor = def?.previewExecutor;
+        const previewResult = previewExecutor
+          ? await previewExecutor(toolArgs, thunkApi, { parentMessageId })
+          : {
+            rawData: {
+              previewOnly: true,
+              toolName: canonicalName,
+              interaction,
+            },
+          };
+
+        const rawData = previewResult?.rawData ?? previewResult;
+
+        const summary =
+          (typeof previewResult?.displayData === "string" &&
+            previewResult.displayData.trim()) ||
+          (interaction === "authorize"
+            ? `🔐 ${canonicalName} 需要授权后执行`
+            : `⚠️ ${canonicalName} 需要确认后执行`);
+
+        const toolPayload: ToolPayload = {
+          toolName: canonicalName,
+          status: "pending",
+          input: toolArgs,
+          rawToolCall: toolCall,
+          toolRunId,
+          summary,
+        };
+
+        return {
+          toolCallId,
+          rawResult: rawData,
+          summary,
+          toolName: canonicalName,
+          toolRunId,
+          toolPayload,
+          hasPendingInteraction: true, // ✅ 暂停点
+        };
+      } catch (e: any) {
+        const errorMessage = e?.message || String(e);
+        const structured = getToolResultErrorData(e);
+        const rawErrorResult =
+          structured?.rawData !== undefined ? structured.rawData : { error: errorMessage };
+        const summary =
+          (typeof structured?.displayData === "string" && structured.displayData.trim()) ||
+          `❌ ${canonicalName} 预览失败: ${errorMessage}`;
+
+        dispatch(
+          toolRunFailed({
+            id: toolRunId,
+            error: errorMessage,
+            outputSummary: summary,
+          })
+        );
+
+        const errorPayload: ToolErrorPayload = {
+          type: e?.name || "Error",
+          message: errorMessage,
+          code: structured?.code ?? e?.code,
+          retryable: structured?.retryable ?? e?.retryable ?? true,
+        };
+
+        const toolPayload: ToolPayload = {
+          toolName: canonicalName,
+          status: "failed",
+          input: toolArgs,
+          rawToolCall: toolCall,
+          error: errorPayload,
+          toolRunId,
+          summary,
+        };
+
+        return rejectWithValue({
+          toolCallId,
+          rawResult: rawErrorResult,
+          summary,
+          toolName: canonicalName,
+          toolRunId,
+          toolPayload,
+          hasPendingInteraction: true,
+        });
+      }
+    }
+
+    // ========= 分支二：auto 工具（包括 ui_ask_choice / readFile / createPlan 等） =========
+    try {
+      const toolResult = await found.executor(toolArgs, thunkApi, {
+        parentMessageId,
+        toolRunId,
+      });
+
+      const rawData = toolResult?.rawData ?? toolResult;
+      const llmContext =
+        typeof toolResult?.llmContext === "string" &&
+        toolResult.llmContext.trim()
+          ? toolResult.llmContext.trim()
+          : undefined;
+
+      const summary =
+        (typeof toolResult?.displayData === "string" &&
+          toolResult.displayData.trim()) ||
+        defaultSummary(canonicalName, "succeeded");
+
+      dispatch(
+        toolRunSucceeded({
+          id: toolRunId,
+          outputSummary: summary,
+        })
+      );
+
+      const toolPayload: ToolPayload = {
+        toolName: canonicalName,
+        status: "succeeded",
+        input: toolArgs,
+        rawToolCall: toolCall,
+        toolRunId,
+        summary,
+        ...(llmContext ? { llmContext } : {}),
+      };
+
+      // ✅ 关键：ui_ask_choice(blocking=true) 也视作“暂停点”
+      const isUiAskChoice = canonicalName === "ui_ask_choice";
+      const blocking =
+        typeof toolArgs?.blocking === "boolean"
+          ? toolArgs.blocking
+          : true; // schema 默认 true
+
+      const hasPendingInteraction =
+        isUiAskChoice && blocking === true;
+
+      return {
+        toolCallId,
+        rawResult: rawData,
+        summary,
+        toolName: canonicalName,
+        toolRunId,
+        toolPayload,
+        hasPendingInteraction,
+      };
+    } catch (e: any) {
+      const errorMessage = e?.message || String(e);
+      const structured = getToolResultErrorData(e);
+      const requiresConfirmation =
+        structured?.code === "self_evolution_requires_confirmation" ||
+        structured?.code === "agent_update_requires_confirmation";
+
+      if (requiresConfirmation) {
+        const confirmedInput = {
+          ...(toolArgs ?? {}),
+          __confirmedSelfEvolution: true,
+        };
+        const summary =
+          (typeof structured?.displayData === "string" &&
+            structured.displayData.trim()) ||
+          `⚠️ ${canonicalName} 需要确认后执行`;
+
+        dispatch(
+          toolRunStarted({
+            id: toolRunId,
+            messageId: parentMessageId,
+            toolName: canonicalName,
+            behavior,
+            inputSummary: JSON.stringify(confirmedInput).slice(0, 400),
+            interaction: "confirm",
+            input: confirmedInput,
+          })
+        );
+        dispatch(toolRunSetPending({ id: toolRunId }));
+
+        const toolPayload: ToolPayload = {
+          toolName: canonicalName,
+          status: "pending",
+          input: confirmedInput,
+          rawToolCall: toolCall,
+          toolRunId,
+          summary,
+        };
+
+        return {
+          toolCallId,
+          rawResult:
+            structured?.rawData !== undefined
+              ? structured.rawData
+              : { error: "self_evolution_requires_confirmation" },
+          summary,
+          toolName: canonicalName,
+          toolRunId,
+          toolPayload,
+          hasPendingInteraction: true,
+        };
+      }
+
+      const rawErrorResult =
+        structured?.rawData !== undefined ? structured.rawData : { error: errorMessage };
+      const summary =
+        (typeof structured?.displayData === "string" && structured.displayData.trim()) ||
+        `❌ ${canonicalName} 执行失败: ${errorMessage}`;
+
+      dispatch(
+        toolRunFailed({
+          id: toolRunId,
+          error: errorMessage,
+          outputSummary: summary,
+        })
+      );
+
+      const errorPayload: ToolErrorPayload = {
+        type: e?.name || "Error",
+        message: errorMessage,
+        code: structured?.code ?? e?.code,
+        retryable: structured?.retryable ?? e?.retryable ?? true,
+      };
+
+      const toolPayload: ToolPayload = {
+        toolName: canonicalName,
+        status: "failed",
+        input: toolArgs,
+        rawToolCall: toolCall,
+        error: errorPayload,
+        toolRunId,
+        summary,
+      };
+
+      return rejectWithValue({
+        toolCallId,
+        rawResult: rawErrorResult,
+        summary,
+        toolName: canonicalName,
+        toolRunId,
+        toolPayload,
+        hasPendingInteraction: false,
+      });
+    }
+  }
+);
+
+export const handleToolCalls = createAsyncThunk(
+  "message/handleToolCalls",
+  async (args: HandleToolCallsPayload, thunkApi: AppThunkApi) => {
+    const {
+      accumulatedCalls,
+      currentContentBuffer,
+      agentConfig,
+      messageId,
+      dialogId,
+      dialogKey,
+      parallelSessionId,
+      parallelBranchId,
+      parallelLabel,
+      parallelIndex,
+    } = args;
+
+    const { dispatch } = thunkApi;
+
+    const updatedContentBuffer = [...currentContentBuffer];
+    let hasHandedOff = false;
+    let hasPendingInteraction = false;
+
+    for (const toolCall of accumulatedCalls) {
+      if (!toolCall.function?.name) continue;
+
+      const toolCallId =
+        toolCall.id ||
+        `call_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+      const toolRunId = createToolRunId();
+      const canonicalToolName = findToolExecutor(toolCall.function.name).canonicalName;
+      const { key: runningToolDbKey, messageId: runningToolMessageId } =
+        createDialogMessageKeyAndId(dialogId);
+      const runningToolMessage: Message = {
+        id: runningToolMessageId,
+        dbKey: runningToolDbKey,
+        role: "tool",
+        content: JSON.stringify({ pending: true }),
+        toolCallId,
+        thinkContent: "",
+        cybotKey: agentConfig.dbKey,
+        isStreaming: true,
+        toolName: canonicalToolName,
+        parentMessageId: messageId,
+        toolRunId,
+        toolPayload: {
+          toolName: canonicalToolName,
+          status: "running",
+          input: {},
+          rawToolCall: toolCall,
+          toolRunId,
+          summary: defaultSummary(canonicalToolName, "running"),
+        },
+      };
+
+      dispatch(addToolMessage(runningToolMessage));
+
+      const { controller: _runningController, ...runningMessageToWrite } =
+        runningToolMessage as any;
+      await dispatch(
+        write({
+          data: { ...runningMessageToWrite, type: DataType.MSG },
+          customKey: runningToolDbKey,
+        })
+      );
+
+      try {
+        const result = await dispatch(
+          processToolData({
+            toolCall: { ...toolCall, id: toolCallId },
+            parentMessageId: messageId,
+            toolRunId,
+          })
+        ).unwrap();
+
+        const toolName = result.toolName;
+        let rawResult = result.rawResult;
+        let toolPayload = result.toolPayload;
+
+        if (toolName) {
+          if (toolName === "streamParallelAgents") {
+            const raw = (result.rawResult as any) ?? {};
+            const task =
+              typeof raw.task === "string" ? raw.task.trim() : "";
+            const agents = Array.isArray(raw.agents) ? raw.agents : [];
+            const returnMode =
+              raw.returnMode === "continue" ? "continue" : "handoff";
+            const displayMode = "inline";
+            const budgetCredits =
+              typeof raw.budgetCredits === "number" &&
+              Number.isFinite(raw.budgetCredits) &&
+              raw.budgetCredits > 0
+                ? raw.budgetCredits
+                : undefined;
+
+            if (task && agents.length > 0) {
+              const parallelResult = await startParallelAgentStreams({
+                task,
+                agents,
+                dispatch,
+                getState: thunkApi.getState,
+                dialogId,
+                dialogKey,
+                waitForCompletion: returnMode === "continue",
+                displayMode,
+                budgetCredits,
+              });
+
+              rawResult = parallelResult;
+
+              if (returnMode === "continue") {
+                const stats = (parallelResult as any)?.stats;
+                const budget = (parallelResult as any)?.budget;
+                const summary = stats
+                  ? `并行调用 ${stats.total} 个 Agent · ${stats.succeeded} 成功 · ${stats.failed} 失败 · 分支回答已展开${
+                      budget
+                        ? ` · 已花费 ${budget.spentCredits} / ${budget.budgetCredits} 积分`
+                        : ""
+                    }`
+                  : toolPayload?.summary || "并行调用已完成";
+
+                toolPayload = {
+                  ...toolPayload,
+                  summary,
+                  ...(typeof (parallelResult as any)?.llmContext === "string" &&
+                  (parallelResult as any).llmContext.trim()
+                    ? { llmContext: (parallelResult as any).llmContext.trim() }
+                    : {}),
+                };
+              } else {
+                hasHandedOff = true;
+              }
+            }
+          }
+
+          dispatch(
+            updateToolMessage({
+              id: runningToolMessageId,
+              changes: {
+                content: JSON.stringify(rawResult),
+                toolCallId: result.toolCallId,
+                isStreaming: false,
+                toolName,
+                toolRunId: result.toolRunId,
+                toolPayload,
+              },
+            })
+          );
+
+          await dispatch(
+            write({
+              data: {
+                ...runningMessageToWrite,
+                content: JSON.stringify(rawResult),
+                toolCallId: result.toolCallId,
+                isStreaming: false,
+                toolName,
+                toolRunId: result.toolRunId,
+                toolPayload,
+                type: DataType.MSG,
+              },
+              customKey: runningToolDbKey,
+            })
+          );
+
+          if (result.hasPendingInteraction) {
+            hasPendingInteraction = true;
+          }
+
+          // handoff 型工具：runStreamingAgent
+          if (toolName === "runStreamingAgent") {
+            const raw = (result.rawResult as any) ?? {};
+            const agentKey = raw.agentKey;
+            const userInput = raw.userInput;
+            const serverBase =
+              typeof raw.serverBase === "string" && raw.serverBase.trim()
+                ? raw.serverBase.trim()
+                : undefined;
+
+            if (agentKey && userInput) {
+              hasHandedOff = true;
+              void dispatch(
+                streamAgentChatTurn({
+                  agentKey,
+                  userInput,
+                  ...(dialogKey ? { dialogKey } : {}),
+                  ...(serverBase ? { serverBase } : {}),
+                  ...((parallelSessionId ||
+                    parallelBranchId ||
+                    parallelLabel ||
+                    parallelIndex !== undefined)
+                    ? {
+                        runtimeOptions: {
+                          ...(parallelSessionId ? { parallelSessionId } : {}),
+                          ...(parallelBranchId ? { parallelBranchId } : {}),
+                          ...(parallelLabel ? { parallelLabel } : {}),
+                          ...(parallelIndex !== undefined ? { parallelIndex } : {}),
+                        },
+                      }
+                    : {}),
+                })
+              );
+            }
+          }
+
+        }
+      } catch (rejectedValue: any) {
+        console.error(
+          "[ToolThunks/handleToolCalls] processToolData rejected:",
+          rejectedValue
+        );
+
+        if (rejectedValue.toolName) {
+          const errorResult = {
+            error: true,
+            message:
+              rejectedValue.toolPayload?.error?.message || "未知错误",
+          };
+          dispatch(
+            updateToolMessage({
+              id: runningToolMessageId,
+              changes: {
+                content: JSON.stringify(errorResult),
+                toolCallId: rejectedValue.toolCallId,
+                isStreaming: false,
+                toolName: rejectedValue.toolName,
+                toolRunId: rejectedValue.toolRunId,
+                toolPayload: rejectedValue.toolPayload,
+              },
+            })
+          );
+
+          await dispatch(
+            write({
+              data: {
+                ...runningMessageToWrite,
+                content: JSON.stringify(errorResult),
+                toolCallId: rejectedValue.toolCallId,
+                isStreaming: false,
+                toolName: rejectedValue.toolName,
+                toolRunId: rejectedValue.toolRunId,
+                toolPayload: rejectedValue.toolPayload,
+                type: DataType.MSG,
+              },
+              customKey: runningToolDbKey,
+            })
+          );
+
+          if (rejectedValue.hasPendingInteraction) {
+            hasPendingInteraction = true;
+          }
+        }
+      }
+    }
+
+    return {
+      finalContentBuffer: updatedContentBuffer,
+      hasHandedOff,
+      hasPendingInteraction,
+    };
+  }
+);