@copilotz/chat-adapter 0.8.4 → 0.9.0

package/dist/index.js

@@ -1039,11 +1039,13 @@ var resolveHydratedMessageSender = (message, options = {}) => {
     });
   }
   if (type === "user") {
+    const isCurrentUser = options.user?.id === externalId || options.user?.id === participantId || options.user?.id === storedId;
+    const currentUserName = isCurrentUser ? clean(options.user?.name) : void 0;
     return defined({
       type: "user",
       id: externalId,
       externalId,
-      name: displayName,
+      name: currentUserName ?? displayName,
       avatarUrl: clean(options.user?.avatarUrl),
       participantId: participantId ?? storedId
     });
@@ -1570,6 +1572,28 @@ var generateId = () => globalThis.crypto?.randomUUID?.() ?? `id-${Date.now()}-${
 var isAbortError = (error) => error instanceof DOMException && error.name === "AbortError" || typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
 var getEventPayload = (event) => event?.payload ?? event;
 var getEventSenderType = (payload) => payload?.senderType || payload?.sender?.type;
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var normalizeThreadTag = (value) => {
+  if (!isRecord2(value)) return null;
+  const id = typeof value.id === "string" ? value.id.trim() : "";
+  const name = typeof value.name === "string" ? value.name.trim() : "";
+  const color = typeof value.color === "string" && value.color.trim() ? value.color.trim() : void 0;
+  if (!id || !name) return null;
+  return color ? { id, name, color } : { id, name };
+};
+var getThreadTagsFromMetadata = (metadata) => {
+  if (!isRecord2(metadata) || !isRecord2(metadata.public)) return [];
+  const tags = metadata.public.tags;
+  if (!Array.isArray(tags)) return [];
+  return tags.map(normalizeThreadTag).filter((tag) => !!tag);
+};
+var patchMetadataPublicTags = (metadata, tags) => ({
+  ...metadata ?? {},
+  public: {
+    ...isRecord2(metadata?.public) ? metadata.public : {},
+    tags
+  }
+});
 var THREAD_MESSAGES_PAGE_SIZE = 50;
 var createEmptyMessagePageInfo = () => ({
   hasMoreBefore: false,
@@ -1577,35 +1601,18 @@ var createEmptyMessagePageInfo = () => ({
   newestMessageId: null
 });
 var createPendingAssistantActivity = () => ({
-  items: [{
-    id: "thinking",
-    kind: "thinking",
-    status: "active",
-    startedAt: nowTs()
-  }]
+  items: [
+    {
+      id: "thinking",
+      kind: "thinking",
+      status: "active",
+      startedAt: nowTs()
+    }
+  ]
 });
-function useCopilotz({
-  userId,
-  userName,
-  userAvatar,
-  assistantName,
-  agentOptions = [],
-  initialContext,
-  bootstrap,
-  defaultThreadName,
-  onToolOutput,
-  preferredAgentName,
-  participants,
-  targetAgentName,
-  getRequestHeaders,
-  eventInterceptor,
-  runErrorInterceptor
-}) {
-  const {
-    state: urlState,
-    setThreadId: setUrlThreadId,
-    isEnabled: isUrlSyncEnabled
-  } = useUrlState();
+var getCurrentUserDisplayName = (explicitName, fallbackId) => explicitName?.trim() || fallbackId;
+function useCopilotz({ userId, userName, userAvatar, assistantName, agentOptions = [], initialContext, bootstrap, defaultThreadName, onToolOutput, preferredAgentName, participants, targetAgentName, getRequestHeaders, eventInterceptor, runErrorInterceptor }) {
+  const { state: urlState, setThreadId: setUrlThreadId, isEnabled: isUrlSyncEnabled } = useUrlState();
   const [threads, setThreads] = useState2([]);
   const [threadMetadataMap, setThreadMetadataMap] = useState2({});
   const [threadExternalIdMap, setThreadExternalIdMap] = useState2({});
@@ -1660,42 +1667,51 @@ function useCopilotz({
       setUserContextSeed((prev) => ({ ...prev, ...initialContext }));
     }
   }, [initialContext]);
-  const processToolOutput = useCallback2((output) => {
-    if (!output) return;
-    const contextPatch = {};
-    if (output.userContext && typeof output.userContext === "object") {
-      Object.assign(contextPatch, output.userContext);
-    }
-    if (Object.keys(contextPatch).length > 0) {
-      setUserContextSeed((prev) => ({ ...prev, ...contextPatch }));
-    }
-    onToolOutput?.(output);
-  }, [onToolOutput]);
+  const processToolOutput = useCallback2(
+    (output) => {
+      if (!output) return;
+      const contextPatch = {};
+      if (output.userContext && typeof output.userContext === "object") {
+        Object.assign(contextPatch, output.userContext);
+      }
+      if (Object.keys(contextPatch).length > 0) {
+        setUserContextSeed((prev) => ({ ...prev, ...contextPatch }));
+      }
+      onToolOutput?.(output);
+    },
+    [onToolOutput]
+  );
   const clearSpecialState = useCallback2(() => {
     setSpecialState(null);
   }, []);
-  const applyEventInterceptor = useCallback2((event) => {
-    if (!eventInterceptor) return void 0;
-    try {
-      const result = eventInterceptor(event);
-      if (result?.specialState) {
-        setSpecialState(result.specialState);
+  const applyEventInterceptor = useCallback2(
+    (event) => {
+      if (!eventInterceptor) return void 0;
+      try {
+        const result = eventInterceptor(event);
+        if (result?.specialState) {
+          setSpecialState(result.specialState);
+        }
+        return result;
+      } catch (error) {
+        console.error("Error in Copilotz event interceptor", error);
+        return void 0;
       }
-      return result;
-    } catch (error) {
-      console.error("Error in Copilotz event interceptor", error);
-      return void 0;
-    }
-  }, [eventInterceptor]);
-  const getSpecialStateFromError = useCallback2((error) => {
-    if (!runErrorInterceptor) return null;
-    try {
-      return runErrorInterceptor(error) ?? null;
-    } catch (interceptorError) {
-      console.error("Error in Copilotz run error interceptor", interceptorError);
-      return null;
-    }
-  }, [runErrorInterceptor]);
+    },
+    [eventInterceptor]
+  );
+  const getSpecialStateFromError = useCallback2(
+    (error) => {
+      if (!runErrorInterceptor) return null;
+      try {
+        return runErrorInterceptor(error) ?? null;
+      } catch (interceptorError) {
+        console.error("Error in Copilotz run error interceptor", interceptorError);
+        return null;
+      }
+    },
+    [runErrorInterceptor]
+  );
   const handleStreamMessageEvent = useCallback2((event) => {
     const payload = getEventPayload(event);
     if (!payload) return;
@@ -1756,6 +1772,7 @@ function useCopilotz({
         updatedAt,
         messageCount: typeof thread.metadata?.messageCount === "number" ? thread.metadata.messageCount : 0,
         isArchived: thread.status === "archived",
+        tags: getThreadTagsFromMetadata(thread.metadata),
         metadata: thread.metadata ?? void 0
       };
     });
@@ -1783,56 +1800,61 @@ function useCopilotz({
     setCurrentThreadExternalId(nextThreadId ? externalMap[nextThreadId] ?? null : null);
     return nextThreadId;
   }, []);
-  const fetchAndSetThreadsState = useCallback2(async (uid, preferredExternalId) => {
-    try {
-      const rawThreads = await fetchThreads(uid, getRequestHeaders);
-      return updateThreadsState(rawThreads, preferredExternalId);
-    } catch (error) {
-      if (isAbortError(error)) return;
-      console.error("Error loading threads", error);
-      return null;
-    }
-  }, [updateThreadsState, getRequestHeaders]);
-  const prepareThreadMessages = useCallback2(async (rawMessages) => {
-    return prepareHydratedMessages(rawMessages, {
-      senderOptions: senderOptionsRef.current,
-      createId: generateId,
-      now: nowTs,
-      onToolOutput: processToolOutput,
-      getRequestHeaders
-    });
-  }, [getRequestHeaders, processToolOutput]);
-  const loadThreadMessages = useCallback2(async (threadId) => {
-    const requestId = messagesRequestRef.current + 1;
-    messagesRequestRef.current = requestId;
-    setIsMessagesLoading(true);
-    setIsLoadingOlderMessages(false);
-    setMessagePageInfo(createEmptyMessagePageInfo());
-    persistedToolUpdatesRef.current = [];
-    liveToolUpdatesRef.current = [];
-    try {
-      const page = await fetchThreadMessagesPage(
-        threadId,
-        { limit: THREAD_MESSAGES_PAGE_SIZE },
+  const fetchAndSetThreadsState = useCallback2(
+    async (uid, preferredExternalId) => {
+      try {
+        const rawThreads = await fetchThreads(uid, getRequestHeaders);
+        return updateThreadsState(rawThreads, preferredExternalId);
+      } catch (error) {
+        if (isAbortError(error)) return;
+        console.error("Error loading threads", error);
+        return null;
+      }
+    },
+    [updateThreadsState, getRequestHeaders]
+  );
+  const prepareThreadMessages = useCallback2(
+    async (rawMessages) => {
+      return prepareHydratedMessages(rawMessages, {
+        senderOptions: senderOptionsRef.current,
+        createId: generateId,
+        now: nowTs,
+        onToolOutput: processToolOutput,
         getRequestHeaders
-      );
-      const { viewMessages, toolResultUpdates } = await prepareThreadMessages(page.data);
-      if (messagesRequestRef.current !== requestId) return;
-      persistedToolUpdatesRef.current = toolResultUpdates;
-      const hydratedMessages = mergePersistedToolResults(viewMessages, persistedToolUpdatesRef.current);
-      setMessages(hydratedMessages);
-      setMessagePageInfo(page.pageInfo);
-    } catch (error) {
-      if (isAbortError(error)) return;
-      console.error(`Error loading messages for thread ${threadId}`, error);
-      persistedToolUpdatesRef.current = [];
+      });
+    },
+    [getRequestHeaders, processToolOutput]
+  );
+  const loadThreadMessages = useCallback2(
+    async (threadId) => {
+      const requestId = messagesRequestRef.current + 1;
+      messagesRequestRef.current = requestId;
+      setIsMessagesLoading(true);
+      setIsLoadingOlderMessages(false);
       setMessagePageInfo(createEmptyMessagePageInfo());
-    } finally {
-      if (messagesRequestRef.current === requestId) {
-        setIsMessagesLoading(false);
+      persistedToolUpdatesRef.current = [];
+      liveToolUpdatesRef.current = [];
+      try {
+        const page = await fetchThreadMessagesPage(threadId, { limit: THREAD_MESSAGES_PAGE_SIZE }, getRequestHeaders);
+        const { viewMessages, toolResultUpdates } = await prepareThreadMessages(page.data);
+        if (messagesRequestRef.current !== requestId) return;
+        persistedToolUpdatesRef.current = toolResultUpdates;
+        const hydratedMessages = mergePersistedToolResults(viewMessages, persistedToolUpdatesRef.current);
+        setMessages(hydratedMessages);
+        setMessagePageInfo(page.pageInfo);
+      } catch (error) {
+        if (isAbortError(error)) return;
+        console.error(`Error loading messages for thread ${threadId}`, error);
+        persistedToolUpdatesRef.current = [];
+        setMessagePageInfo(createEmptyMessagePageInfo());
+      } finally {
+        if (messagesRequestRef.current === requestId) {
+          setIsMessagesLoading(false);
+        }
       }
-    }
-  }, [getRequestHeaders, prepareThreadMessages]);
+    },
+    [getRequestHeaders, prepareThreadMessages]
+  );
   const loadOlderMessages = useCallback2(async () => {
     const threadId = currentThreadIdRef.current;
     const pageInfo = messagePageInfoRef.current;
@@ -1843,21 +1865,11 @@ function useCopilotz({
     const requestId = messagesRequestRef.current;
     setIsLoadingOlderMessages(true);
     try {
-      const page = await fetchThreadMessagesPage(
-        threadId,
-        { limit: THREAD_MESSAGES_PAGE_SIZE, before },
-        getRequestHeaders
-      );
+      const page = await fetchThreadMessagesPage(threadId, { limit: THREAD_MESSAGES_PAGE_SIZE, before }, getRequestHeaders);
       const { viewMessages, toolResultUpdates } = await prepareThreadMessages(page.data);
       if (messagesRequestRef.current !== requestId) return;
-      persistedToolUpdatesRef.current = [
-        ...toolResultUpdates,
-        ...persistedToolUpdatesRef.current
-      ];
-      setMessages((prev) => mergePersistedToolResults(
-        prependUniqueMessages(viewMessages, prev),
-        persistedToolUpdatesRef.current
-      ));
+      persistedToolUpdatesRef.current = [...toolResultUpdates, ...persistedToolUpdatesRef.current];
+      setMessages((prev) => mergePersistedToolResults(prependUniqueMessages(viewMessages, prev), persistedToolUpdatesRef.current));
       setMessagePageInfo(page.pageInfo);
     } catch (error) {
       if (isAbortError(error)) return;
@@ -1868,15 +1880,18 @@ function useCopilotz({
       }
     }
   }, [getRequestHeaders, prepareThreadMessages]);
-  const handleSelectThread = useCallback2(async (threadId) => {
-    setCurrentThreadId(threadId);
-    setMessages([]);
-    setMessagePageInfo(createEmptyMessagePageInfo());
-    persistedToolUpdatesRef.current = [];
-    const extMap = threadExternalIdMapRef.current;
-    setCurrentThreadExternalId(extMap[threadId] ?? null);
-    await loadThreadMessages(threadId);
-  }, [loadThreadMessages]);
+  const handleSelectThread = useCallback2(
+    async (threadId) => {
+      setCurrentThreadId(threadId);
+      setMessages([]);
+      setMessagePageInfo(createEmptyMessagePageInfo());
+      persistedToolUpdatesRef.current = [];
+      const extMap = threadExternalIdMapRef.current;
+      setCurrentThreadExternalId(extMap[threadId] ?? null);
+      await loadThreadMessages(threadId);
+    },
+    [loadThreadMessages]
+  );
   const handleCreateThread = useCallback2((title) => {
     messagesRequestRef.current += 1;
     setIsMessagesLoading(false);
@@ -1892,7 +1907,10 @@ function useCopilotz({
       metadata: { pendingTitle: title?.trim() || void 0 }
     };
     setThreads((prev) => [newThread, ...prev]);
-    setThreadMetadataMap((prev) => ({ ...prev, [id]: { pendingTitle: title?.trim() || void 0 } }));
+    setThreadMetadataMap((prev) => ({
+      ...prev,
+      [id]: { pendingTitle: title?.trim() || void 0 }
+    }));
     setThreadExternalIdMap((prev) => ({ ...prev, [id]: id }));
     setCurrentThreadId(id);
     setCurrentThreadExternalId(id);
@@ -1900,89 +1918,117 @@ function useCopilotz({
     setMessagePageInfo(createEmptyMessagePageInfo());
     persistedToolUpdatesRef.current = [];
   }, []);
-  const handleRenameThread = useCallback2(async (threadId, newTitle) => {
-    const trimmedTitle = newTitle.trim();
-    if (!trimmedTitle) return;
-    setThreads(
-      (prev) => prev.map((t) => t.id === threadId ? { ...t, title: trimmedTitle, updatedAt: nowTs() } : t)
-    );
-    const extMap = threadExternalIdMapRef.current;
-    const isPlaceholder = extMap[threadId] === threadId;
-    if (isPlaceholder) {
+  const handleRenameThread = useCallback2(
+    async (threadId, newTitle) => {
+      const trimmedTitle = newTitle.trim();
+      if (!trimmedTitle) return;
+      setThreads((prev) => prev.map((t) => t.id === threadId ? { ...t, title: trimmedTitle, updatedAt: nowTs() } : t));
+      const extMap = threadExternalIdMapRef.current;
+      const isPlaceholder = extMap[threadId] === threadId;
+      if (isPlaceholder) {
+        setThreadMetadataMap((prev) => ({
+          ...prev,
+          [threadId]: { ...prev[threadId], pendingTitle: trimmedTitle }
+        }));
+      } else {
+        try {
+          await updateThread(threadId, { name: trimmedTitle }, getRequestHeaders);
+        } catch (error) {
+          console.error("Failed to rename thread:", error);
+          if (userId) {
+            await fetchAndSetThreadsState(userId, currentThreadExternalIdRef.current);
+          }
+        }
+      }
+    },
+    [userId, fetchAndSetThreadsState, getRequestHeaders]
+  );
+  const handleArchiveThread = useCallback2(
+    async (threadId) => {
+      const thread = threadsRef.current.find((t) => t.id === threadId);
+      if (!thread) return;
+      const newArchivedStatus = !thread.isArchived;
+      setThreads((prev) => prev.map((t) => t.id === threadId ? { ...t, isArchived: newArchivedStatus, updatedAt: nowTs() } : t));
+      const extMap = threadExternalIdMapRef.current;
+      const isPlaceholder = extMap[threadId] === threadId;
+      if (!isPlaceholder) {
+        try {
+          await updateThread(threadId, { status: newArchivedStatus ? "archived" : "active" }, getRequestHeaders);
+        } catch (error) {
+          console.error("Failed to archive thread:", error);
+          if (userId) {
+            await fetchAndSetThreadsState(userId, currentThreadExternalIdRef.current);
+          }
+        }
+      }
+    },
+    [userId, fetchAndSetThreadsState, getRequestHeaders]
+  );
+  const handleUpdateThreadTags = useCallback2(
+    async (threadId, tags) => {
+      const extMap = threadExternalIdMapRef.current;
+      const currentMetadata = threadMetadataMapRef.current[threadId];
+      const nextMetadata = patchMetadataPublicTags(currentMetadata, tags);
+      setThreads((prev) => prev.map((thread) => thread.id === threadId ? { ...thread, tags, metadata: nextMetadata, updatedAt: nowTs() } : thread));
       setThreadMetadataMap((prev) => ({
         ...prev,
-        [threadId]: { ...prev[threadId], pendingTitle: trimmedTitle }
+        [threadId]: nextMetadata
       }));
-    } else {
+      const isPlaceholder = extMap[threadId] === threadId;
+      if (isPlaceholder) return;
       try {
-        await updateThread(threadId, { name: trimmedTitle }, getRequestHeaders);
+        await updateThread(threadId, { metadata: nextMetadata }, getRequestHeaders);
       } catch (error) {
-        console.error("Failed to rename thread:", error);
+        console.error("Failed to update thread tags:", error);
         if (userId) {
           await fetchAndSetThreadsState(userId, currentThreadExternalIdRef.current);
         }
       }
-    }
-  }, [userId, fetchAndSetThreadsState, getRequestHeaders]);
-  const handleArchiveThread = useCallback2(async (threadId) => {
-    const thread = threadsRef.current.find((t) => t.id === threadId);
-    if (!thread) return;
-    const newArchivedStatus = !thread.isArchived;
-    setThreads(
-      (prev) => prev.map((t) => t.id === threadId ? { ...t, isArchived: newArchivedStatus, updatedAt: nowTs() } : t)
-    );
-    const extMap = threadExternalIdMapRef.current;
-    const isPlaceholder = extMap[threadId] === threadId;
-    if (!isPlaceholder) {
-      try {
-        await updateThread(threadId, { status: newArchivedStatus ? "archived" : "active" }, getRequestHeaders);
-      } catch (error) {
-        console.error("Failed to archive thread:", error);
-        if (userId) {
-          await fetchAndSetThreadsState(userId, currentThreadExternalIdRef.current);
+    },
+    [userId, fetchAndSetThreadsState, getRequestHeaders]
+  );
+  const handleDeleteThread = useCallback2(
+    async (threadId) => {
+      const extMap = threadExternalIdMapRef.current;
+      const isPlaceholder = extMap[threadId] === threadId;
+      setThreads((prev) => prev.filter((t) => t.id !== threadId));
+      setThreadMetadataMap((prev) => {
+        const next = { ...prev };
+        delete next[threadId];
+        return next;
+      });
+      setThreadExternalIdMap((prev) => {
+        const next = { ...prev };
+        delete next[threadId];
+        return next;
+      });
+      if (currentThreadIdRef.current === threadId) {
+        const remaining = threadsRef.current.filter((t) => t.id !== threadId);
+        if (remaining.length > 0) {
+          setCurrentThreadId(remaining[0].id);
+          setCurrentThreadExternalId(extMap[remaining[0].id] ?? null);
+          await loadThreadMessages(remaining[0].id);
+        } else {
+          setCurrentThreadId(null);
+          setCurrentThreadExternalId(null);
+          setMessages([]);
+          setMessagePageInfo(createEmptyMessagePageInfo());
+          persistedToolUpdatesRef.current = [];
         }
       }
-    }
-  }, [userId, fetchAndSetThreadsState, getRequestHeaders]);
-  const handleDeleteThread = useCallback2(async (threadId) => {
-    const extMap = threadExternalIdMapRef.current;
-    const isPlaceholder = extMap[threadId] === threadId;
-    setThreads((prev) => prev.filter((t) => t.id !== threadId));
-    setThreadMetadataMap((prev) => {
-      const next = { ...prev };
-      delete next[threadId];
-      return next;
-    });
-    setThreadExternalIdMap((prev) => {
-      const next = { ...prev };
-      delete next[threadId];
-      return next;
-    });
-    if (currentThreadIdRef.current === threadId) {
-      const remaining = threadsRef.current.filter((t) => t.id !== threadId);
-      if (remaining.length > 0) {
-        setCurrentThreadId(remaining[0].id);
-        setCurrentThreadExternalId(extMap[remaining[0].id] ?? null);
-        await loadThreadMessages(remaining[0].id);
-      } else {
-        setCurrentThreadId(null);
-        setCurrentThreadExternalId(null);
-        setMessages([]);
-        setMessagePageInfo(createEmptyMessagePageInfo());
-        persistedToolUpdatesRef.current = [];
-      }
-    }
-    if (!isPlaceholder) {
-      try {
-        await deleteThread(threadId, getRequestHeaders);
-      } catch (error) {
-        console.error("Failed to delete thread:", error);
-        if (userId) {
-          await fetchAndSetThreadsState(userId, currentThreadExternalIdRef.current);
+      if (!isPlaceholder) {
+        try {
+          await deleteThread(threadId, getRequestHeaders);
+        } catch (error) {
+          console.error("Failed to delete thread:", error);
+          if (userId) {
+            await fetchAndSetThreadsState(userId, currentThreadExternalIdRef.current);
+          }
         }
       }
-    }
-  }, [userId, fetchAndSetThreadsState, loadThreadMessages, getRequestHeaders]);
+    },
+    [userId, fetchAndSetThreadsState, loadThreadMessages, getRequestHeaders]
+  );
   const handleStop = useCallback2(() => {
     abortControllerRef.current?.abort();
     abortControllerRef.current = null;
@@ -2005,514 +2051,533 @@ function useCopilotz({
       ...typeof payload.fileName === "string" ? { fileName: payload.fileName } : {},
       ...typeof payload.size === "number" ? { size: payload.size } : {}
     };
-    setMessages((prev) => prev.map((msg) => msg.id === assistantMessageId ? {
-      ...msg,
-      attachments: [...msg.attachments || [], mediaAttachment]
-    } : msg));
+    setMessages(
+      (prev) => prev.map(
+        (msg) => msg.id === assistantMessageId ? {
+          ...msg,
+          attachments: [...msg.attachments || [], mediaAttachment]
+        } : msg
+      )
+    );
   }, []);
-  const sendCopilotzMessage = useCallback2(async (params) => {
-    let currentAssistantId = params.assistantMessageId ?? generateId();
-    let currentAssistantSender = params.assistantSender;
-    params.onBeforeStart?.(currentAssistantId);
-    let hasStreamProgress = false;
-    const updateStreamingMessage = (partial, opts) => {
-      if (partial && partial.length > 0) {
-        hasStreamProgress = true;
-      }
-      const isReasoning = opts?.isReasoning ?? false;
-      const nextSender = opts?.agent ? resolveAgentSender(opts.agent, senderOptionsRef.current) : currentAssistantSender;
-      if (nextSender) {
-        currentAssistantSender = nextSender;
-      }
-      const nextAgentKey = currentAssistantSender?.agentId ?? currentAssistantSender?.id ?? null;
-      const applyUpdate = (msg) => {
-        return {
-          ...updateAssistantMessageToken(msg, {
-            partial,
-            isReasoning
-          }),
-          ...currentAssistantSender ? { sender: currentAssistantSender } : {}
+  const sendCopilotzMessage = useCallback2(
+    async (params) => {
+      let currentAssistantId = params.assistantMessageId ?? generateId();
+      let currentAssistantSender = params.assistantSender;
+      params.onBeforeStart?.(currentAssistantId);
+      let hasStreamProgress = false;
+      const updateStreamingMessage = (partial, opts) => {
+        if (partial && partial.length > 0) {
+          hasStreamProgress = true;
+        }
+        const isReasoning = opts?.isReasoning ?? false;
+        const nextSender = opts?.agent ? resolveAgentSender(opts.agent, senderOptionsRef.current) : currentAssistantSender;
+        if (nextSender) {
+          currentAssistantSender = nextSender;
+        }
+        const nextAgentKey = currentAssistantSender?.agentId ?? currentAssistantSender?.id ?? null;
+        const applyUpdate = (msg) => {
+          return {
+            ...updateAssistantMessageToken(msg, {
+              partial,
+              isReasoning
+            }),
+            ...currentAssistantSender ? { sender: currentAssistantSender } : {}
+          };
         };
+        setMessages((prev) => {
+          const idx = prev.findIndex((m) => m.id === currentAssistantId);
+          if (idx >= 0 && canAttachToStreamingAssistant(prev[idx], nextAgentKey)) {
+            const msg = prev[idx];
+            const next = applyUpdate(msg);
+            if (msg.content === next.content && msg.activity === next.activity && msg.isStreaming === next.isStreaming && msg.isComplete === next.isComplete) {
+              return prev;
+            }
+            const updated = [...prev];
+            updated[idx] = next;
+            return updated;
+          }
+          const last = prev[prev.length - 1];
+          if (canAttachToStreamingAssistant(last, nextAgentKey)) {
+            currentAssistantId = last.id;
+            const next = applyUpdate(last);
+            if (last.content === next.content && last.activity === next.activity && last.isStreaming === next.isStreaming && last.isComplete === next.isComplete) {
+              return prev;
+            }
+            const updated = [...prev];
+            updated[prev.length - 1] = next;
+            return updated;
+          }
+          const lastStreamingBelongsToDifferentAgent = Boolean(nextAgentKey) && last?.role === "assistant" && last.isStreaming && Boolean(messageAgentKey(last)) && messageAgentKey(last) !== nextAgentKey;
+          if (!prev.length || prev[prev.length - 1].role !== "assistant" || !prev[prev.length - 1].isStreaming || lastStreamingBelongsToDifferentAgent) {
+            const newId = generateId();
+            currentAssistantId = newId;
+            const base = {
+              id: newId,
+              role: "assistant",
+              content: "",
+              timestamp: nowTs(),
+              isStreaming: true,
+              isComplete: false,
+              ...currentAssistantSender ? { sender: currentAssistantSender } : {}
+            };
+            return [...prev, applyUpdate(base)];
+          }
+          return prev;
+        });
       };
-      setMessages((prev) => {
-        const idx = prev.findIndex((m) => m.id === currentAssistantId);
-        if (idx >= 0 && canAttachToStreamingAssistant(prev[idx], nextAgentKey)) {
+      const finalizeCurrentAssistantBubble = () => {
+        setMessages((prev) => {
+          const idx = prev.findIndex((m) => m.id === currentAssistantId);
+          if (idx < 0) return prev;
           const msg = prev[idx];
-          const next = applyUpdate(msg);
-          if (msg.content === next.content && msg.activity === next.activity && msg.isStreaming === next.isStreaming && msg.isComplete === next.isComplete) {
-            return prev;
-          }
+          if (!msg.isStreaming && msg.isComplete) return prev;
           const updated = [...prev];
-          updated[idx] = next;
+          updated[idx] = closeAssistantMessage(msg);
           return updated;
+        });
+      };
+      const curThreadId = currentThreadIdRef.current;
+      const applyLiveToolResultUpdate = (update) => {
+        let matched = false;
+        setMessages((prev) => {
+          const next = applyToolResultUpdateToMessages(prev, update, {
+            isStreaming: true,
+            isComplete: false
+          });
+          matched = next.matched;
+          return next.matched ? next.messages : prev;
+        });
+        if (!matched) {
+          liveToolUpdatesRef.current.push(update);
         }
-        const last = prev[prev.length - 1];
-        if (canAttachToStreamingAssistant(last, nextAgentKey)) {
-          currentAssistantId = last.id;
-          const next = applyUpdate(last);
-          if (last.content === next.content && last.activity === next.activity && last.isStreaming === next.isStreaming && last.isComplete === next.isComplete) {
+      };
+      const finalizeActiveAssistantTurn = (finalAnswer) => {
+        setMessages((prev) => {
+          const currentIdx = prev.findIndex((message2) => message2.id === currentAssistantId && message2.role === "assistant");
+          const fallbackIdx = currentIdx >= 0 ? currentIdx : (() => {
+            for (let i = prev.length - 1; i >= 0; i--) {
+              if (prev[i].role === "assistant" && prev[i].isStreaming) {
+                return i;
+              }
+            }
+            return -1;
+          })();
+          if (fallbackIdx < 0) return prev;
+          const message = prev[fallbackIdx];
+          const nextMessage = finalizeAssistantMessage(message, finalAnswer);
+          if (message.content === nextMessage.content && message.isStreaming === nextMessage.isStreaming && message.isComplete === nextMessage.isComplete && message.activity === nextMessage.activity) {
             return prev;
           }
           const updated = [...prev];
-          updated[prev.length - 1] = next;
+          updated[fallbackIdx] = nextMessage;
+          currentAssistantId = nextMessage.id;
           return updated;
-        }
-        const lastStreamingBelongsToDifferentAgent = Boolean(nextAgentKey) && last?.role === "assistant" && last.isStreaming && Boolean(messageAgentKey(last)) && messageAgentKey(last) !== nextAgentKey;
-        if (!prev.length || (prev[prev.length - 1].role !== "assistant" || !prev[prev.length - 1].isStreaming) || lastStreamingBelongsToDifferentAgent) {
-          const newId = generateId();
-          currentAssistantId = newId;
-          const base = {
-            id: newId,
-            role: "assistant",
+        });
+      };
+      const toServerMessageFromEvent = async (event) => {
+        if (!event) return null;
+        const type = event?.type || "";
+        const payload = event?.payload ?? event;
+        if (type === "TOOL_CALL") {
+          const parsedToolCall = extractLiveToolCall(payload);
+          return {
+            id: generateId(),
+            threadId: curThreadId ?? "",
+            senderType: "tool",
             content: "",
-            timestamp: nowTs(),
-            isStreaming: true,
-            isComplete: false,
-            ...currentAssistantSender ? { sender: currentAssistantSender } : {}
+            toolCalls: [
+              {
+                id: parsedToolCall.id ?? generateId(),
+                name: parsedToolCall.name,
+                args: parsedToolCall.arguments,
+                ...parsedToolCall.result !== void 0 ? { output: parsedToolCall.result } : {},
+                status: parsedToolCall.status
+              }
+            ]
           };
-          return [...prev, applyUpdate(base)];
         }
-        return prev;
-      });
-    };
-    const finalizeCurrentAssistantBubble = () => {
-      setMessages((prev) => {
-        const idx = prev.findIndex((m) => m.id === currentAssistantId);
-        if (idx < 0) return prev;
-        const msg = prev[idx];
-        if (!msg.isStreaming && msg.isComplete) return prev;
-        const updated = [...prev];
-        updated[idx] = closeAssistantMessage(msg);
-        return updated;
-      });
-    };
-    const curThreadId = currentThreadIdRef.current;
-    const applyLiveToolResultUpdate = (update) => {
-      let matched = false;
-      setMessages((prev) => {
-        const next = applyToolResultUpdateToMessages(prev, update, {
-          isStreaming: true,
-          isComplete: false
+        return null;
+      };
+      const abortController = new AbortController();
+      abortControllerRef.current?.abort();
+      abortControllerRef.current = abortController;
+      setIsStreaming(true);
+      liveToolUpdatesRef.current = [];
+      try {
+        const normalizedUserMetadata = params.userMetadata ? JSON.parse(JSON.stringify(params.userMetadata)) : void 0;
+        const contextSeed = userContextSeedRef.current;
+        const contextMetadata = contextSeed ? JSON.parse(JSON.stringify(contextSeed)) : void 0;
+        const requestContent = params.content && params.content.length > 0 ? params.content : "";
+        const metadataKey = params.threadId ?? params.threadExternalId ?? void 0;
+        const currentThreadMetadataMap = threadMetadataMapRef.current;
+        const messageMetadata = metadataKey ? currentThreadMetadataMap[metadataKey]?.userContext : void 0;
+        const threadMetadata = metadataKey ? currentThreadMetadataMap[metadataKey] : void 0;
+        const mergedMetadata = {
+          ...messageMetadata ?? {},
+          ...params.metadata ?? {}
+        };
+        const finalMetadata = Object.keys(mergedMetadata).length > 0 ? mergedMetadata : void 0;
+        await runCopilotzStream({
+          threadId: params.threadId ?? void 0,
+          threadExternalId: params.threadExternalId ?? void 0,
+          content: requestContent,
+          user: {
+            externalId: params.userId,
+            name: params.userName ?? params.userId,
+            metadata: {
+              ...contextMetadata ? contextMetadata : {},
+              ...normalizedUserMetadata ?? {}
+            }
+          },
+          attachments: params.attachments,
+          metadata: finalMetadata,
+          threadMetadata: params.threadMetadata ?? threadMetadata,
+          toolCalls: params.toolCalls,
+          selectedAgent: params.agentName ?? preferredAgentRef.current ?? null,
+          participants: participantsRef.current,
+          targetAgent: targetAgentNameRef.current,
+          getRequestHeaders,
+          onToken: (token, _isComplete, raw, opts) => updateStreamingMessage(token, {
+            ...opts,
+            agent: raw?.payload?.agent ?? raw?.agent ?? null
+          }),
+          onMessageEvent: async (event) => {
+            const intercepted = applyEventInterceptor(event);
+            if (intercepted?.handled) {
+              return;
+            }
+            const type = event?.type || "";
+            const payload = getEventPayload(event);
+            if (type === "TOOL_RESULT") {
+              processToolOutput(payload ?? {});
+              applyLiveToolResultUpdate(extractLiveToolResultUpdate(payload ?? {}));
+              return;
+            }
+            if (type === "LLM_RESULT") {
+              const finalAnswer = typeof payload?.answer === "string" ? payload.answer : void 0;
+              finalizeActiveAssistantTurn(finalAnswer);
+              return;
+            }
+            if (type === "MESSAGE" || type === "NEW_MESSAGE") {
+              return;
+            }
+            if (type === "TOOL_CALL") {
+              const parsedToolCall = extractLiveToolCall(payload ?? {});
+              const eventSender = resolveLiveEventSender(event, senderOptionsRef.current);
+              currentAssistantSender = eventSender;
+              const eventAgentKey = currentAssistantSender.agentId ?? currentAssistantSender.id;
+              const callId = parsedToolCall.id ?? generateId();
+              const toolName = parsedToolCall.name;
+              const bufferedUpdates = liveToolUpdatesRef.current;
+              const matchingUpdateIndex = bufferedUpdates.findIndex((upd) => matchesToolResultUpdate({ id: callId, name: toolName }, upd));
+              const bufferedUpdate = matchingUpdateIndex >= 0 ? bufferedUpdates[matchingUpdateIndex] : void 0;
+              if (matchingUpdateIndex >= 0) {
+                bufferedUpdates.splice(matchingUpdateIndex, 1);
+              }
+              const initialStatus = bufferedUpdate ? bufferedUpdate.status : parsedToolCall.status;
+              const initialResult = bufferedUpdate && bufferedUpdate.result !== void 0 ? bufferedUpdate.result : parsedToolCall.result;
+              const endTime = bufferedUpdate?.endTime;
+              setMessages(
+                (prev) => (() => {
+                  const canHostActivity = (message) => {
+                    if (!message) return false;
+                    return message.role === "assistant" && message.isStreaming && message.content.trim().length === 0 && !message.attachments?.length;
+                  };
+                  const appendToolCall = (msg) => ({
+                    ...appendAssistantToolCall(msg, {
+                      id: callId,
+                      name: toolName,
+                      arguments: parsedToolCall.arguments,
+                      ...initialResult !== void 0 ? { result: initialResult } : {},
+                      status: initialStatus,
+                      startTime: Date.now(),
+                      ...endTime !== void 0 ? { endTime } : {}
+                    })
+                  });
+                  const currentIdx = prev.findIndex((message) => message.id === currentAssistantId && message.role === "assistant" && message.isStreaming && canHostActivity(message));
+                  if (currentIdx >= 0) {
+                    const next = [...prev];
+                    next[currentIdx] = appendToolCall({
+                      ...next[currentIdx],
+                      isStreaming: true,
+                      isComplete: false,
+                      ...currentAssistantSender ? { sender: currentAssistantSender } : {}
+                    });
+                    return next;
+                  }
+                  const last = prev[prev.length - 1];
+                  if (canHostActivity(last) && canAttachToStreamingAssistant(last, eventAgentKey)) {
+                    currentAssistantId = last.id;
+                    const next = [...prev];
+                    next[prev.length - 1] = appendToolCall({
+                      ...last,
+                      isStreaming: true,
+                      isComplete: false,
+                      ...currentAssistantSender ? { sender: currentAssistantSender } : {}
+                    });
+                    return next;
+                  }
+                  const newId = generateId();
+                  currentAssistantId = newId;
+                  return [
+                    ...prev,
+                    appendToolCall({
+                      id: newId,
+                      role: "assistant",
+                      content: "",
+                      timestamp: nowTs(),
+                      isStreaming: true,
+                      isComplete: false,
+                      ...currentAssistantSender ? { sender: currentAssistantSender } : {}
+                    })
+                  ];
+                })()
+              );
+              hasStreamProgress = true;
+              return;
+            }
+            const sm = await toServerMessageFromEvent(event);
+            if (sm) {
+              const viewMsg = convertServerMessage(sm, {
+                senderOptions: senderOptionsRef.current,
+                createId: generateId,
+                now: nowTs
+              });
+              finalizeCurrentAssistantBubble();
+              setMessages((prev) => [...prev, viewMsg]);
+              return;
+            }
+            handleStreamMessageEvent(event);
+          },
+          onAssetEvent: async (payload) => {
+            const intercepted = applyEventInterceptor({
+              type: "ASSET_CREATED",
+              payload
+            });
+            if (intercepted?.handled) {
+              return;
+            }
+            await (async () => {
+              if (!hasStreamProgress) return;
+              handleStreamAssetEvent(payload, currentAssistantId);
+            })();
+          },
+          signal: abortController.signal
         });
-        matched = next.matched;
-        return next.matched ? next.messages : prev;
-      });
-      if (!matched) {
-        liveToolUpdatesRef.current.push(update);
+      } finally {
+        setIsStreaming(false);
+        setMessages((prev) => {
+          const hasStreaming = prev.some((msg) => msg.isStreaming);
+          if (!hasStreaming) return prev;
+          return prev.map((msg) => msg.isStreaming ? closeAssistantMessage(msg) : msg);
+        });
+        abortControllerRef.current = null;
       }
-    };
-    const finalizeActiveAssistantTurn = (finalAnswer) => {
-      setMessages((prev) => {
-        const currentIdx = prev.findIndex((message2) => message2.id === currentAssistantId && message2.role === "assistant");
-        const fallbackIdx = currentIdx >= 0 ? currentIdx : (() => {
-          for (let i = prev.length - 1; i >= 0; i--) {
-            if (prev[i].role === "assistant" && prev[i].isStreaming) {
-              return i;
-            }
-          }
-          return -1;
-        })();
-        if (fallbackIdx < 0) return prev;
-        const message = prev[fallbackIdx];
-        const nextMessage = finalizeAssistantMessage(message, finalAnswer);
-        if (message.content === nextMessage.content && message.isStreaming === nextMessage.isStreaming && message.isComplete === nextMessage.isComplete && message.activity === nextMessage.activity) {
-          return prev;
+      return currentAssistantId;
+    },
+    [applyEventInterceptor, handleStreamMessageEvent, handleStreamAssetEvent, getRequestHeaders]
+  );
+  const handleSendMessage = useCallback2(
+    async (content, attachments = []) => {
+      if (!content.trim() && attachments.length === 0) return;
+      if (!userId) return;
+      const timestamp = nowTs();
+      const curThreadId = currentThreadIdRef.current;
+      const curThreadExtId = currentThreadExternalIdRef.current;
+      const existingThreadId = curThreadId ?? void 0;
+      const extMap = threadExternalIdMapRef.current;
+      const isPlaceholderThread = existingThreadId ? extMap[existingThreadId] === existingThreadId : false;
+      const threadIdForSend = isPlaceholderThread ? void 0 : existingThreadId;
+      let effectiveThreadExternalId = curThreadExtId ?? (isPlaceholderThread ? existingThreadId : void 0);
+      if (!threadIdForSend) {
+        if (!effectiveThreadExternalId) {
+          effectiveThreadExternalId = generateId();
         }
-        const updated = [...prev];
-        updated[fallbackIdx] = nextMessage;
-        currentAssistantId = nextMessage.id;
-        return updated;
-      });
-    };
-    const toServerMessageFromEvent = async (event) => {
-      if (!event) return null;
-      const type = event?.type || "";
-      const payload = event?.payload ?? event;
-      if (type === "TOOL_CALL") {
-        const parsedToolCall = extractLiveToolCall(payload);
-        return {
-          id: generateId(),
-          threadId: curThreadId ?? "",
-          senderType: "tool",
-          content: "",
-          toolCalls: [{
-            id: parsedToolCall.id ?? generateId(),
-            name: parsedToolCall.name,
-            args: parsedToolCall.arguments,
-            ...parsedToolCall.result !== void 0 ? { output: parsedToolCall.result } : {},
-            status: parsedToolCall.status
-          }]
-        };
+        setCurrentThreadExternalId(effectiveThreadExternalId);
+      } else if (curThreadExtId !== (effectiveThreadExternalId ?? null)) {
+        setCurrentThreadExternalId(effectiveThreadExternalId ?? null);
       }
-      return null;
-    };
-    const abortController = new AbortController();
-    abortControllerRef.current?.abort();
-    abortControllerRef.current = abortController;
-    setIsStreaming(true);
-    liveToolUpdatesRef.current = [];
-    try {
-      const normalizedUserMetadata = params.userMetadata ? JSON.parse(JSON.stringify(params.userMetadata)) : void 0;
-      const contextSeed = userContextSeedRef.current;
-      const contextMetadata = contextSeed ? JSON.parse(JSON.stringify(contextSeed)) : void 0;
-      const requestContent = params.content && params.content.length > 0 ? params.content : "";
-      const metadataKey = params.threadId ?? params.threadExternalId ?? void 0;
-      const currentThreadMetadataMap = threadMetadataMapRef.current;
-      const messageMetadata = metadataKey ? currentThreadMetadataMap[metadataKey]?.userContext : void 0;
-      const threadMetadata = metadataKey ? currentThreadMetadataMap[metadataKey] : void 0;
-      const mergedMetadata = {
-        ...messageMetadata ?? {},
-        ...params.metadata ?? {}
+      const conversationKey = threadIdForSend ?? effectiveThreadExternalId;
+      const currentMetadata = threadMetadataMapRef.current[conversationKey];
+      const pendingTitle = currentMetadata?.pendingTitle;
+      const userMessage = {
+        id: generateId(),
+        role: "user",
+        content,
+        timestamp,
+        attachments: attachments.length > 0 ? attachments : void 0,
+        isComplete: true,
+        sender: resolveUserSender({
+          id: userId,
+          name: getCurrentUserDisplayName(userName, userId)
+        })
       };
-      const finalMetadata = Object.keys(mergedMetadata).length > 0 ? mergedMetadata : void 0;
-      await runCopilotzStream({
-        threadId: params.threadId ?? void 0,
-        threadExternalId: params.threadExternalId ?? void 0,
-        content: requestContent,
-        user: {
-          externalId: params.userId,
-          name: params.userName ?? params.userId,
-          metadata: {
-            ...contextMetadata ? contextMetadata : {},
-            ...normalizedUserMetadata ?? {}
-          }
+      const assistantSender = targetAgentNameRef.current ? resolveAgentSender(
+        {
+          id: targetAgentNameRef.current,
+          name: targetAgentNameRef.current
         },
-        attachments: params.attachments,
-        metadata: finalMetadata,
-        threadMetadata: params.threadMetadata ?? threadMetadata,
-        toolCalls: params.toolCalls,
-        selectedAgent: params.agentName ?? preferredAgentRef.current ?? null,
-        participants: participantsRef.current,
-        targetAgent: targetAgentNameRef.current,
-        getRequestHeaders,
-        onToken: (token, _isComplete, raw, opts) => updateStreamingMessage(token, {
-          ...opts,
-          agent: raw?.payload?.agent ?? raw?.agent ?? null
-        }),
-        onMessageEvent: async (event) => {
-          const intercepted = applyEventInterceptor(event);
-          if (intercepted?.handled) {
-            return;
-          }
-          const type = event?.type || "";
-          const payload = getEventPayload(event);
-          if (type === "TOOL_RESULT") {
-            processToolOutput(payload ?? {});
-            applyLiveToolResultUpdate(extractLiveToolResultUpdate(
-              payload ?? {}
-            ));
-            return;
-          }
-          if (type === "LLM_RESULT") {
-            const finalAnswer = typeof payload?.answer === "string" ? payload.answer : void 0;
-            finalizeActiveAssistantTurn(finalAnswer);
-            return;
+        senderOptionsRef.current
+      ) : preferredAgentRef.current ? resolveAgentSender({ id: preferredAgentRef.current, name: preferredAgentRef.current }, senderOptionsRef.current) : resolveAssistantFallbackSender(senderOptionsRef.current);
+      const assistantPlaceholder = {
+        id: generateId(),
+        role: "assistant",
+        content: "",
+        timestamp: timestamp + 1,
+        isStreaming: true,
+        isComplete: false,
+        sender: assistantSender,
+        activity: createPendingAssistantActivity()
+      };
+      setMessages((prev) => [...prev, userMessage, assistantPlaceholder]);
+      setSpecialState(null);
+      if (!threadsRef.current.some((t) => t.id === conversationKey)) {
+        const newThread = {
+          id: conversationKey,
+          title: content.slice(0, 40) || "Nova conversa",
+          createdAt: timestamp,
+          updatedAt: timestamp,
+          messageCount: 0
+        };
+        setThreads((prev) => [newThread, ...prev]);
+        setThreadMetadataMap((prev) => ({ ...prev, [conversationKey]: {} }));
+        setThreadExternalIdMap((prev) => ({
+          ...prev,
+          [conversationKey]: effectiveThreadExternalId ?? null
+        }));
+      }
+      try {
+        await sendCopilotzMessage({
+          threadId: threadIdForSend,
+          threadExternalId: effectiveThreadExternalId,
+          content,
+          attachments,
+          userId,
+          userName: getCurrentUserDisplayName(userName, userId),
+          agentName: preferredAgentRef.current,
+          assistantMessageId: assistantPlaceholder.id,
+          assistantSender,
+          // Include pending title for new threads
+          threadMetadata: pendingTitle ? { name: pendingTitle } : void 0
+        });
+        await new Promise((r) => setTimeout(r, 1e3));
+        await fetchAndSetThreadsState(userId, effectiveThreadExternalId ?? existingThreadId ?? null);
+      } catch (error) {
+        if (isAbortError(error)) return;
+        console.error("Error sending Copilotz message", error);
+        const nextSpecialState = getSpecialStateFromError(error);
+        if (nextSpecialState) {
+          setSpecialState(nextSpecialState);
+          setMessages((prev) => prev.filter((msg) => !msg.isStreaming));
+          return;
+        }
+        setMessages((prev) => {
+          const finalized = prev.map((msg) => msg.isStreaming ? closeAssistantMessage(msg) : msg);
+          if (finalized.some(hasVisibleAssistantOutput)) {
+            return finalized;
           }
-          if (type === "MESSAGE" || type === "NEW_MESSAGE") {
-            return;
+          for (let i = finalized.length - 1; i >= 0; i--) {
+            const message = finalized[i];
+            if (message.role !== "assistant") continue;
+            const updated = [...finalized];
+            updated[i] = {
+              ...message,
+              content: "Desculpe, ocorreu um erro ao gerar a resposta. Por favor, tente novamente.",
+              isStreaming: false,
+              isComplete: true,
+              sender: message.sender ?? resolveAssistantFallbackSender(senderOptionsRef.current)
+            };
+            return updated;
           }
-          if (type === "TOOL_CALL") {
-            const parsedToolCall = extractLiveToolCall(
-              payload ?? {}
-            );
-            const eventSender = resolveLiveEventSender(event, senderOptionsRef.current);
-            currentAssistantSender = eventSender;
-            const eventAgentKey = currentAssistantSender.agentId ?? currentAssistantSender.id;
-            const callId = parsedToolCall.id ?? generateId();
-            const toolName = parsedToolCall.name;
-            const bufferedUpdates = liveToolUpdatesRef.current;
-            const matchingUpdateIndex = bufferedUpdates.findIndex((upd) => matchesToolResultUpdate({ id: callId, name: toolName }, upd));
-            const bufferedUpdate = matchingUpdateIndex >= 0 ? bufferedUpdates[matchingUpdateIndex] : void 0;
-            if (matchingUpdateIndex >= 0) {
-              bufferedUpdates.splice(matchingUpdateIndex, 1);
+          return [
+            ...finalized,
+            {
+              id: generateId(),
+              role: "assistant",
+              content: "Desculpe, ocorreu um erro ao gerar a resposta. Por favor, tente novamente.",
+              timestamp: nowTs(),
+              isStreaming: false,
+              isComplete: true,
+              sender: resolveAssistantFallbackSender(senderOptionsRef.current)
             }
-            const initialStatus = bufferedUpdate ? bufferedUpdate.status : parsedToolCall.status;
-            const initialResult = bufferedUpdate && bufferedUpdate.result !== void 0 ? bufferedUpdate.result : parsedToolCall.result;
-            const endTime = bufferedUpdate?.endTime;
-            setMessages(
-              (prev) => (() => {
-                const canHostActivity = (message) => {
-                  if (!message) return false;
-                  return message.role === "assistant" && message.isStreaming && message.content.trim().length === 0 && !message.attachments?.length;
-                };
-                const appendToolCall = (msg) => ({
-                  ...appendAssistantToolCall(msg, {
-                    id: callId,
-                    name: toolName,
-                    arguments: parsedToolCall.arguments,
-                    ...initialResult !== void 0 ? { result: initialResult } : {},
-                    status: initialStatus,
-                    startTime: Date.now(),
-                    ...endTime !== void 0 ? { endTime } : {}
-                  })
-                });
-                const currentIdx = prev.findIndex((message) => message.id === currentAssistantId && message.role === "assistant" && message.isStreaming && canHostActivity(message));
-                if (currentIdx >= 0) {
-                  const next = [...prev];
-                  next[currentIdx] = appendToolCall({
-                    ...next[currentIdx],
-                    isStreaming: true,
-                    isComplete: false,
-                    ...currentAssistantSender ? { sender: currentAssistantSender } : {}
-                  });
-                  return next;
-                }
-                const last = prev[prev.length - 1];
-                if (canHostActivity(last) && canAttachToStreamingAssistant(
-                  last,
-                  eventAgentKey
-                )) {
-                  currentAssistantId = last.id;
-                  const next = [...prev];
-                  next[prev.length - 1] = appendToolCall({
-                    ...last,
-                    isStreaming: true,
-                    isComplete: false,
-                    ...currentAssistantSender ? { sender: currentAssistantSender } : {}
-                  });
-                  return next;
-                }
-                const newId = generateId();
-                currentAssistantId = newId;
-                return [
-                  ...prev,
-                  appendToolCall({
-                    id: newId,
-                    role: "assistant",
-                    content: "",
-                    timestamp: nowTs(),
-                    isStreaming: true,
-                    isComplete: false,
-                    ...currentAssistantSender ? { sender: currentAssistantSender } : {}
-                  })
-                ];
-              })()
-            );
-            hasStreamProgress = true;
-            return;
-          }
-          const sm = await toServerMessageFromEvent(event);
-          if (sm) {
-            const viewMsg = convertServerMessage(sm, {
-              senderOptions: senderOptionsRef.current,
-              createId: generateId,
-              now: nowTs
-            });
-            finalizeCurrentAssistantBubble();
-            setMessages((prev) => [...prev, viewMsg]);
-            return;
-          }
-          handleStreamMessageEvent(event);
-        },
-        onAssetEvent: async (payload) => {
-          const intercepted = applyEventInterceptor({ type: "ASSET_CREATED", payload });
-          if (intercepted?.handled) {
-            return;
-          }
-          await (async () => {
-            if (!hasStreamProgress) return;
-            handleStreamAssetEvent(payload, currentAssistantId);
-          })();
-        },
-        signal: abortController.signal
-      });
-    } finally {
-      setIsStreaming(false);
-      setMessages((prev) => {
-        const hasStreaming = prev.some((msg) => msg.isStreaming);
-        if (!hasStreaming) return prev;
-        return prev.map((msg) => msg.isStreaming ? closeAssistantMessage(msg) : msg);
-      });
-      abortControllerRef.current = null;
-    }
-    return currentAssistantId;
-  }, [applyEventInterceptor, handleStreamMessageEvent, handleStreamAssetEvent, getRequestHeaders]);
-  const handleSendMessage = useCallback2(async (content, attachments = []) => {
-    if (!content.trim() && attachments.length === 0) return;
-    if (!userId) return;
-    const timestamp = nowTs();
-    const curThreadId = currentThreadIdRef.current;
-    const curThreadExtId = currentThreadExternalIdRef.current;
-    const existingThreadId = curThreadId ?? void 0;
-    const extMap = threadExternalIdMapRef.current;
-    const isPlaceholderThread = existingThreadId ? extMap[existingThreadId] === existingThreadId : false;
-    const threadIdForSend = isPlaceholderThread ? void 0 : existingThreadId;
-    let effectiveThreadExternalId = curThreadExtId ?? (isPlaceholderThread ? existingThreadId : void 0);
-    if (!threadIdForSend) {
-      if (!effectiveThreadExternalId) {
-        effectiveThreadExternalId = generateId();
-      }
-      setCurrentThreadExternalId(effectiveThreadExternalId);
-    } else if (curThreadExtId !== (effectiveThreadExternalId ?? null)) {
-      setCurrentThreadExternalId(effectiveThreadExternalId ?? null);
-    }
-    const conversationKey = threadIdForSend ?? effectiveThreadExternalId;
-    const currentMetadata = threadMetadataMapRef.current[conversationKey];
-    const pendingTitle = currentMetadata?.pendingTitle;
-    const userMessage = {
-      id: generateId(),
-      role: "user",
-      content,
-      timestamp,
-      attachments: attachments.length > 0 ? attachments : void 0,
-      isComplete: true,
-      sender: resolveUserSender({
-        id: userId,
-        name: userContextSeedRef.current?.profile?.full_name ?? userId
-      })
-    };
-    const assistantSender = targetAgentNameRef.current ? resolveAgentSender(
-      { id: targetAgentNameRef.current, name: targetAgentNameRef.current },
-      senderOptionsRef.current
-    ) : preferredAgentRef.current ? resolveAgentSender(
-      { id: preferredAgentRef.current, name: preferredAgentRef.current },
-      senderOptionsRef.current
-    ) : resolveAssistantFallbackSender(senderOptionsRef.current);
-    const assistantPlaceholder = {
-      id: generateId(),
-      role: "assistant",
-      content: "",
-      timestamp: timestamp + 1,
-      isStreaming: true,
-      isComplete: false,
-      sender: assistantSender,
-      activity: createPendingAssistantActivity()
-    };
-    setMessages((prev) => [...prev, userMessage, assistantPlaceholder]);
-    setSpecialState(null);
-    if (!threadsRef.current.some((t) => t.id === conversationKey)) {
-      const newThread = {
-        id: conversationKey,
-        title: content.slice(0, 40) || "Nova conversa",
-        createdAt: timestamp,
-        updatedAt: timestamp,
-        messageCount: 0
-      };
-      setThreads((prev) => [newThread, ...prev]);
-      setThreadMetadataMap((prev) => ({ ...prev, [conversationKey]: {} }));
-      setThreadExternalIdMap((prev) => ({ ...prev, [conversationKey]: effectiveThreadExternalId ?? null }));
-    }
-    try {
-      await sendCopilotzMessage({
-        threadId: threadIdForSend,
-        threadExternalId: effectiveThreadExternalId,
-        content,
-        attachments,
-        userId,
-        // userName can be anything, but let's try to find it in context or just fallback
-        userName: userContextSeedRef.current?.profile?.full_name ?? userId,
-        agentName: preferredAgentRef.current,
-        assistantMessageId: assistantPlaceholder.id,
-        assistantSender,
-        // Include pending title for new threads
-        threadMetadata: pendingTitle ? { name: pendingTitle } : void 0
-      });
-      await new Promise((r) => setTimeout(r, 1e3));
-      await fetchAndSetThreadsState(userId, effectiveThreadExternalId ?? existingThreadId ?? null);
-    } catch (error) {
-      if (isAbortError(error)) return;
-      console.error("Error sending Copilotz message", error);
-      const nextSpecialState = getSpecialStateFromError(error);
-      if (nextSpecialState) {
-        setSpecialState(nextSpecialState);
-        setMessages((prev) => prev.filter((msg) => !msg.isStreaming));
-        return;
+          ];
+        });
       }
-      setMessages((prev) => {
-        const finalized = prev.map((msg) => msg.isStreaming ? closeAssistantMessage(msg) : msg);
-        if (finalized.some(hasVisibleAssistantOutput)) {
-          return finalized;
+    },
+    [userId, fetchAndSetThreadsState, loadThreadMessages, sendCopilotzMessage, getSpecialStateFromError]
+  );
+  const bootstrapConversation = useCallback2(
+    async (uid) => {
+      if (!bootstrap?.initialToolCalls && !bootstrap?.initialMessage) return;
+      const bootstrapThreadExternalId = generateId();
+      setCurrentThreadId(bootstrapThreadExternalId);
+      setCurrentThreadExternalId(bootstrapThreadExternalId);
+      setThreadExternalIdMap((prev) => ({
+        ...prev,
+        [bootstrapThreadExternalId]: bootstrapThreadExternalId
+      }));
+      setThreadMetadataMap((prev) => ({
+        ...prev,
+        [bootstrapThreadExternalId]: {}
+      }));
+      const assistantSender = preferredAgentRef.current ? resolveAgentSender({ id: preferredAgentRef.current, name: preferredAgentRef.current }, senderOptionsRef.current) : resolveAssistantFallbackSender(senderOptionsRef.current);
+      const assistantMessageId = generateId();
+      setMessages([
+        {
+          id: assistantMessageId,
+          role: "assistant",
+          content: "",
+          timestamp: nowTs(),
+          isStreaming: true,
+          isComplete: false,
+          sender: assistantSender,
+          activity: createPendingAssistantActivity()
         }
-        for (let i = finalized.length - 1; i >= 0; i--) {
-          const message = finalized[i];
-          if (message.role !== "assistant") continue;
-          const updated = [...finalized];
-          updated[i] = {
-            ...message,
-            content: "Desculpe, ocorreu um erro ao gerar a resposta. Por favor, tente novamente.",
-            isStreaming: false,
-            isComplete: true,
-            sender: message.sender ?? resolveAssistantFallbackSender(senderOptionsRef.current)
-          };
-          return updated;
+      ]);
+      setMessagePageInfo(createEmptyMessagePageInfo());
+      persistedToolUpdatesRef.current = [];
+      setSpecialState(null);
+      try {
+        await sendCopilotzMessage({
+          threadExternalId: bootstrapThreadExternalId,
+          content: bootstrap.initialMessage || "",
+          toolCalls: bootstrap.initialToolCalls,
+          userId: uid,
+          userName: getCurrentUserDisplayName(userName, uid),
+          agentName: preferredAgentRef.current,
+          assistantMessageId,
+          assistantSender,
+          threadMetadata: {
+            name: defaultThreadName || "Main Thread"
+          }
+        });
+        await new Promise((r) => setTimeout(r, 1e3));
+        await fetchAndSetThreadsState(uid, bootstrapThreadExternalId);
+      } catch (error) {
+        if (isAbortError(error)) return;
+        console.error("Error bootstrapping conversation", error);
+        const nextSpecialState = getSpecialStateFromError(error);
+        if (nextSpecialState) {
+          setSpecialState(nextSpecialState);
+          setMessages([]);
+          return;
         }
-        return [
-          ...finalized,
+        setMessages([
           {
             id: generateId(),
             role: "assistant",
-            content: "Desculpe, ocorreu um erro ao gerar a resposta. Por favor, tente novamente.",
+            content: "N\xE3o foi poss\xEDvel iniciar a conversa. Tente novamente mais tarde.",
             timestamp: nowTs(),
             isStreaming: false,
             isComplete: true,
             sender: resolveAssistantFallbackSender(senderOptionsRef.current)
           }
-        ];
-      });
-    }
-  }, [userId, fetchAndSetThreadsState, loadThreadMessages, sendCopilotzMessage, getSpecialStateFromError]);
-  const bootstrapConversation = useCallback2(async (uid) => {
-    if (!bootstrap?.initialToolCalls && !bootstrap?.initialMessage) return;
-    const bootstrapThreadExternalId = generateId();
-    setCurrentThreadId(bootstrapThreadExternalId);
-    setCurrentThreadExternalId(bootstrapThreadExternalId);
-    setThreadExternalIdMap((prev) => ({ ...prev, [bootstrapThreadExternalId]: bootstrapThreadExternalId }));
-    setThreadMetadataMap((prev) => ({ ...prev, [bootstrapThreadExternalId]: {} }));
-    const assistantSender = preferredAgentRef.current ? resolveAgentSender(
-      { id: preferredAgentRef.current, name: preferredAgentRef.current },
-      senderOptionsRef.current
-    ) : resolveAssistantFallbackSender(senderOptionsRef.current);
-    const assistantMessageId = generateId();
-    setMessages([{
-      id: assistantMessageId,
-      role: "assistant",
-      content: "",
-      timestamp: nowTs(),
-      isStreaming: true,
-      isComplete: false,
-      sender: assistantSender,
-      activity: createPendingAssistantActivity()
-    }]);
-    setMessagePageInfo(createEmptyMessagePageInfo());
-    persistedToolUpdatesRef.current = [];
-    setSpecialState(null);
-    try {
-      await sendCopilotzMessage({
-        threadExternalId: bootstrapThreadExternalId,
-        content: bootstrap.initialMessage || "",
-        toolCalls: bootstrap.initialToolCalls,
-        userId: uid,
-        agentName: preferredAgentRef.current,
-        assistantMessageId,
-        assistantSender,
-        threadMetadata: {
-          name: defaultThreadName || "Main Thread"
-        }
-      });
-      await new Promise((r) => setTimeout(r, 1e3));
-      await fetchAndSetThreadsState(uid, bootstrapThreadExternalId);
-    } catch (error) {
-      if (isAbortError(error)) return;
-      console.error("Error bootstrapping conversation", error);
-      const nextSpecialState = getSpecialStateFromError(error);
-      if (nextSpecialState) {
-        setSpecialState(nextSpecialState);
-        setMessages([]);
-        return;
+        ]);
       }
-      setMessages([
-        {
-          id: generateId(),
-          role: "assistant",
-          content: "N\xE3o foi poss\xEDvel iniciar a conversa. Tente novamente mais tarde.",
-          timestamp: nowTs(),
-          isStreaming: false,
-          isComplete: true,
-          sender: resolveAssistantFallbackSender(senderOptionsRef.current)
-        }
-      ]);
-    }
-  }, [fetchAndSetThreadsState, loadThreadMessages, sendCopilotzMessage, bootstrap, defaultThreadName, getSpecialStateFromError]);
+    },
+    [fetchAndSetThreadsState, loadThreadMessages, sendCopilotzMessage, bootstrap, defaultThreadName, getSpecialStateFromError]
+  );
   const reset = useCallback2(() => {
     messagesRequestRef.current += 1;
     setThreads([]);
@@ -2561,7 +2626,10 @@ function useCopilotz({
     const metadata = threadMetadataMap[currentThreadId];
     if (!metadata) return;
     if (metadata.userContext && typeof metadata.userContext === "object") {
-      setUserContextSeed((prev) => ({ ...prev, ...metadata.userContext }));
+      setUserContextSeed((prev) => ({
+        ...prev,
+        ...metadata.userContext
+      }));
     }
   }, [currentThreadId, threadMetadataMap]);
   return {
@@ -2580,6 +2648,7 @@ function useCopilotz({
     selectThread: handleSelectThread,
     renameThread: handleRenameThread,
     archiveThread: handleArchiveThread,
+    updateThreadTags: handleUpdateThreadTags,
     deleteThread: handleDeleteThread,
     stopGeneration: handleStop,
     fetchAndSetThreadsState,
@@ -2591,39 +2660,7 @@ function useCopilotz({
 
 // src/CopilotzChat.tsx
 import { jsx } from "react/jsx-runtime";
-var CopilotzChat = ({
-  userId,
-  userName,
-  userAvatar,
-  userEmail,
-  initialContext,
-  bootstrap,
-  config: userConfig,
-  callbacks: userCallbacks,
-  customComponent,
-  onToolOutput,
-  onCurrentThreadIdChange,
-  onLogout,
-  onViewProfile,
-  onAddMemory,
-  onUpdateMemory,
-  onDeleteMemory,
-  userMenuSections,
-  userMenuAdditionalItems,
-  suggestions,
-  agentOptions = [],
-  selectedAgentId = null,
-  onSelectAgent,
-  participantIds,
-  onParticipantsChange,
-  targetAgentId = null,
-  onTargetAgentChange,
-  getRequestHeaders,
-  className,
-  eventInterceptor,
-  runErrorInterceptor,
-  renderSpecialState
-}) => {
+var CopilotzChat = ({ userId, userName, userAvatar, userEmail, initialContext, bootstrap, config: userConfig, callbacks: userCallbacks, customComponent, onToolOutput, onCurrentThreadIdChange, onLogout, onViewProfile, onAddMemory, onUpdateMemory, onDeleteMemory, userMenuSections, userMenuAdditionalItems, suggestions, agentOptions = [], selectedAgentId = null, onSelectAgent, participantIds, onParticipantsChange, targetAgentId = null, onTargetAgentChange, getRequestHeaders, className, eventInterceptor, runErrorInterceptor, renderSpecialState }) => {
   const selectedAgent = agentOptions.find((agent) => agent.id === selectedAgentId) || null;
   const participantAgentIds = useMemo(() => {
     if (!participantIds || participantIds.length === 0) return null;
@@ -2634,26 +2671,7 @@ var CopilotzChat = ({
     if (!targetAgentId) return null;
     return targetAgentId;
   }, [targetAgentId]);
-  const {
-    messages,
-    isMessagesLoading,
-    isLoadingOlderMessages,
-    messagePageInfo,
-    threads,
-    currentThreadId,
-    isStreaming,
-    specialState,
-    clearSpecialState,
-    userContextSeed,
-    sendMessage,
-    createThread,
-    selectThread,
-    renameThread,
-    archiveThread,
-    deleteThread: deleteThread2,
-    stopGeneration,
-    loadOlderMessages
-  } = useCopilotz({
+  const { messages, isMessagesLoading, isLoadingOlderMessages, messagePageInfo, threads, currentThreadId, isStreaming, specialState, clearSpecialState, userContextSeed, sendMessage, createThread, selectThread, renameThread, archiveThread, updateThreadTags, deleteThread: deleteThread2, stopGeneration, loadOlderMessages } = useCopilotz({
     userId,
     userName,
     userAvatar,
@@ -2674,17 +2692,7 @@ var CopilotzChat = ({
     onCurrentThreadIdChange?.(currentThreadId);
   }, [currentThreadId, onCurrentThreadIdChange]);
   const chatCallbacks = useMemo(() => {
-    const {
-      onSendMessage: _1,
-      onStopGeneration: _2,
-      onCreateThread: _3,
-      onSelectThread: _4,
-      onRenameThread: _5,
-      onArchiveThread: _6,
-      onDeleteThread: _7,
-      onCopyMessage: _8,
-      ...restUserCallbacks
-    } = userCallbacks || {};
+    const { onSendMessage: _1, onStopGeneration: _2, onCreateThread: _3, onSelectThread: _4, onRenameThread: _5, onArchiveThread: _6, onDeleteThread: _7, onUpdateThreadTags: _8, onCopyMessage: _9, ...restUserCallbacks } = userCallbacks || {};
     return {
       ...restUserCallbacks,
       onSendMessage: (content, attachments) => {
@@ -2711,6 +2719,10 @@ var CopilotzChat = ({
         void archiveThread(threadId);
         userCallbacks?.onArchiveThread?.(threadId);
       },
+      onUpdateThreadTags: (threadId, tags) => {
+        void updateThreadTags(threadId, tags);
+        userCallbacks?.onUpdateThreadTags?.(threadId, tags);
+      },
       onDeleteThread: (threadId) => {
         void deleteThread2(threadId);
         userCallbacks?.onDeleteThread?.(threadId);
@@ -2726,18 +2738,7 @@ var CopilotzChat = ({
       onLogout,
       onViewProfile
     };
-  }, [
-    sendMessage,
-    stopGeneration,
-    createThread,
-    selectThread,
-    renameThread,
-    archiveThread,
-    deleteThread2,
-    userCallbacks,
-    onLogout,
-    onViewProfile
-  ]);
+  }, [sendMessage, stopGeneration, createThread, selectThread, renameThread, archiveThread, updateThreadTags, deleteThread2, userCallbacks, onLogout, onViewProfile]);
   const mergedConfig = useMemo(() => {
     const base = userConfig || {};
     if (!customComponent) {
@@ -2754,53 +2755,25 @@ var CopilotzChat = ({
   }, [userConfig, customComponent]);
   const effectiveUserName = userName || userId;
   const effectiveUserAvatar = userAvatar;
-  const userProp = useMemo(() => ({
-    id: userId,
-    name: effectiveUserName,
-    email: userEmail,
-    avatar: effectiveUserAvatar
-  }), [userId, effectiveUserName, userEmail, effectiveUserAvatar]);
-  const assistantProp = useMemo(() => ({
-    name: userConfig?.branding?.title,
-    avatar: userConfig?.branding?.avatar,
-    description: userConfig?.branding?.subtitle
-  }), [
-    userConfig?.branding?.title,
-    userConfig?.branding?.avatar,
-    userConfig?.branding?.subtitle
-  ]);
+  const userProp = useMemo(
+    () => ({
+      id: userId,
+      name: effectiveUserName,
+      email: userEmail,
+      avatar: effectiveUserAvatar
+    }),
+    [userId, effectiveUserName, userEmail, effectiveUserAvatar]
+  );
+  const assistantProp = useMemo(
+    () => ({
+      name: userConfig?.branding?.title,
+      avatar: userConfig?.branding?.avatar,
+      description: userConfig?.branding?.subtitle
+    }),
+    [userConfig?.branding?.title, userConfig?.branding?.avatar, userConfig?.branding?.subtitle]
+  );
   const specialStateContent = specialState ? renderSpecialState?.(specialState, { clear: clearSpecialState }) : null;
-  return /* @__PURE__ */ jsx(ChatUserContextProvider, { initial: userContextSeed, children: specialStateContent ?? /* @__PURE__ */ jsx(
-    ChatUI,
-    {
-      messages,
-      isMessagesLoading,
-      isLoadingOlderMessages,
-      hasMoreMessagesBefore: messagePageInfo.hasMoreBefore,
-      onLoadOlderMessages: loadOlderMessages,
-      threads,
-      currentThreadId,
-      config: mergedConfig,
-      callbacks: chatCallbacks,
-      isGenerating: isStreaming,
-      suggestions,
-      agentOptions,
-      selectedAgentId,
-      onSelectAgent,
-      participantIds,
-      onParticipantsChange,
-      targetAgentId,
-      onTargetAgentChange,
-      user: userProp,
-      assistant: assistantProp,
-      onAddMemory,
-      onUpdateMemory,
-      onDeleteMemory,
-      userMenuSections,
-      userMenuAdditionalItems,
-      className
-    }
-  ) });
+  return /* @__PURE__ */ jsx(ChatUserContextProvider, { initial: userContextSeed, children: specialStateContent ?? /* @__PURE__ */ jsx(ChatUI, { messages, isMessagesLoading, isLoadingOlderMessages, hasMoreMessagesBefore: messagePageInfo.hasMoreBefore, onLoadOlderMessages: loadOlderMessages, threads, currentThreadId, config: mergedConfig, callbacks: chatCallbacks, isGenerating: isStreaming, suggestions, agentOptions, selectedAgentId, onSelectAgent, participantIds, onParticipantsChange, targetAgentId, onTargetAgentChange, user: userProp, assistant: assistantProp, onAddMemory, onUpdateMemory, onDeleteMemory, userMenuSections, userMenuAdditionalItems, className }) });
 };
 export {
   CopilotzChat,