@amaster.ai/components-templates 1.6.0 → 1.8.0

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

@@ -1,9 +1,12 @@
 import type {
+  Message1,
   SendStreamingMessageResponse,
   SendStreamingMessageSuccessResponse,
+  TextPart,
 } from "@a2a-js/sdk";
+import { produce } from "immer";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { client } from "../../../lib/client";
+import { client } from "@/lib/client";
 import { useAiAssistantI18n } from "../i18n";
 import type {
   Conversation,
@@ -13,8 +16,32 @@ import type {
   TextMessage,
   ThoughtMessage,
   ToolMessage,
+  UIRenderMessage,
 } from "../types";
 
+interface HistoryState {
+  next: string | null;
+  hasMore: boolean;
+}
+
+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;
+
 class SimpleAbortController {
   aborted = false;
   private listeners: (() => void)[] = [];
@@ -43,26 +70,6 @@ function createAbortController(): AbortController | SimpleAbortController {
   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;
@@ -96,7 +103,6 @@ const handlers: Record<string, MessageHandler> = {
     };
   },
 
-  // thought 类型（逐步追加 description）
   thought: (conv, part, id, role, status) => {
     if (!id) return conv;
     const newChunk = part?.data?.description || "";
@@ -129,14 +135,13 @@ const handlers: Record<string, MessageHandler> = {
     };
   },
 
-  // 工具调用（状态变更 + 最终结果）
   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 来识别消息
+    if (!id || !name) return conv;
 
     const toolStatus = partData?.status;
     const existing = conv.messages.find((m) => m.messageId === id);
@@ -174,7 +179,7 @@ const handlers: Record<string, MessageHandler> = {
     };
   },
 
-  error: (conv, part, id, role) => {
+  error: (conv, part, id, role, _status) => {
     const errorMsg = part?.text || part?.data?.error || "发生错误";
     return {
       ...conv,
@@ -192,60 +197,92 @@ const handlers: Record<string, MessageHandler> = {
       lastUpdated: new Date().toISOString(),
     };
   },
-};
 
-// 用于生成唯一 assistant message id
-const generateId = () =>
-  `msg-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+  "ui-render": (conv, part, id, role, status) => {
+    if (!id) return conv;
+    const existing = conv.messages.find((m) => m.messageId === id);
+    const partData = part?.data || {};
+    const spec = partData.spec || { root: "", elements: {} };
 
-// ================= 历史消息处理 =================
+    if (existing && existing.kind === "ui-render") {
+      return {
+        ...conv,
+        messages: conv.messages.map((m) =>
+          m.messageId === id ? { ...(m as UIRenderMessage), spec } : m,
+        ),
+        lastUpdated: new Date().toISOString(),
+      };
+    }
 
-interface HistoryState {
-  next: string | null;
-  hasMore: boolean;
-}
+    return {
+      ...conv,
+      messages: [
+        ...conv.messages,
+        {
+          messageId: id,
+          role,
+          kind: "ui-render",
+          spec,
+          timestamp: status?.timestamp || new Date().toISOString(),
+        } as UIRenderMessage,
+      ],
+      lastUpdated: new Date().toISOString(),
+    };
+  },
+};
 
-interface HistoryMessage {
-  messageId: string;
-  historyId?: string;
-  role: string;
-  parts?: any[];
-}
+const getKind = (part: any, metadata?: any) => {
+  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";
+  }
+  return kind;
+};
+
+const generateId = () =>
+  `msg-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
 
-// ================= 主 Hook =================
+type ConversationsState = {
+  byId: Record<string, Conversation>;
+  order: string[];
+};
 
-export function useConversationProcessor() {
-  const [conversationsMap, setConversationsMap] = useState<
-    Map<string, Conversation>
-  >(new Map());
+export function useConversation() {
+  const [state, setState] = useState<ConversationsState>({
+    byId: {},
+    order: [],
+  });
   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 loadingRef = useRef(false);
+  const abortControllerRef = useRef<any>(null);
   const forceStopRef = useRef(false);
-  const lastMessageTypeRef = useRef<string>("");
+  const lastMessageTypeRef = useRef<string>("unknown");
   const lastMessageIdRef = useRef<string>("");
+  const lastMessageRoleRef = useRef<Role | string>("");
   const currentStreamingTaskIdRef = useRef<string | null>(null);
-  const loadingRef = useRef(false);
+  const [starting, setStarting] = useState(true);
+  const {t} = useAiAssistantI18n();
 
   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();
@@ -255,167 +292,218 @@ export function useConversationProcessor() {
     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;
-      }
+  const handleEnd = useCallback(() => {
+    abort();
+    lastMessageTypeRef.current = "";
+    lastMessageIdRef.current = "";
+    lastMessageRoleRef.current = "";
+    currentStreamingTaskIdRef.current = null;
+  }, [abort]);
+
+  // 填充数据到 conversation 中
+  const fillData = ({
+    kind,
+    taskId,
+    part,
+    status,
+    handler,
+    isHistory,
+    historyId,
+    messageId,
+  }: {
+    kind: string;
+    taskId: string;
+    part: any;
+    status: any;
+    handler: MessageHandler;
+    isHistory?: boolean;
+    historyId?: string;
+    messageId?: string;
+  }) => {
+    setState(
+      produce((draft) => {
+        let id = messageId || lastMessageIdRef.current;
+        const role = status?.message?.role === "agent" ? "assistant" : "user";
+
+        if (
+          !messageId &&
+          (kind === "ui-render" ||
+            (kind !== "unknown" && kind !== lastMessageTypeRef.current))
+        ) {
+          lastMessageTypeRef.current = kind;
+          id = generateId();
+          lastMessageIdRef.current = id;
+        }
 
-      // 对于历史消息，我们需要用不同的方式处理
-      setConversationsMap((prev) => {
-        const prevConv = prev.get(taskId) ?? {
+        const prevConv = draft.byId[taskId] ?? {
           taskId,
-          status: "completed" as const,
+          status: isHistory ? "completed" : "submitted",
           messages: [],
+          role,
           historyId,
           lastUpdated: new Date().toISOString(),
         };
 
-        const role = data.role === "agent" ? "assistant" : "user";
-
-        const nextConv = handler(prevConv, firstPart, messageId, role, {
-          message: data,
-        });
+        const nextConv = handler(prevConv, part, id, role, status);
 
-        const nextMap = new Map(prev);
-        nextMap.set(taskId, {
+        draft.byId[taskId] = {
           ...nextConv,
+          status: status?.state || prevConv.status,
           lastUpdated: new Date().toISOString(),
-        });
-        return nextMap;
-      });
-    },
-    [],
-  );
+        };
 
-  const processDataLine = useCallback((data: SendStreamingMessageResponse) => {
-    if (!(data as any)?.result) return;
-    const result = (data as SendStreamingMessageSuccessResponse).result;
+        const index = draft.order.indexOf(taskId);
+        if (index !== -1) {
+          draft.order.splice(index, 1);
+        }
 
-    const { taskId, status, metadata, final } = result as any;
+        if (!isHistory) {
+          draft.order.push(taskId);
+        }
+      }),
+    );
+  };
 
-    if (final) {
-      handleEnd();
-      return;
-    }
+  // 处理实时数据
+  const processLiveData = useCallback(
+    (data: SendStreamingMessageResponse) => {
+      if (!(data as any)?.result) return;
+      const result = (data as SendStreamingMessageSuccessResponse).result;
 
-    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 { taskId, status, metadata, final } = result as any;
 
-    const handler = handlers[kind];
-    if (!handler) {
-      console.warn("Unhandled message type", result);
-      return;
-    }
+      if (final) {
+        handleEnd();
+        return;
+      }
 
-    if (kind && kind !== lastMessageTypeRef.current) {
-      lastMessageTypeRef.current = kind;
-      lastMessageIdRef.current = generateId();
-    }
+      if (!taskId) return;
 
-    removeLoadingPlaceholder();
+      currentStreamingTaskIdRef.current = taskId;
 
-    setConversationsMap((prev) => {
-      const prevConv = prev.get(taskId) ?? {
-        taskId,
-        status: "submitted" as const,
-        messages: [],
-        lastUpdated: new Date().toISOString(),
-      };
+      const parts = status?.message?.parts || [];
+      const firstPart = parts?.[0];
+      const kind = getKind(firstPart, metadata);
+
+      const handler = handlers[kind];
+      if (!handler) {
+        return;
+      }
+      removeLoadingPlaceholder();
 
-      const nextConv = handler(
-        prevConv,
-        part,
-        lastMessageIdRef.current,
-        (status?.message?.role === "agent" ? "assistant" : "") || "assistant",
+      fillData({
+        kind,
+        taskId,
+        part: firstPart,
         status,
-      );
+        handler,
+      });
+    },
+    [handleEnd],
+  );
 
-      const nextMap = new Map(prev);
+  const processHistoryData = useCallback(
+    (data: Message1, taskId: string) => {
+      const { messageId, historyId } = (data || {}) as any;
+      if (!messageId) return;
 
-      nextMap.set(taskId, {
-        ...nextConv,
-        status: status?.state || prevConv.status,
-        lastUpdated: new Date().toISOString(),
+      const parts = data.parts || [];
+      const firstPart = parts?.[0];
+
+      const kind = getKind(firstPart);
+
+      if (kind === "text-content") {
+        let text = (firstPart as TextPart).text || "";
+        text = text.trim();
+        if (text.startsWith("<ui>")) {
+          const json = text.slice(4).trim();
+          try {
+            const partData = JSON.parse(json);
+            if (partData.root && partData.elements) {
+              fillData({
+                kind: 'ui-render',
+                taskId,
+                part: { kind: 'data', data: { type: "ui", spec: partData } },
+                handler: handlers['ui-render'],
+                isHistory: true,
+                historyId,
+                messageId,
+                status: { message: data },
+              });
+            }
+          } catch (error) {
+            // 解析失败，有可能是半截
+          }
+          return;
+        }
+      }
+
+      const handler = handlers[kind];
+      if (!handler) {
+        return;
+      }
+      fillData({
+        kind,
+        taskId,
+        part: firstPart,
+        handler,
+        isHistory: true,
+        historyId,
+        messageId,
+        status: { message: data },
       });
-      return nextMap;
-    });
-  }, []);
+    },
+    [handleEnd],
+  );
 
   const conversations = useMemo(() => {
-    return Array.from(conversationsMap.values());
-  }, [conversationsMap]);
+    return state.order
+      .map((id) => state.byId[id])
+      .filter(Boolean) as Conversation[];
+  }, [state]);
 
   const getConversation = useCallback(
     (taskId: string) => {
-      return conversationsMap.get(taskId);
+      return state.byId[taskId];
     },
-    [conversationsMap],
+    [state],
   );
 
   const clearConversation = useCallback((taskId: string) => {
-    setConversationsMap((prev) => {
-      if (!prev.has(taskId)) return prev;
-      const next = new Map(prev);
-      next.delete(taskId);
-      return next;
-    });
+    setState(
+      produce((draft) => {
+        if (!draft.byId[taskId]) return;
+        delete draft.byId[taskId];
+        draft.order = draft.order.filter((id) => id !== taskId);
+      }),
+    );
   }, []);
 
   const removeMessage = useCallback((taskId: string, messageId: string) => {
-    setConversationsMap((prev) => {
-      const conv = prev.get(taskId);
-      if (!conv) return prev;
+    setState(
+      produce((draft) => {
+        const conv = draft.byId[taskId];
+        if (!conv) return;
 
-      const nextConv = {
-        ...conv,
-        messages: conv.messages.filter((m) => m.messageId !== messageId),
-      };
+        const nextMessages = conv.messages.filter(
+          (m) => m.messageId !== messageId,
+        );
 
-      const nextMap = new Map(prev);
-      nextMap.set(taskId, nextConv);
-      return nextMap;
-    });
+        draft.byId[taskId] = {
+          ...conv,
+          messages: nextMessages,
+          lastUpdated: new Date().toISOString(),
+        };
+
+        const index = draft.order.indexOf(taskId);
+        if (index !== -1) {
+          draft.order.splice(index, 1);
+        }
+        draft.order.push(taskId);
+      }),
+    );
   }, []);
 
-  // 新增：更新已有消息
   const updateMessage = useCallback((input: UpdateMessageInput) => {
     const {
       taskId,
@@ -427,72 +515,75 @@ export function useConversationProcessor() {
       metadata = {},
     } = input;
 
-    setConversationsMap((prev) => {
-      const conv = prev.get(taskId);
-      if (!conv) return prev;
+    setState(
+      produce((draft) => {
+        const conv = draft.byId[taskId];
+        if (!conv) return;
 
-      const msgIndex = conv.messages.findIndex(
-        (m) => m.messageId === messageId,
-      );
-      if (msgIndex === -1) {
-        console.warn(
-          `Message ${messageId} not found in conversation ${taskId}`,
+        const msgIndex = conv.messages.findIndex(
+          (m) => m.messageId === messageId,
         );
-        return prev;
-      }
+        if (msgIndex === -1) {
+          return;
+        }
 
-      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;
+        const oldMsg = conv.messages[msgIndex];
+        const updatedMsg: MessagesItem = { ...oldMsg, ...metadata };
+
+        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;
-      }
+        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 nextMessages = [...conv.messages];
+        nextMessages[msgIndex] = updatedMsg;
 
-      const nextConv: Conversation = {
-        ...conv,
-        messages: nextMessages,
-        lastUpdated: new Date().toISOString(),
-      };
+        draft.byId[taskId] = {
+          ...conv,
+          messages: nextMessages,
+          lastUpdated: new Date().toISOString(),
+        };
 
-      const nextMap = new Map(prev);
-      nextMap.set(taskId, nextConv);
-      return nextMap;
-    });
+        const index = draft.order.indexOf(taskId);
+        if (index !== -1) {
+          draft.order.splice(index, 1);
+        }
+        draft.order.push(taskId);
+      }),
+    );
   }, []);
 
   const addConversation = useCallback((conversation: Conversation) => {
-    setConversationsMap((prev) => {
-      const nextMap = new Map(prev);
-      const id = conversation.taskId;
-      nextMap.set(id, conversation);
-      return nextMap;
-    });
+    setState(
+      produce((draft) => {
+        const id = conversation.taskId;
+        draft.byId[id] = conversation;
+        const index = draft.order.indexOf(id);
+        if (index !== -1) {
+          draft.order.splice(index, 1);
+        }
+        draft.order.push(id);
+      }),
+    );
   }, []);
 
   const addLoadingPlaceholder = useCallback(() => {
@@ -510,260 +601,288 @@ export function useConversationProcessor() {
       ],
       lastUpdated: new Date().toISOString(),
     });
-  }, [t.thinking]);
+  }, [addConversation]);
+
+  const removeLoadingPlaceholder = useCallback(() => {
+    clearConversation("loading-placeholder");
+  }, [clearConversation]);
 
   useEffect(() => {
     if (!isLoading) {
       removeLoadingPlaceholder();
     }
-  }, [isLoading]);
+  }, [isLoading, removeLoadingPlaceholder]);
 
