nolo-cli 0.1.40 → 0.1.42

package/chat/dialog/actions/handleSendMessageAction.ts

@@ -0,0 +1,202 @@
+// 文件路径: chat/dialog/actions/handleSendMessageAction.ts
+
+import type { RootState } from "../../../app/store";
+import type { AgentRuntimeOptions } from "../../../ai/agent/types";
+import {
+    messageStreamEnd,
+    prepareAndPersistUserMessage,
+} from "../../messages/messageSlice";
+import { streamAgentChatTurn } from "../../../ai/agent/agentSlice";
+import { readAndWait, selectById } from "../../../database/dbSlice";
+import type { DialogConfig } from "../../../app/types";
+import { createDialogMessageKeyAndId } from "../../../database/keys";
+import { extractCustomId } from "../../../core/prefix";
+import { resolveHandleSendMessageContext } from "./handleSendMessageResolver";
+
+export interface HandleSendMessageArgs {
+    userInput: string | any[];
+    dialogKey?: string;
+    runtimeOptions?: AgentRuntimeOptions;
+    /** 可选：本轮显式指定要调用的 Agent ID（来自 @mention） */
+    targetAgentKey?: string;
+    quickChatPerfStartedAt?: number;
+}
+
+interface HandleSendMessageThunkApi {
+    dispatch: any;
+    getState: () => RootState;
+    rejectWithValue: (value: unknown) => unknown;
+}
+
+const getDialogConfig = (
+    state: RootState,
+    dialogKey?: string
+): DialogConfig | null => {
+    const resolvedDialogKey = dialogKey ?? state.dialog?.currentDialogKey;
+    if (!resolvedDialogKey) return null;
+
+    const dialog = selectById(state, resolvedDialogKey) as DialogConfig | null;
+    return dialog ?? null;
+};
+
+const ensureDialogConfig = async (
+    dispatch: any,
+    getState: () => RootState,
+    dialogKey?: string
+): Promise<DialogConfig | null> => {
+    const state = getState();
+    const resolvedDialogKey = dialogKey ?? state.dialog?.currentDialogKey;
+    if (!resolvedDialogKey) return null;
+
+    try {
+        const existingDialog = getDialogConfig(state, resolvedDialogKey);
+        if (
+            existingDialog &&
+            Array.isArray(existingDialog.cybots) &&
+            existingDialog.cybots.length > 0
+        ) {
+            return existingDialog;
+        }
+
+        const persistedDialog = (await dispatch(readAndWait(resolvedDialogKey)).unwrap()) as DialogConfig;
+        if (persistedDialog) return persistedDialog;
+
+        return existingDialog;
+    } catch {
+        return getDialogConfig(getState(), resolvedDialogKey);
+    }
+};
+
+const logQuickChatPerfStage = (
+    startedAt: number | undefined,
+    stage: string,
+    details: Record<string, unknown> = {}
+) => {
+    if (!startedAt) return;
+    const now = typeof performance !== "undefined" ? performance.now() : Date.now();
+    console.info("[QuickChatPerf]", {
+        stage,
+        elapsedMs: now - startedAt,
+        ...(typeof performance !== "undefined" ? { atMs: now } : {}),
+        ...details,
+    });
+};
+
+const finalizeQuickChatStreamStartupFailure = async (
+    dispatch: any,
+    dialogConfig: DialogConfig,
+    agentKey: string,
+) => {
+    const dialogKey = dialogConfig.dbKey;
+    const dialogId = dialogConfig.id ?? extractCustomId(dialogKey);
+    const { key: msgKey, messageId } = createDialogMessageKeyAndId(dialogId);
+
+    await dispatch(
+        messageStreamEnd({
+            finalContentBuffer: [
+                {
+                    type: "text",
+                    text: "[错误: 未能启动模型回复，请重试。]",
+                },
+            ],
+            totalUsage: null,
+            msgKey,
+            agentConfig: {
+                dbKey: agentKey,
+            },
+            dialogId,
+            dialogKey,
+            messageId,
+            reasoningBuffer: "",
+        })
+    ).unwrap?.();
+};
+
+/**
+ * 发送用户消息（当前对话）：
+ * - 支持 runtimeOptions：用于为当前轮次额外注入工具 / 编辑上下文
+ * - 支持 targetAgentKey：本轮可显式指定要调用的 Agent（例如通过 @mention）
+ * - 默认行为不变：老调用只传 userInput 仍然有效
+ */
+export const handleSendMessageAction = async (
+    args: HandleSendMessageArgs,
+    { dispatch, getState, rejectWithValue }: HandleSendMessageThunkApi
+) => {
+    try {
+        logQuickChatPerfStage(args.quickChatPerfStartedAt, "handle-send-message-entered", {
+            dialogKey: args.dialogKey ?? null,
+        });
+        const dialogConfig = await ensureDialogConfig(dispatch, getState, args.dialogKey);
+        if (!dialogConfig) {
+            throw new Error(
+                "handleSendMessage: Dialog configuration is missing."
+            );
+        }
+        logQuickChatPerfStage(args.quickChatPerfStartedAt, "handle-send-message-dialog-ready", {
+            dialogKey: dialogConfig.dbKey,
+            cybotCount: dialogConfig.cybots?.length ?? 0,
+        });
+
+        // 步骤 1: 准备并持久化用户的消息
+        await dispatch(
+            prepareAndPersistUserMessage({
+                userInput: args.userInput,
+                dialogConfig,
+            })
+        ).unwrap();
+        logQuickChatPerfStage(args.quickChatPerfStartedAt, "handle-send-message-user-persisted", {
+            dialogKey: dialogConfig.dbKey,
+        });
+
+        // 步骤 2: 计算本轮要实际调用的 agentKey
+        const { agentKeyToUse, effectiveRuntimeOptions } =
+            resolveHandleSendMessageContext({
+                dialogConfig,
+                targetAgentKey: args.targetAgentKey,
+                runtimeOptions: args.runtimeOptions,
+            });
+
+        // 没有可用 Agent 时，只保存用户消息，不触发 Agent 回复
+        if (!agentKeyToUse) {
+            return;
+        }
+
+        // 步骤 3: 触发 Agent 的回合
+        const streamResult = await dispatch(
+            streamAgentChatTurn({
+                agentKey: agentKeyToUse,
+                userInput: args.userInput,
+                dialogKey: dialogConfig.dbKey,
+                parentMessageId: undefined,
+                runtimeOptions: effectiveRuntimeOptions,
+                quickChatPerfStartedAt: args.quickChatPerfStartedAt,
+            })
+        ).unwrap();
+        if (args.quickChatPerfStartedAt && streamResult === undefined) {
+            logQuickChatPerfStage(args.quickChatPerfStartedAt, "handle-send-message-stream-empty", {
+                dialogKey: dialogConfig.dbKey,
+                agentKey: agentKeyToUse,
+            });
+            await finalizeQuickChatStreamStartupFailure(
+                dispatch,
+                dialogConfig,
+                agentKeyToUse,
+            );
+            return;
+        }
+        logQuickChatPerfStage(args.quickChatPerfStartedAt, "handle-send-message-stream-finished", {
+            dialogKey: dialogConfig.dbKey,
+            agentKey: agentKeyToUse,
+        });
+
+        return;
+    } catch (error: any) {
+        console.error("handleSendMessage failed:", error);
+        const errorMessage = error instanceof Error
+            ? error.message
+            : typeof error === "string"
+            ? error
+            : error?.message || error?.error || String(error);
+        return rejectWithValue(errorMessage);
+    }
+};

