@amaster.ai/components-templates 1.4.11 → 1.6.0

package/components/ai-assistant-taro/template/hooks/useConversation.ts

@@ -0,0 +1,787 @@
+import type {
+  SendStreamingMessageResponse,
+  SendStreamingMessageSuccessResponse,
+} from "@a2a-js/sdk";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { client } from "../../../lib/client";
+import { useAiAssistantI18n } from "../i18n";
+import type {
+  Conversation,
+  ErrorMessage,
+  MessagesItem,
+  Role,
+  TextMessage,
+  ThoughtMessage,
+  ToolMessage,
+} from "../types";
+
+class SimpleAbortController {
+  aborted = false;
+  private listeners: (() => void)[] = [];
+
+  signal = {
+    aborted: false,
+    addEventListener: (_: "abort", cb: () => void) => {
+      this.listeners.push(cb);
+    },
+  };
+
+  abort() {
+    if (this.aborted) return;
+    this.aborted = true;
+    (this.signal as { aborted: boolean }).aborted = true;
+    this.listeners.forEach((cb) => {
+      cb();
+    });
+  }
+}
+
+function createAbortController(): AbortController | SimpleAbortController {
+  if (typeof AbortController !== "undefined") {
+    return new AbortController();
+  }
+  return new SimpleAbortController();
+}
+
+export interface UpdateMessageInput {
+  taskId: string;
+  messageId: string;
+  content?: string;
+  partial?: boolean;
+  status?: string;
+  response?: any;
+  metadata?: Record<string, any>;
+}
+
+// ================= 消息处理器 =================
+
+type MessageHandler = (
+  conv: Conversation,
+  part: any,
+  id: string,
+  role: Role,
+  status?: any,
+) => Conversation;
+
+const handlers: Record<string, MessageHandler> = {
+  "text-content": (conv, part, id, role, status) => {
+    if (!id) return conv;
+    const existing = conv.messages.find((m) => m.messageId === id);
+    const newText = part.text || "";
+    if (existing && "content" in existing) {
+      return {
+        ...conv,
+        messages: conv.messages.map((m) =>
+          m.messageId === id
+            ? { ...m, content: (m as TextMessage).content + newText }
+            : m,
+        ),
+        lastUpdated: new Date().toISOString(),
+      };
+    }
+
+    return {
+      ...conv,
+      messages: [
+        ...conv.messages,
+        {
+          messageId: id,
+          role,
+          kind: "text-content",
+          content: newText,
+          timestamp: status.timestamp || new Date().toISOString(),
+        } as TextMessage,
+      ],
+      lastUpdated: new Date().toISOString(),
+    };
+  },
+
+  // thought 类型（逐步追加 description）
+  thought: (conv, part, id, role, status) => {
+    if (!id) return conv;
+    const newChunk = part?.data?.description || "";
+    const existing = conv.messages.find((m) => m.messageId === id);
+    if (existing && "thought" in existing) {
+      return {
+        ...conv,
+        messages: conv.messages.map((m) =>
+          m.messageId === id
+            ? { ...m, thought: (m as ThoughtMessage).thought + newChunk }
+            : m,
+        ),
+        lastUpdated: new Date().toISOString(),
+      };
+    }
+
+    return {
+      ...conv,
+      messages: [
+        ...conv.messages,
+        {
+          messageId: id,
+          role,
+          kind: "thought",
+          thought: newChunk,
+          timestamp: status?.timestamp || new Date().toISOString(),
+        } as ThoughtMessage,
+      ],
+      lastUpdated: new Date().toISOString(),
+    };
+  },
+
+  // 工具调用（状态变更 + 最终结果）
+  tool: (conv, part, _id, role, status) => {
+    const partData = part?.data || {};
+    const tool = partData?.tool;
+    const name = tool?.displayName || tool?.name || "";
+    const request = partData?.request;
+    const id = request?.callId;
+    if (!id || !name) return conv; // 必须有 callId 来识别消息
+
+    const toolStatus = partData?.status;
+    const existing = conv.messages.find((m) => m.messageId === id);
+
+    if (existing && "toolStatus" in existing) {
+      return {
+        ...conv,
+        messages: conv.messages.map((m) =>
+          m.messageId === id
+            ? {
+                ...m,
+                toolStatus: toolStatus || (m as ToolMessage).toolStatus,
+              }
+            : m,
+        ),
+        lastUpdated: new Date().toISOString(),
+      };
+    }
+
+    return {
+      ...conv,
+      messages: [
+        ...conv.messages,
+        {
+          messageId: id,
+          role,
+          kind: "tool",
+          toolName: name,
+          toolDescription: request?.args?.query || "",
+          toolStatus: toolStatus || "pending",
+          timestamp: status?.timestamp || new Date().toISOString(),
+        } as ToolMessage,
+      ],
+      lastUpdated: new Date().toISOString(),
+    };
+  },
+
+  error: (conv, part, id, role) => {
+    const errorMsg = part?.text || part?.data?.error || "发生错误";
+    return {
+      ...conv,
+      messages: [
+        ...conv.messages,
+        {
+          messageId: id || `error-${Date.now()}`,
+          role,
+          kind: "error",
+          content: errorMsg,
+          timestamp: new Date().toISOString(),
+        } as ErrorMessage,
+      ],
+      status: "error",
+      lastUpdated: new Date().toISOString(),
+    };
+  },
+};
+
+// 用于生成唯一 assistant message id
+const generateId = () =>
+  `msg-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+
+// ================= 历史消息处理 =================
+
+interface HistoryState {
+  next: string | null;
+  hasMore: boolean;
+}
+
+interface HistoryMessage {
+  messageId: string;
+  historyId?: string;
+  role: string;
+  parts?: any[];
+}
+
+// ================= 主 Hook =================
+
+export function useConversationProcessor() {
+  const [conversationsMap, setConversationsMap] = useState<
+    Map<string, Conversation>
+  >(new Map());
+  const [isLoading, setIsLoading] = useState(false);
+  const [isLoadingHistory, setIsLoadingHistory] = useState(false);
+  const [historyState, setHistoryState] = useState<HistoryState>({
+    next: null,
+    hasMore: false,
+  });
+  const [starting, setStarting] = useState(true);
+  const { t } = useAiAssistantI18n();
+  const abortControllerRef = useRef<
+    AbortController | SimpleAbortController | null
+  >(null);
+  const forceStopRef = useRef(false);
+  const lastMessageTypeRef = useRef<string>("");
+  const lastMessageIdRef = useRef<string>("");
+  const currentStreamingTaskIdRef = useRef<string | null>(null);
+  const loadingRef = useRef(false);
+
+  useEffect(() => {
+    loadingRef.current = isLoading;
+  }, [isLoading]);
+
+  const handleEnd = useCallback(() => {
+    setIsLoading(false);
+    lastMessageTypeRef.current = "";
+    lastMessageIdRef.current = "";
+    currentStreamingTaskIdRef.current = null;
+  }, []);
+
+  const abort = useCallback(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+    forceStopRef.current = true;
+    setIsLoading(false);
+  }, []);
+
+  // 处理历史消息数据
+  const processHistoryData = useCallback(
+    (data: HistoryMessage, taskId: string) => {
+      const { messageId, historyId } = data || {};
+      if (!messageId) return;
+
+      const parts = data.parts || [];
+      const firstPart = parts?.[0];
+
+      let kind = "unknown";
+      if (firstPart?.data?.tool) {
+        kind = "tool";
+      } else if (firstPart?.data?.type === "ui") {
+        kind = "ui-render";
+      } else if (firstPart?.kind === "text") {
+        kind = "text-content";
+      } else if (firstPart?.data?.type === "though") {
+        kind = "thought";
+      }
+
+      const handler = handlers[kind];
+      if (!handler) {
+        return;
+      }
+
+      // 对于历史消息，我们需要用不同的方式处理
+      setConversationsMap((prev) => {
+        const prevConv = prev.get(taskId) ?? {
+          taskId,
+          status: "completed" as const,
+          messages: [],
+          historyId,
+          lastUpdated: new Date().toISOString(),
+        };
+
+        const role = data.role === "agent" ? "assistant" : "user";
+
+        const nextConv = handler(prevConv, firstPart, messageId, role, {
+          message: data,
+        });
+
+        const nextMap = new Map(prev);
+        nextMap.set(taskId, {
+          ...nextConv,
+          lastUpdated: new Date().toISOString(),
+        });
+        return nextMap;
+      });
+    },
+    [],
+  );
+
+  const processDataLine = useCallback((data: SendStreamingMessageResponse) => {
+    if (!(data as any)?.result) return;
+    const result = (data as SendStreamingMessageSuccessResponse).result;
+
+    const { taskId, status, metadata, final } = result as any;
+
+    if (final) {
+      handleEnd();
+      return;
+    }
+
+    if (!taskId) return;
+
+    const parts = status?.message?.parts || [];
+    const part = parts?.[0];
+
+    let kind = "unknown";
+    if (part?.data?.tool) {
+      kind = "tool";
+    } else if (part?.data?.type === "ui") {
+      kind = "ui-render";
+    } else if (part?.kind === "text") {
+      kind = "text-content";
+    } else if (
+      part?.data?.type === "though" ||
+      metadata?.coderAgent?.kind === "thought"
+    ) {
+      kind = "thought";
+    } else if (metadata?.error) {
+      kind = "error";
+    }
+
+    const handler = handlers[kind];
+    if (!handler) {
+      console.warn("Unhandled message type", result);
+      return;
+    }
+
+    if (kind && kind !== lastMessageTypeRef.current) {
+      lastMessageTypeRef.current = kind;
+      lastMessageIdRef.current = generateId();
+    }
+
+    removeLoadingPlaceholder();
+
+    setConversationsMap((prev) => {
+      const prevConv = prev.get(taskId) ?? {
+        taskId,
+        status: "submitted" as const,
+        messages: [],
+        lastUpdated: new Date().toISOString(),
+      };
+
+      const nextConv = handler(
+        prevConv,
+        part,
+        lastMessageIdRef.current,
+        (status?.message?.role === "agent" ? "assistant" : "") || "assistant",
+        status,
+      );
+
+      const nextMap = new Map(prev);
+
+      nextMap.set(taskId, {
+        ...nextConv,
+        status: status?.state || prevConv.status,
+        lastUpdated: new Date().toISOString(),
+      });
+      return nextMap;
+    });
+  }, []);
+
+  const conversations = useMemo(() => {
+    return Array.from(conversationsMap.values());
+  }, [conversationsMap]);
+
+  const getConversation = useCallback(
+    (taskId: string) => {
+      return conversationsMap.get(taskId);
+    },
+    [conversationsMap],
+  );
+
+  const clearConversation = useCallback((taskId: string) => {
+    setConversationsMap((prev) => {
+      if (!prev.has(taskId)) return prev;
+      const next = new Map(prev);
+      next.delete(taskId);
+      return next;
+    });
+  }, []);
+
+  const removeMessage = useCallback((taskId: string, messageId: string) => {
+    setConversationsMap((prev) => {
+      const conv = prev.get(taskId);
+      if (!conv) return prev;
+
+      const nextConv = {
+        ...conv,
+        messages: conv.messages.filter((m) => m.messageId !== messageId),
+      };
+
+      const nextMap = new Map(prev);
+      nextMap.set(taskId, nextConv);
+      return nextMap;
+    });
+  }, []);
+
+  // 新增：更新已有消息
+  const updateMessage = useCallback((input: UpdateMessageInput) => {
+    const {
+      taskId,
+      messageId,
+      content,
+      partial = false,
+      status,
+      response,
+      metadata = {},
+    } = input;
+
+    setConversationsMap((prev) => {
+      const conv = prev.get(taskId);
+      if (!conv) return prev;
+
+      const msgIndex = conv.messages.findIndex(
+        (m) => m.messageId === messageId,
+      );
+      if (msgIndex === -1) {
+        console.warn(
+          `Message ${messageId} not found in conversation ${taskId}`,
+        );
+        return prev;
+      }
+
+      const oldMsg = conv.messages[msgIndex];
+      const updatedMsg: MessagesItem = { ...oldMsg, ...metadata };
+
+      // 处理文本 / thought 内容更新
+      if (content !== undefined) {
+        if ("content" in updatedMsg) {
+          updatedMsg.content = partial
+            ? (updatedMsg as TextMessage).content + content
+            : content;
+        } else if ("thought" in updatedMsg) {
+          updatedMsg.thought = partial
+            ? (updatedMsg as ThoughtMessage).thought + content
+            : content;
+        } else if (oldMsg.kind === "text-content") {
+          // 兼容旧消息类型
+          (updatedMsg as any).content = partial
+            ? ((oldMsg as any).content || "") + content
+            : content;
+        }
+      }
+
+      // 处理 tool 消息的特殊字段
+      if ("toolStatus" in updatedMsg || status) {
+        (updatedMsg as any).toolStatus =
+          status || (updatedMsg as any).toolStatus;
+      }
+      if (response !== undefined) {
+        (updatedMsg as any).response = response;
+      }
+
+      const nextMessages = [...conv.messages];
+      nextMessages[msgIndex] = updatedMsg;
+
+      const nextConv: Conversation = {
+        ...conv,
+        messages: nextMessages,
+        lastUpdated: new Date().toISOString(),
+      };
+
+      const nextMap = new Map(prev);
+      nextMap.set(taskId, nextConv);
+      return nextMap;
+    });
+  }, []);
+
+  const addConversation = useCallback((conversation: Conversation) => {
+    setConversationsMap((prev) => {
+      const nextMap = new Map(prev);
+      const id = conversation.taskId;
+      nextMap.set(id, conversation);
+      return nextMap;
+    });
+  }, []);
+
+  const addLoadingPlaceholder = useCallback(() => {
+    addConversation({
+      taskId: "loading-placeholder",
+      status: "working",
+      messages: [
+        {
+          messageId: "loading-placeholder",
+          role: "assistant",
+          kind: "text-content",
+          content: t.thinking,
+          timestamp: new Date().toISOString(),
+        },
+      ],
+      lastUpdated: new Date().toISOString(),
+    });
+  }, [t.thinking]);
+
+  useEffect(() => {
+    if (!isLoading) {
+      removeLoadingPlaceholder();
+    }
+  }, [isLoading]);
+
+  const removeLoadingPlaceholder = useCallback(() => {
+    clearConversation("loading-placeholder");
+  }, []);
+
+  // 发送用户消息，启动流式对话
+  const sendMessage = useCallback(
+    async (userContent: string, _placeholderText?: string) => {
+      if (!userContent.trim()) return;
+
+      const taskId = `conv-${Date.now()}`;
+
+      // 添加用户消息
+      const userMsgId = generateId();
+
+      addConversation({
+        taskId,
+        status: "submitted",
+        messages: [
+          {
+            messageId: userMsgId,
+            role: "user",
+            kind: "text-content",
+            content: userContent,
+            timestamp: new Date().toISOString(),
+          },
+        ],
+        lastUpdated: new Date().toISOString(),
+      });
+
+      addLoadingPlaceholder();
+
+      setIsLoading(true);
+
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+      abortControllerRef.current = createAbortController();
+      const controller = abortControllerRef.current;
+
+      forceStopRef.current = false;
+
+      try {
+        const stream = client.copilot.chat([
+          { role: "user", content: userContent },
+        ]);
+
+        for await (const chunk of stream) {
+          if (controller?.signal.aborted || forceStopRef.current) break;
+
+          // 根据你的实际 stream 返回格式调整
+          processDataLine(chunk);
+
+          // 检查是否结束
+          if ((chunk as any)?.isFinal || (chunk as any)?.final) {
+            break;
+          }
+        }
+      } catch (err: any) {
+        if (err.name === "AbortError" || forceStopRef.current) {
+          console.log("[Chat] Request aborted");
+        } else {
+          console.error("[Chat] Stream error:", err);
+          const id = generateId();
+          addConversation({
+            taskId: id,
+            status: "error",
+            messages: [
+              {
+                messageId: `error-${Date.now()}`,
+                role: "assistant",
+                kind: "error",
+                content: t.errorMessage,
+                timestamp: new Date().toISOString(),
+              } as ErrorMessage,
+            ],
+            lastUpdated: new Date().toISOString(),
+          });
+        }
+      } finally {
+        setIsLoading(false);
+        if (abortControllerRef.current === controller) {
+          abortControllerRef.current = null;
+        }
+      }
+    },
+    [processDataLine],
+  );
+
+  const resetConversation = useCallback(
+    (welcome?: string) => {
+      abort();
+
+      setConversationsMap(new Map());
+      setIsLoading(false);
+      setHistoryState({ next: null, hasMore: false });
+
+      if (welcome) {
+        const taskId = `conv-${Date.now()}`;
+        setConversationsMap(
+          new Map([
+            [
+              taskId,
+              {
+                taskId,
+                status: "submitted",
+                messages: [
+                  {
+                    messageId: `greeting-${Date.now()}`,
+                    role: "assistant",
+                    kind: "text-content",
+                    content: welcome,
+                    timestamp: new Date().toISOString(),
+                  } as TextMessage,
+                ],
+                lastUpdated: new Date().toISOString(),
+              },
+            ],
+          ]),
+        );
+      }
+    },
+    [abort],
+  );
+
+  const loadHistory = useCallback(
+    async (limit = 20, next?: string) => {
+      setIsLoadingHistory(true);
+      try {
+        const copilot = client.copilot as any;
+        const result = await copilot.getHistory?.(limit, next);
+        const messages: HistoryMessage[] = result?.messages || [];
+
+        let taskId = "";
+        let lastRole = "";
+        const taskIds: string[] = [];
+
+        messages.forEach((msg) => {
+          const role = msg.role === "agent" ? "assistant" : "user";
+          if (role !== lastRole) {
+            taskId = `history-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            taskIds.push(taskId);
+            lastRole = role;
+          }
+          processHistoryData(msg, taskId);
+        });
+
+        setHistoryState({
+          next: result?.next || null,
+          hasMore: result?.hasMore || false,
+        });
+
+        return { taskIds, hasMore: result?.hasMore || false };
+      } catch (error) {
+        console.error("[Chat] Failed to load history:", error);
+        return { taskIds: [], hasMore: false };
+      } finally {
+        setIsLoadingHistory(false);
+      }
+    },
+    [processHistoryData],
+  );
+
+  const loadMoreHistory = useCallback(async () => {
+    if (!historyState.hasMore || isLoadingHistory || !historyState.next) return;
+    await loadHistory(20, historyState.next || undefined);
+  }, [historyState.hasMore, historyState.next, isLoadingHistory, loadHistory]);
+
+  const checkActiveTask = useCallback(async () => {
+    try {
+      const result = await client.copilot.getChatStatus();
+      const taskId = result.taskId;
+      if (taskId && result.working) {
+        currentStreamingTaskIdRef.current = taskId;
+        setIsLoading(true);
+
+        const stream = await client.copilot.chat([], { taskId });
+        for await (const chunk of stream) {
+          if (forceStopRef.current) break;
+          processDataLine(chunk);
+        }
+      }
+    } catch (error) {
+      console.error("[Chat] Failed to check active task:", error);
+    }
+  }, [processDataLine]);
+
+  const cancelChat = useCallback(async () => {
+    abort();
+
+    const targetTaskId = currentStreamingTaskIdRef.current;
+    if (!targetTaskId) return;
+
+    addConversation({
+      taskId: generateId(),
+      status: "completed",
+      messages: [
+        {
+          messageId: `cancel-${Date.now()}`,
+          role: "assistant",
+          kind: "text-content",
+          content: t.cancelled,
+          timestamp: new Date().toISOString(),
+        } as TextMessage,
+      ],
+      lastUpdated: new Date().toISOString(),
+    });
+
+    try {
+      await client.copilot.cancelChat(targetTaskId);
+      currentStreamingTaskIdRef.current = null;
+    } catch (error) {
+      console.error("[Chat] Failed to cancel chat:", error);
+    }
+  }, [abort, addConversation, t.cancelled]);
+
+  const startNewConversation = useCallback(async () => {
+    addConversation({
+      taskId: generateId(),
+      status: "submitted",
+      messages: [],
+      lastUpdated: new Date().toISOString(),
+      system: { level: "newConversation" },
+    });
+    try {
+      const copilot = client.copilot as any;
+      await copilot.newConversation?.();
+    } catch (error) {
+      console.error("[Chat] Failed to create new conversation:", error);
+    }
+  }, [addConversation]);
+
+  useEffect(() => {
+    if (starting) {
+      const init = async () => {
+        console.log("[Chat] Initializing conversation...");
+        try {
+          await loadHistory();
+          await checkActiveTask();
+        } catch (error) {
+          console.log("[Chat] Initialization error:", error);
+        }
+        setStarting(false);
+      };
+      init();
+    }
+  }, [starting]);
+
+  return {
+    starting,
+    isLoading,
+    isLoadingHistory,
+    historyState,
+    conversations,
+    sendMessage,
+    abort,
+    cancelChat,
+    resetConversation,
+    startNewConversation,
+    loadHistory,
+    loadMoreHistory,
+    processDataLine,
+    getConversation,
+    clearConversation,
+    removeMessage,
+    updateMessage,
+  };
+}