-  const removeLoadingPlaceholder = useCallback(() => {
-    clearConversation("loading-placeholder");
+  const onSendError = useCallback(() => {
+    addConversation({
+      taskId: generateId(),
+      status: "error",
+      messages: [
+        {
+          messageId: `error-${Date.now()}`,
+          role: "assistant",
+          kind: "error",
+          content: t.errorMessage,
+          timestamp: new Date().toISOString(),
+        } as ErrorMessage,
+      ],
+      lastUpdated: new Date().toISOString(),
+    });
+    setIsLoading(false);
+  }, [addConversation]);
+
+  const loadHistory = useCallback(async (limit = 20, next?: string) => {
+    setIsLoadingHistory(true);
+    let scrollToId = "";
+    try {
+      const copilot = client.copilot as any;
+      const result = await copilot.getHistory?.(limit, next);
+      const messages = result?.messages || [];
+      const length = messages.length;
+      scrollToId = length > 0 ? messages?.[length - 1]?.messageId : "";
+
+      let taskId = "";
+      let lastRole = "";
+      const taskIds: string[] = [];
+      messages.forEach((msg: any) => {
+        const role = msg.role === "agent" ? "assistant" : "user";
+        if (role !== lastRole) {
+          taskId = `history-conv-${generateId()}`;
+          taskIds.push(taskId);
+          lastRole = role;
+        }
+        processHistoryData(msg, taskId);
+      });
+      setState(
+        produce((draft) => {
+          draft.order = [...taskIds, ...draft.order];
+        }),
+      );
+      setHistoryState({
+        next: result?.next || null,
+        hasMore: result?.hasMore || false,
+      });
+    } catch (error) {
+      console.error("[Chat] Failed to load history:", error);
+    } finally {
+      setIsLoadingHistory(false);
+      scrollToId &&
+        next &&
+        setTimeout(() => {
+          document
+            .querySelector(`[data-conversation-message-id="${scrollToId}"]`)
+            ?.scrollIntoView({ behavior: "instant", block: "center" });
+        }, 20);
+    }
   }, []);
 
-  // 发送用户消息，启动流式对话
-  const sendMessage = useCallback(
-    async (userContent: string, _placeholderText?: string) => {
-      if (!userContent.trim()) return;
+  const loadMoreHistory = useCallback(async () => {
+    if (!historyState.hasMore || isLoadingHistory || !historyState.next) return;
+    await loadHistory(20, historyState.next);
+  }, [historyState.hasMore, historyState.next, isLoadingHistory]);
 
-      const taskId = `conv-${Date.now()}`;
+  const checkActiveTask = useCallback(async () => {
+    try {
+      const result = await client.copilot.getChatStatus();
+      const taskId = result.taskId;
+      if (taskId && result.working) {
+        currentStreamingTaskIdRef.current = taskId;
 
-      // 添加用户消息
-      const userMsgId = generateId();
+        const stream = await client.copilot.chat([], { taskId });
+        for await (const chunk of stream) {
+          if (forceStopRef.current) break;
+          processLiveData(chunk);
+        }
+      }
+    } catch (error) {
+      console.error("[Chat] Failed to check active task:", error);
+    }
+  }, [processLiveData]);
 
+  const cancelChat = useCallback(
+    async (taskId?: string) => {
+      abort();
       addConversation({
-        taskId,
-        status: "submitted",
+        taskId: generateId(),
+        status: "error",
         messages: [
           {
-            messageId: userMsgId,
-            role: "user",
+            messageId: `cancel-${Date.now()}`,
+            role: "assistant",
             kind: "text-content",
-            content: userContent,
+            content: t.cancelled,
             timestamp: new Date().toISOString(),
-          },
+          } as TextMessage,
         ],
         lastUpdated: new Date().toISOString(),
       });
+      const targetTaskId = taskId || currentStreamingTaskIdRef.current;
+      if (!targetTaskId) return;
 
-      addLoadingPlaceholder();
+      try {
+        await client.copilot.cancelChat(targetTaskId);
+        currentStreamingTaskIdRef.current = null;
+      } catch (error) {
+        console.error("[Chat] Failed to cancel chat:", error);
+      }
+    },
+    [abort],
+  );
 
-      setIsLoading(true);
+  const resetConversation = useCallback(
+    (greeting?: string) => {
+      abort();
+      setState({ byId: {}, order: [] });
+      currentStreamingTaskIdRef.current = null;
+
+      if (greeting) {
+        const taskId = `conv-${Date.now()}`;
+        setState({
+          byId: {
+            [taskId]: {
+              taskId,
+              status: "submitted",
+              messages: [
+                {
+                  messageId: `greeting-${Date.now()}`,
+                  role: "assistant",
+                  kind: "text-content",
+                  content: greeting,
+                  timestamp: new Date().toISOString(),
+                } as TextMessage,
+              ],
+              lastUpdated: new Date().toISOString(),
+            },
+          },
+          order: [taskId],
+        });
+      }
+    },
+    [abort],
+  );
+
+  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);
+    }
+  }, []);
+
+  const subscribeChatEvents = useCallback(
+    async ({
+      userContent,
+      taskId,
+    }: {
+      userContent?: string;
+      taskId?: string;
+    }) => {
+      let hasResponse = false;
 
       if (abortControllerRef.current) {
         abortControllerRef.current.abort();
       }
-      abortControllerRef.current = createAbortController();
+      if (typeof AbortController !== "undefined") {
+        abortControllerRef.current = createAbortController();
+      }
       const controller = abortControllerRef.current;
-
       forceStopRef.current = false;
 
+      // real chat
       try {
-        const stream = client.copilot.chat([
-          { role: "user", content: userContent },
-        ]);
+        const stream = client.copilot.chat(
+          userContent ? [{ role: "user", content: userContent }] : [],
+          taskId ? { taskId } : undefined,
+        );
 
         for await (const chunk of stream) {
           if (controller?.signal.aborted || forceStopRef.current) break;
+          hasResponse = true;
 
-          // 根据你的实际 stream 返回格式调整
-          processDataLine(chunk);
+          processLiveData(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");
+          console.error("[Chat] Request aborted", err);
         } 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(),
-          });
+          onSendError();
         }
       } finally {
-        setIsLoading(false);
-        if (abortControllerRef.current === controller) {
-          abortControllerRef.current = null;
+        abort();
+        if (!hasResponse) {
+          onSendError();
         }
       }
     },