package/chat/dialog/actions/handleSendMessageResolver.ts

@@ -0,0 +1,27 @@
+import type { AgentRuntimeOptions } from "../../../ai/agent/types";
+import {
+  PERSONALIZATION_DIALOG_CATEGORY,
+  buildPersonalizationRuntimeOptions,
+} from "../../../ai/policy/personalizationDialog";
+import type { DialogConfig } from "../../../app/types";
+import { getPrimaryDialogAgentId } from "../dialogAgents";
+
+export function resolveHandleSendMessageContext(input: {
+  dialogConfig: DialogConfig;
+  targetAgentKey?: string;
+  runtimeOptions?: AgentRuntimeOptions;
+}): {
+  agentKeyToUse?: string;
+  effectiveRuntimeOptions?: AgentRuntimeOptions;
+} {
+  const { dialogConfig, targetAgentKey, runtimeOptions } = input;
+  const defaultAgentKey = getPrimaryDialogAgentId(dialogConfig) ?? undefined;
+
+  return {
+    agentKeyToUse: targetAgentKey || defaultAgentKey,
+    effectiveRuntimeOptions:
+      dialogConfig.category === PERSONALIZATION_DIALOG_CATEGORY
+        ? buildPersonalizationRuntimeOptions(runtimeOptions)
+        : runtimeOptions,
+  };
+}

package/chat/dialog/actions/removeCybotAction.ts

@@ -0,0 +1,6 @@
+import { removeDialogAgentAction } from "./removeDialogAgentAction";
+
+export const removeCybotAction = async (
+  cybotId: string,
+  thunkApi: any // 使用 any 或具体类型
+) => removeDialogAgentAction(cybotId, thunkApi);

package/chat/dialog/actions/removeDialogAgentAction.ts

@@ -0,0 +1,44 @@
+import { patch, selectById } from "../../../database/dbSlice";
+import { formatISO } from "date-fns";
+import type { RootState } from "../../../app/store";
+import type { DialogConfig } from "../../../app/types";
+import {
+  getPrimaryDialogAgentId,
+  removeDialogAgentId,
+} from "../dialogAgents";
+import { cleanupCliSessionForDialog } from "./cleanupCliSession";
+
+export const removeDialogAgentAction = async (
+  agentId: string,
+  thunkApi: any,
+) => {
+  const { dispatch, getState } = thunkApi;
+  const state = getState() as RootState;
+  const currentDialogKey = state.dialog?.currentDialogKey;
+
+  if (!currentDialogKey) {
+    throw new Error("No current dialog selected");
+  }
+
+  const dialogConfig = selectById(
+    state,
+    currentDialogKey,
+  ) as DialogConfig | undefined;
+  if (!dialogConfig) {
+    throw new Error("Dialog configuration not found");
+  }
+
+  if (getPrimaryDialogAgentId(dialogConfig) === agentId) {
+    await cleanupCliSessionForDialog({ dispatch, getState }, dialogConfig);
+  }
+
+  return await dispatch(
+    patch({
+      dbKey: currentDialogKey,
+      changes: {
+        cybots: removeDialogAgentId(dialogConfig.cybots || [], agentId),
+        updatedAt: formatISO(new Date()),
+      },
+    }),
+  ).unwrap();
+};

package/chat/dialog/actions/replacePrimaryCybotAction.ts

@@ -0,0 +1,6 @@
+import { setPrimaryDialogAgentAction } from "./setPrimaryDialogAgentAction";
+
+export const replacePrimaryCybotAction = async (
+  cybotId: string,
+  thunkApi: any
+) => setPrimaryDialogAgentAction(cybotId, thunkApi);

package/chat/dialog/actions/setPrimaryDialogAgentAction.ts

@@ -0,0 +1,52 @@
+import { patch, selectById } from "../../../database/dbSlice";
+import { formatISO } from "date-fns";
+import type { RootState } from "../../../app/store";
+import type { DialogConfig } from "../../../app/types";
+import {
+  getPrimaryDialogAgentId,
+  replacePrimaryDialogAgentId,
+} from "../dialogAgents";
+import { cleanupCliSessionForDialog } from "./cleanupCliSession";
+
+export const setPrimaryDialogAgentAction = async (
+  agentId: string,
+  thunkApi: any,
+) => {
+  const { dispatch, getState } = thunkApi;
+  const state = getState() as RootState;
+  const currentDialogKey = state.dialog?.currentDialogKey;
+
+  if (!currentDialogKey) {
+    throw new Error("No current dialog selected");
+  }
+
+  if (!agentId || typeof agentId !== "string") {
+    throw new Error("No valid agent ID provided");
+  }
+
+  const dialogConfig = selectById(
+    state,
+    currentDialogKey,
+  ) as DialogConfig | undefined;
+  if (!dialogConfig) {
+    throw new Error("Dialog configuration not found");
+  }
+
+  const currentPrimaryAgentId = getPrimaryDialogAgentId(dialogConfig);
+  if (currentPrimaryAgentId && currentPrimaryAgentId !== agentId) {
+    await cleanupCliSessionForDialog({ dispatch, getState }, dialogConfig);
+  }
+
+  return await dispatch(
+    patch({
+      dbKey: currentDialogKey,
+      changes: {
+        cybots: replacePrimaryDialogAgentId(
+          dialogConfig.cybots || [],
+          agentId,
+        ),
+        updatedAt: formatISO(new Date()),
+      },
+    }),
+  ).unwrap();
+};