-    [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(),
-              },
-            ],
-          ]),
-        );
+  const sendMessage = useCallback(
+    async (userContent: string) => {
+      if (loadingRef.current) {
+        return;
       }
-    },
-    [abort],
-  );
+      if (!userContent.trim()) return;
+      const userMsgId = generateId();
 
-  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);
-        });
+      addConversation({
+        taskId: generateId(),
+        status: "submitted",
+        messages: [
+          {
+            messageId: userMsgId,
+            role: "user",
+            kind: "text-content",
+            content: userContent,
+            timestamp: new Date().toISOString(),
+          },
+        ],
+        lastUpdated: new Date().toISOString(),
+      });
 
-        setHistoryState({
-          next: result?.next || null,
-          hasMore: result?.hasMore || false,
-        });
+      addLoadingPlaceholder();
 
-        return { taskIds, hasMore: result?.hasMore || false };
-      } catch (error) {
-        console.error("[Chat] Failed to load history:", error);
-        return { taskIds: [], hasMore: false };
-      } finally {
-        setIsLoadingHistory(false);
-      }
+      setIsLoading(true);
+      subscribeChatEvents({ userContent });
     },
-    [processHistoryData],
+    [
+      addConversation,
+      addLoadingPlaceholder,
+      processLiveData,
+      onSendError,
+      abort,
+    ],
   );
 
-  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...");
+        console.debug("[Chat] Initializing conversation...");
         try {
           await loadHistory();
           await checkActiveTask();
+          setStarting(false);
         } catch (error) {
-          console.log("[Chat] Initialization error:", error);
+          console.error("[Chat] Initialization error:", error);
+          setStarting(false);
         }
-        setStarting(false);
       };
       init();
     }
-  }, [starting]);
+  }, [starting, loadHistory, checkActiveTask]);
 
   return {
     starting,
@@ -778,7 +897,6 @@ export function useConversationProcessor() {
     startNewConversation,
     loadHistory,
     loadMoreHistory,
-    processDataLine,
     getConversation,
     clearConversation,
     removeMessage,