@assistant-ui/react 0.0.13 → 0.0.15

package/dist/index.mjs

@@ -35,7 +35,7 @@ var useAssistantContext = () => {
   const context = useContext(AssistantContext);
   if (!context)
     throw new Error(
-      "useAssistantContext must be used within a AssistantProvider"
+      "This component must be used within a AssistantProvider."
     );
   return context;
 };
@@ -44,14 +44,10 @@ var useAssistantContext = () => {
 var useThreadIf = (props) => {
   const { useThread } = useAssistantContext();
   return useThread((thread) => {
-    if (props.empty === true && thread.messages.length !== 0)
-      return false;
-    if (props.empty === false && thread.messages.length === 0)
-      return false;
-    if (props.running === true && !thread.isRunning)
-      return false;
-    if (props.running === false && thread.isRunning)
-      return false;
+    if (props.empty === true && thread.messages.length !== 0) return false;
+    if (props.empty === false && thread.messages.length === 0) return false;
+    if (props.running === true && !thread.isRunning) return false;
+    if (props.running === false && thread.isRunning) return false;
     return true;
   });
 };
@@ -81,8 +77,7 @@ var useOnResizeContent = (ref, callback) => {
   callbackRef.current = callback;
   useLayoutEffect(() => {
     const el = ref.current;
-    if (!el)
-      return;
+    if (!el) return;
     const resizeObserver = new ResizeObserver(() => {
       callbackRef.current();
     });
@@ -137,16 +132,14 @@ var ThreadViewport = forwardRef2(({ autoScroll = true, onScroll, children, ...re
   const lastScrollTop = useRef3(0);
   const scrollToBottom = () => {
     const div = messagesEndRef.current;
-    if (!div || !autoScroll)
-      return;
+    if (!div || !autoScroll) return;
     const behavior = firstRenderRef.current ? "instant" : "auto";
     firstRenderRef.current = false;
     useViewport.setState({ isAtBottom: true });
     div.scrollIntoView({ behavior });
   };
   useOnResizeContent(divRef, () => {
-    if (!useViewport.getState().isAtBottom)
-      return;
+    if (!useViewport.getState().isAtBottom) return;
     scrollToBottom();
   });
   useOnScrollToBottom(() => {
@@ -154,8 +147,7 @@ var ThreadViewport = forwardRef2(({ autoScroll = true, onScroll, children, ...re
   });
   const handleScroll = () => {
     const div = divRef.current;
-    if (!div)
-      return;
+    if (!div) return;
     const isAtBottom = useViewport.getState().isAtBottom;
     const newIsAtBottom = div.scrollHeight - div.scrollTop <= div.clientHeight;
     if (!newIsAtBottom && lastScrollTop.current < div.scrollTop) {
@@ -187,7 +179,7 @@ var MessageContext = createContext2(null);
 var useMessageContext = () => {
   const context = useContext2(MessageContext);
   if (!context)
-    throw new Error("useMessageContext must be used within a MessageProvider");
+    throw new Error("This component must be used within a MessageProvider.");
   return context;
 };
 
@@ -205,10 +197,8 @@ var useComposerContext = () => {
 var useComposerIf = (props) => {
   const { useComposer } = useComposerContext();
   return useComposer((composer) => {
-    if (props.editing === true && !composer.isEditing)
-      return false;
-    if (props.editing === false && composer.isEditing)
-      return false;
+    if (props.editing === true && !composer.isEditing) return false;
+    if (props.editing === false && composer.isEditing) return false;
     return true;
   });
 };
@@ -230,6 +220,14 @@ __export(message_exports, {
 import { useMemo, useState } from "react";
 import { create as create2 } from "zustand";
 
+// src/utils/context/getMessageText.tsx
+var getMessageText = (message) => {
+  const textParts = message.content.filter(
+    (part) => part.type === "text"
+  );
+  return textParts.map((part) => part.text).join("\n\n");
+};
+
 // src/utils/context/stores/ComposerStore.ts
 import {
   create
@@ -256,8 +254,7 @@ var makeMessageComposerStore = ({
     onSend(value);
   },
   cancel: () => {
-    if (!get().isEditing)
-      return false;
+    if (!get().isEditing) return false;
     set({ isEditing: false });
     return true;
   }
@@ -276,8 +273,7 @@ var makeThreadComposerStore = (useThread) => create()((set, get, store) => {
     },
     cancel: () => {
       const thread = useThread.getState();
-      if (!thread.isRunning)
-        return false;
+      if (!thread.isRunning) return false;
       useThread.getState().cancelRun();
       return true;
     }
@@ -292,31 +288,42 @@ var getIsLast = (thread, message) => {
 var useMessageContext2 = () => {
   const { useThread } = useAssistantContext();
   const [context] = useState(() => {
-    const useMessage = create2(() => ({
+    const useMessage = create2((set) => ({
       message: null,
+      parentId: null,
       branches: [],
       isLast: false,
       isCopied: false,
       isHovering: false,
-      setIsCopied: () => {
+      setIsCopied: (value) => {
+        set({ isCopied: value });
       },
-      setIsHovering: () => {
+      setIsHovering: (value) => {
+        set({ isHovering: value });
       }
     }));
     const useComposer = makeMessageComposerStore({
       onEdit: () => {
         const message = useMessage.getState().message;
         if (message.role !== "user")
-          throw new Error("Editing is only supported for user messages");
-        if (message.content[0]?.type !== "text")
-          throw new Error("Editing is only supported for text-only messages");
-        return message.content[0].text;
+          throw new Error(
+            "Tried to edit a non-user message. Editing is only supported for user messages. This is likely an internal bug in assistant-ui."
+          );
+        const text = getMessageText(message);
+        return text;
       },
       onSend: (text) => {
-        const message = useMessage.getState().message;
+        const { message, parentId } = useMessage.getState();
+        if (message.role !== "user")
+          throw new Error(
+            "Tried to edit a non-user message. Editing is only supported for user messages. This is likely an internal bug in assistant-ui."
+          );
+        const nonTextParts = message.content.filter(
+          (part) => part.type !== "text" && part.type !== "ui"
+        );
         useThread.getState().append({
-          parentId: message.parentId,
-          content: [{ type: "text", text }]
+          parentId,
+          content: [{ type: "text", text }, ...nonTextParts]
         });
       }
     });
@@ -326,28 +333,21 @@ var useMessageContext2 = () => {
 };
 var MessageProvider = ({
   message,
+  parentId,
   children
 }) => {
   const { useThread } = useAssistantContext();
   const context = useMessageContext2();
   const isLast = useThread((thread) => getIsLast(thread, message));
   const branches = useThread((thread) => thread.getBranches(message.id));
-  const [isCopied, setIsCopied] = useState(false);
-  const [isHovering, setIsHovering] = useState(false);
   useMemo(() => {
-    context.useMessage.setState(
-      {
-        message,
-        branches,
-        isLast,
-        isCopied,
-        isHovering,
-        setIsCopied,
-        setIsHovering
-      },
-      true
-    );
-  }, [context, message, branches, isLast, isCopied, isHovering]);
+    context.useMessage.setState({
+      message,
+      parentId,
+      branches,
+      isLast
+    });
+  }, [context, message, parentId, branches, isLast]);
   return /* @__PURE__ */ jsx4(MessageContext.Provider, { value: context, children });
 };
 
@@ -384,18 +384,12 @@ var MessageRoot = forwardRef3(
 var useMessageIf = (props) => {
   const { useMessage } = useMessageContext();
   return useMessage(({ message, branches, isLast, isCopied, isHovering }) => {
-    if (props.hasBranches === true && branches.length < 2)
-      return false;
-    if (props.user && message.role !== "user")
-      return false;
-    if (props.assistant && message.role !== "assistant")
-      return false;
-    if (props.lastOrHover === true && !isHovering && !isLast)
-      return false;
-    if (props.copied === true && !isCopied)
-      return false;
-    if (props.copied === false && isCopied)
-      return false;
+    if (props.hasBranches === true && branches.length < 2) return false;
+    if (props.user && message.role !== "user") return false;
+    if (props.assistant && message.role !== "assistant") return false;
+    if (props.lastOrHover === true && !isHovering && !isLast) return false;
+    if (props.copied === true && !isCopied) return false;
+    if (props.copied === false && isCopied) return false;
     return true;
   });
 };
@@ -457,18 +451,23 @@ var ThreadMessages = ({ components }) => {
   const thread = useThread();
   const messages = thread.messages;
   const { UserMessage, EditComposer, AssistantMessage } = getComponents(components);
-  if (messages.length === 0)
-    return null;
+  if (messages.length === 0) return null;
   return /* @__PURE__ */ jsx7(Fragment2, { children: messages.map((message, idx) => {
-    return (
-      // biome-ignore lint/suspicious/noArrayIndexKey: fixes a11y issues with branch navigation
-      /* @__PURE__ */ jsxs2(MessageProvider, { message, children: [
-        /* @__PURE__ */ jsxs2(MessageIf, { user: true, children: [
-          /* @__PURE__ */ jsx7(ComposerIf, { editing: false, children: /* @__PURE__ */ jsx7(UserMessage, {}) }),
-          /* @__PURE__ */ jsx7(ComposerIf, { editing: true, children: /* @__PURE__ */ jsx7(EditComposer, {}) })
-        ] }),
-        /* @__PURE__ */ jsx7(MessageIf, { assistant: true, children: /* @__PURE__ */ jsx7(AssistantMessage, {}) })
-      ] }, idx)
+    const parentId = messages[idx - 1]?.id ?? null;
+    return /* @__PURE__ */ jsxs2(
+      MessageProvider,
+      {
+        message,
+        parentId,
+        children: [
+          /* @__PURE__ */ jsxs2(MessageIf, { user: true, children: [
+            /* @__PURE__ */ jsx7(ComposerIf, { editing: false, children: /* @__PURE__ */ jsx7(UserMessage, {}) }),
+            /* @__PURE__ */ jsx7(ComposerIf, { editing: true, children: /* @__PURE__ */ jsx7(EditComposer, {}) })
+          ] }),
+          /* @__PURE__ */ jsx7(MessageIf, { assistant: true, children: /* @__PURE__ */ jsx7(AssistantMessage, {}) })
+        ]
+      },
+      parentId ?? "__ROOT__"
     );
   }) });
 };
@@ -552,8 +551,7 @@ var ComposerRoot = forwardRef6(
     const ref = useComposedRefs2(forwardedRef, formRef);
     const handleSubmit = (e) => {
       const composerState = useComposer.getState();
-      if (!composerState.isEditing)
-        return;
+      if (!composerState.isEditing) return;
       e.preventDefault();
       composerState.send();
       useViewport.getState().scrollToBottom();
@@ -582,18 +580,16 @@ import {
 import TextareaAutosize from "react-textarea-autosize";
 import { jsx as jsx11 } from "react/jsx-runtime";
 var ComposerInput = forwardRef7(
-  ({ autoFocus, asChild, disabled, onChange, onKeyDown, ...rest }, forwardedRef) => {
+  ({ autoFocus = false, asChild, disabled, onChange, onKeyDown, ...rest }, forwardedRef) => {
     const { useThread, useViewport } = useAssistantContext();
     const { useComposer, type } = useComposerContext();
     const value = useComposer((c) => {
-      if (!c.isEditing)
-        return "";
+      if (!c.isEditing) return "";
       return c.value;
     });
     const Component = asChild ? Slot : TextareaAutosize;
     const handleKeyPress = (e) => {
-      if (disabled)
-        return;
+      if (disabled) return;
       const composer = useComposer.getState();
       if (e.key === "Escape") {
         if (useComposer.getState().cancel()) {
@@ -610,11 +606,10 @@ var ComposerInput = forwardRef7(
     };
     const textareaRef = useRef5(null);
     const ref = useComposedRefs3(forwardedRef, textareaRef);
-    const autoFocusEnabled = autoFocus !== false && !disabled;
+    const autoFocusEnabled = autoFocus && !disabled;
     const focus = useCallback(() => {
       const textarea = textareaRef.current;
-      if (!textarea || !autoFocusEnabled)
-        return;
+      if (!textarea || !autoFocusEnabled) return;
       textarea.focus();
       textarea.setSelectionRange(
         textareaRef.current.value.length,
@@ -636,8 +631,7 @@ var ComposerInput = forwardRef7(
         disabled,
         onChange: composeEventHandlers6(onChange, (e) => {
           const composerState = useComposer.getState();
-          if (!composerState.isEditing)
-            return;
+          if (!composerState.isEditing) return;
           return composerState.setValue(e.target.value);
         }),
         onKeyDown: composeEventHandlers6(onKeyDown, handleKeyPress)
@@ -735,8 +729,7 @@ var useGoToNextBranch = () => {
     [useMessage, useComposer],
     (m, c) => c.isEditing || m.branches.indexOf(m.message.id) + 1 >= m.branches.length
   );
-  if (disabled)
-    return null;
+  if (disabled) return null;
   return () => {
     const { message, branches } = useMessage.getState();
     useThread.getState().switchToBranch(branches[branches.indexOf(message.id) + 1]);
@@ -779,8 +772,7 @@ var useGoToPreviousBranch = () => {
     [useMessage, useComposer],
     (m, c) => c.isEditing || m.branches.indexOf(m.message.id) <= 0
   );
-  if (disabled)
-    return null;
+  if (disabled) return null;
   return () => {
     const { message, branches } = useMessage.getState();
     useThread.getState().switchToBranch(
@@ -840,20 +832,16 @@ var ActionBarRoot = forwardRef12(({ hideWhenRunning, autohide, autohideFloat, ..
   const hideAndfloatStatus = useCombinedStore(
     [useThread, useMessage],
     (t, m) => {
-      if (hideWhenRunning && t.isRunning)
-        return "hidden" /* Hidden */;
+      if (hideWhenRunning && t.isRunning) return "hidden" /* Hidden */;
       const autohideEnabled = autohide === "always" || autohide === "not-last" && !m.isLast;
-      if (!autohideEnabled)
-        return "normal" /* Normal */;
-      if (!m.isHovering)
-        return "hidden" /* Hidden */;
+      if (!autohideEnabled) return "normal" /* Normal */;
+      if (!m.isHovering) return "hidden" /* Hidden */;
       if (autohideFloat === "always" || autohideFloat === "single-branch" && m.branches.length <= 1)
         return "floating" /* Floating */;
       return "normal" /* Normal */;
     }
   );
-  if (hideAndfloatStatus === "hidden" /* Hidden */)
-    return null;
+  if (hideAndfloatStatus === "hidden" /* Hidden */) return null;
   return /* @__PURE__ */ jsx18(
     Primitive11.div,
     {
@@ -867,14 +855,18 @@ var ActionBarRoot = forwardRef12(({ hideWhenRunning, autohide, autohideFloat, ..
 // src/actions/useCopyMessage.tsx
 var useCopyMessage = ({ copiedDuration = 3e3 }) => {
   const { useMessage, useComposer } = useMessageContext();
-  const isEditing = useComposer((s) => s.isEditing);
-  if (isEditing)
-    return null;
+  const hasCopyableContent = useCombinedStore(
+    [useMessage, useComposer],
+    (m, c) => {
+      return c.isEditing || m.message.content.some((c2) => c2.type === "text");
+    }
+  );
+  if (!hasCopyableContent) return null;
   return () => {
+    const { isEditing, value: composerValue } = useComposer.getState();
     const { message, setIsCopied } = useMessage.getState();
-    if (message.content[0]?.type !== "text")
-      throw new Error("Copying is only supported for text-only messages");
-    navigator.clipboard.writeText(message.content[0].text);
+    const valueToCopy = isEditing ? composerValue : getMessageText(message);
+    navigator.clipboard.writeText(valueToCopy);
     setIsCopied(true);
     setTimeout(() => setIsCopied(false), copiedDuration);
   };
@@ -891,13 +883,10 @@ var useReloadMessage = () => {
     [useThread, useMessage],
     (t, m) => t.isRunning || m.message.role !== "assistant"
   );
-  if (disabled)
-    return null;
+  if (disabled) return null;
   return () => {
-    const message = useMessage.getState().message;
-    if (message.role !== "assistant")
-      throw new Error("Reloading is only supported on assistant messages");
-    useThread.getState().startRun(message.parentId);
+    const { parentId } = useMessage.getState();
+    useThread.getState().startRun(parentId);
     useViewport.getState().scrollToBottom();
   };
 };
@@ -912,8 +901,7 @@ var useBeginMessageEdit = () => {
     [useMessage, useComposer],
     (m, c) => m.message.role !== "user" || c.isEditing
   );
-  if (disabled)
-    return null;
+  if (disabled) return null;
   return () => {
     const { edit } = useComposer.getState();
     edit();
@@ -924,7 +912,7 @@ var useBeginMessageEdit = () => {
 var ActionBarEdit = createActionButton(useBeginMessageEdit);
 
 // src/adapters/vercel/VercelAIAssistantProvider.tsx
-import { useCallback as useCallback3, useMemo as useMemo4 } from "react";
+import { useMemo as useMemo4 } from "react";
 
 // src/adapters/vercel/useDummyAIAssistantContext.tsx
 import { useState as useState2 } from "react";
@@ -961,13 +949,13 @@ var makeDummyThreadStore = () => {
     switchToBranch: () => {
       throw new Error("Not implemented");
     },
-    append: async () => {
+    append: () => {
       throw new Error("Not implemented");
     },
-    cancelRun: () => {
+    startRun: () => {
       throw new Error("Not implemented");
     },
-    startRun: async () => {
+    cancelRun: () => {
       throw new Error("Not implemented");
     }
   }));
@@ -982,7 +970,7 @@ var useDummyAIAssistantContext = () => {
   return context;
 };
 
-// src/adapters/vercel/useVercelAIBranches.tsx
+// src/adapters/vercel/useVercelAIThreadState.tsx
 import { useCallback as useCallback2, useMemo as useMemo3, useRef as useRef6, useState as useState3 } from "react";
 
 // src/adapters/MessageRepository.tsx
@@ -995,8 +983,7 @@ var optimisticPrefix = "__optimistic__";
 var generateOptimisticId = () => `${optimisticPrefix}${generateId()}`;
 var isOptimisticId = (id) => id.startsWith(optimisticPrefix);
 var findHead = (message) => {
-  if (message.next)
-    return findHead(message.next);
+  if (message.next) return findHead(message.next);
   return message;
 };
 var MessageRepository = class {
@@ -1011,19 +998,21 @@ var MessageRepository = class {
     }
     return messages;
   }
-  addOrUpdateMessage(message) {
+  addOrUpdateMessage(parentId, message) {
     const item = this.messages.get(message.id);
     if (item) {
-      if (item.current.parentId !== message.parentId) {
+      if ((item.prev?.current.id ?? null) !== parentId) {
         this.deleteMessage(message.id);
       } else {
         item.current = message;
         return;
       }
     }
-    const prev = message.parentId ? this.messages.get(message.parentId) : null;
+    const prev = parentId ? this.messages.get(parentId) : null;
     if (prev === void 0)
-      throw new Error("Unexpected: Parent message not found");
+      throw new Error(
+        "MessageRepository(addOrUpdateMessage): Parent message not found. This is likely an internal bug in assistant-ui."
+      );
     const newItem = {
       prev,
       current: message,
@@ -1045,7 +1034,9 @@ var MessageRepository = class {
   deleteMessage(messageId) {
     const message = this.messages.get(messageId);
     if (!message)
-      throw new Error("Unexpected: Message not found");
+      throw new Error(
+        "MessageRepository(deleteMessage): Message not found. This is likely an internal bug in assistant-ui."
+      );
     if (message.children.length > 0) {
       for (const child of message.children) {
         this.deleteMessage(child);
@@ -1060,7 +1051,9 @@ var MessageRepository = class {
         const childId = message.prev.children.at(-1);
         const child = childId ? this.messages.get(childId) : null;
         if (child === void 0)
-          throw new Error("Unexpected: Child message not found");
+          throw new Error(
+            "MessageRepository(deleteMessage): Child message not found. This is likely an internal bug in assistant-ui."
+          );
         message.prev.next = child;
       }
     } else {
@@ -1070,16 +1063,16 @@ var MessageRepository = class {
       this.head = message.prev ? findHead(message.prev) : null;
     }
   }
-  getOptimisticId = () => {
+  getOptimisticId() {
     let optimisticId;
     do {
       optimisticId = generateOptimisticId();
     } while (this.messages.has(optimisticId));
     return optimisticId;
-  };
+  }
   commitOptimisticRun(parentId) {
     const optimisticId = this.getOptimisticId();
-    this.addOrUpdateMessage({
+    this.addOrUpdateMessage(parentId, {
       id: optimisticId,
       role: "assistant",
       content: [
@@ -1088,7 +1081,6 @@ var MessageRepository = class {
           text: ""
         }
       ],
-      parentId,
       createdAt: /* @__PURE__ */ new Date()
     });
     return optimisticId;
@@ -1096,7 +1088,9 @@ var MessageRepository = class {
   getBranches(messageId) {
     const message = this.messages.get(messageId);
     if (!message)
-      throw new Error("Unexpected: Message not found");
+      throw new Error(
+        "MessageRepository(getBranches): Message not found. This is likely an internal bug in assistant-ui."
+      );
     if (message.prev) {
       return message.prev.children;
     }
@@ -1105,7 +1099,9 @@ var MessageRepository = class {
   switchToBranch(messageId) {
     const message = this.messages.get(messageId);
     if (!message)
-      throw new Error("Unexpected: Branch not found");
+      throw new Error(
+        "MessageRepository(switchToBranch): Branch not found. This is likely an internal bug in assistant-ui."
+      );
     if (message.prev) {
       message.prev.next = message;
     }
@@ -1115,7 +1111,9 @@ var MessageRepository = class {
     if (messageId) {
       const message = this.messages.get(messageId);
       if (!message)
-        throw new Error("Unexpected: Branch not found");
+        throw new Error(
+          "MessageRepository(resetHead): Branch not found. This is likely an internal bug in assistant-ui."
+        );
       this.head = message;
       for (let current = message; current; current = current.prev) {
         if (current.prev) {
@@ -1128,151 +1126,171 @@ var MessageRepository = class {
   }
 };
 
-// src/adapters/vercel/useVercelAIBranches.tsx
+// src/adapters/ThreadMessageConverter.tsx
+var ThreadMessageConverter = class {
+  constructor(converter2) {
+    this.converter = converter2;
+  }
+  cache = /* @__PURE__ */ new WeakMap();
+  convertMessages(messages) {
+    return messages.map((m) => {
+      const cached = this.cache.get(m);
+      if (cached) return cached;
+      const newMessage = this.converter(m);
+      this.cache.set(m, newMessage);
+      return newMessage;
+    });
+  }
+};
+
+// src/adapters/vercel/useVercelAIThreadState.tsx
+var vercelToThreadMessage = (message) => {
+  if (message.role !== "user" && message.role !== "assistant")
+    throw new Error(
+      `You have a message with an unsupported role. The role ${message.role} is not supported.`
+    );
+  return {
+    id: message.id,
+    role: message.role,
+    content: [
+      ...message.content ? [{ type: "text", text: message.content }] : [],
+      ...message.toolInvocations?.map((t) => ({
+        type: "tool-call",
+        name: t.toolName,
+        args: t.args,
+        result: "result" in t ? t.result : void 0
+      })) ?? []
+    ],
+    // ignore type mismatch for now
+    createdAt: message.createdAt ?? /* @__PURE__ */ new Date(),
+    innerMessage: message
+  };
+};
+var converter = new ThreadMessageConverter(vercelToThreadMessage);
 var sliceMessagesUntil = (messages, messageId) => {
-  if (messageId == null)
-    return [];
-  if (isOptimisticId(messageId))
-    return messages;
+  if (messageId == null) return [];
+  if (isOptimisticId(messageId)) return messages;
   const messageIdx = messages.findIndex((m) => m.id === messageId);
   if (messageIdx === -1)
-    throw new Error("Unexpected: Message not found");
+    throw new Error(
+      "useVercelAIThreadState: Message not found. This is liekly an internal bug in assistant-ui."
+    );
   return messages.slice(0, messageIdx + 1);
 };
 var hasUpcomingMessage = (isRunning, messages) => {
   return isRunning && messages[messages.length - 1]?.role !== "assistant";
 };
-var useVercelAIBranches = (chat, messages) => {
+var getIsRunning = (vercel) => {
+  if ("isLoading" in vercel) return vercel.isLoading;
+  return vercel.status === "in_progress";
+};
+var useVercelAIThreadState = (vercel) => {
   const [data] = useState3(() => new MessageRepository());
-  const isRunning = "isLoading" in chat ? chat.isLoading : chat.status === "in_progress";
+  const vercelRef = useRef6(vercel);
+  vercelRef.current = vercel;
+  const isRunning = getIsRunning(vercelRef.current);
   const assistantOptimisticIdRef = useRef6(null);
-  const messagesEx = useMemo3(() => {
-    for (const message of messages) {
-      data.addOrUpdateMessage(message);
+  const messages = useMemo3(() => {
+    const vm = converter.convertMessages(vercel.messages);
+    for (let i = 0; i < vm.length; i++) {
+      const message = vm[i];
+      const parent = vm[i - 1];
+      data.addOrUpdateMessage(parent?.id ?? null, message);
     }
     if (assistantOptimisticIdRef.current) {
       data.deleteMessage(assistantOptimisticIdRef.current);
       assistantOptimisticIdRef.current = null;
     }
-    if (hasUpcomingMessage(isRunning, messages)) {
+    if (hasUpcomingMessage(isRunning, vm)) {
       assistantOptimisticIdRef.current = data.commitOptimisticRun(
-        messages.at(-1)?.id ?? null
+        vm.at(-1)?.id ?? null
       );
     }
-    data.resetHead(
-      assistantOptimisticIdRef.current ?? messages.at(-1)?.id ?? null
-    );
+    data.resetHead(assistantOptimisticIdRef.current ?? vm.at(-1)?.id ?? null);
     return data.getMessages();
-  }, [data, isRunning, messages]);
-  const getBranches = useCallback2(
+  }, [data, isRunning, vercel.messages]);
+  const getBranches2 = useCallback2(
     (messageId) => {
       return data.getBranches(messageId);
     },
     [data]
   );
-  const switchToBranch = useCallback2(
+  const switchToBranch2 = useCallback2(
     (messageId) => {
       data.switchToBranch(messageId);
-      chat.setMessages(
+      vercelRef.current.setMessages(
         data.getMessages().filter((m) => !isOptimisticId(m.id)).map((m) => m.innerMessage)
       );
     },
-    [data, chat.setMessages]
-  );
-  const reloadMaybe = "reload" in chat ? chat.reload : void 0;
-  const startRun = useCallback2(
-    async (parentId) => {
-      if (!reloadMaybe)
-        throw new Error("Reload not supported by Vercel AI SDK's useAssistant");
-      const newMessages = sliceMessagesUntil(chat.messages, parentId);
-      chat.setMessages(newMessages);
-      await reloadMaybe();
-    },
-    [chat.messages, chat.setMessages, reloadMaybe]
-  );
-  const append = useCallback2(
-    async (message) => {
-      if (message.content.length !== 1 || message.content[0]?.type !== "text")
-        throw new Error("Only text content is supported by Vercel AI SDK");
-      const newMessages = sliceMessagesUntil(chat.messages, message.parentId);
-      chat.setMessages(newMessages);
-      await chat.append({
-        role: "user",
-        content: message.content[0].text
-      });
-    },
-    [chat.messages, chat.setMessages, chat.append]
+    [data]
   );
+  const startRun = useCallback2(async (parentId) => {
+    const reloadMaybe = "reload" in vercelRef.current ? vercelRef.current.reload : void 0;
+    if (!reloadMaybe)
+      throw new Error(
+        "Reload is not supported by Vercel AI SDK's useAssistant."
+      );
+    const newMessages = sliceMessagesUntil(
+      vercelRef.current.messages,
+      parentId
+    );
+    vercelRef.current.setMessages(newMessages);
+    await reloadMaybe();
+  }, []);
+  const append = useCallback2(async (message) => {
+    if (message.content.length !== 1 || message.content[0]?.type !== "text")
+      throw new Error("Only text content is supported by Vercel AI SDK.");
+    const newMessages = sliceMessagesUntil(
+      vercelRef.current.messages,
+      message.parentId
+    );
+    vercelRef.current.setMessages(newMessages);
+    await vercelRef.current.append({
+      role: "user",
+      content: message.content[0].text
+    });
+  }, []);
+  const cancelRun2 = useCallback2(() => {
+    const lastMessage = vercelRef.current.messages.at(-1);
+    vercelRef.current.stop();
+    if (lastMessage?.role === "user") {
+      vercelRef.current.setInput(lastMessage.content);
+    }
+  }, []);
   return useMemo3(
     () => ({
-      messages: messagesEx,
-      getBranches,
-      switchToBranch,
+      isRunning,
+      messages,
+      getBranches: getBranches2,
+      switchToBranch: switchToBranch2,
       append,
-      startRun
+      startRun,
+      cancelRun: cancelRun2
     }),
-    [messagesEx, getBranches, switchToBranch, append, startRun]
+    [
+      isRunning,
+      messages,
+      getBranches2,
+      switchToBranch2,
+      append,
+      startRun,
+      cancelRun2
+    ]
   );
 };
 
 // src/adapters/vercel/VercelAIAssistantProvider.tsx
 import { jsx as jsx19 } from "react/jsx-runtime";
-var ThreadMessageCache = /* @__PURE__ */ new WeakMap();
-var vercelToThreadMessage = (message, parentId) => {
-  if (message.role !== "user" && message.role !== "assistant")
-    throw new Error("Unsupported role");
-  return {
-    parentId,
-    id: message.id,
-    role: message.role,
-    content: [{ type: "text", text: message.content }],
-    createdAt: message.createdAt ?? /* @__PURE__ */ new Date(),
-    innerMessage: message
-  };
-};
-var vercelToCachedThreadMessages = (messages) => {
-  return messages.map((m, idx) => {
-    const cached = ThreadMessageCache.get(m);
-    const parentId = messages[idx - 1]?.id ?? null;
-    if (cached && cached.parentId === parentId)
-      return cached;
-    const newMessage = vercelToThreadMessage(m, parentId);
-    ThreadMessageCache.set(m, newMessage);
-    return newMessage;
-  });
-};
 var VercelAIAssistantProvider = ({
   children,
   ...rest
 }) => {
   const context = useDummyAIAssistantContext();
   const vercel = "chat" in rest ? rest.chat : rest.assistant;
-  const messages = useMemo4(() => {
-    return vercelToCachedThreadMessages(vercel.messages);
-  }, [vercel.messages]);
-  const branches = useVercelAIBranches(vercel, messages);
-  const cancelRun = useCallback3(() => {
-    const lastMessage = vercel.messages.at(-1);
-    vercel.stop();
-    if (lastMessage?.role === "user") {
-      vercel.setInput(lastMessage.content);
-    }
-  }, [vercel.messages, vercel.stop, vercel.setInput]);
-  const isRunning = "isLoading" in vercel ? vercel.isLoading : vercel.status === "in_progress";
+  const threadState = useVercelAIThreadState(vercel);
   useMemo4(() => {
-    context.useThread.setState(
-      {
-        messages: branches.messages,
-        isRunning,
-        getBranches: branches.getBranches,
-        switchToBranch: branches.switchToBranch,
-        append: branches.append,
-        startRun: branches.startRun,
-        cancelRun
-      },
-      true
-    );
-  }, [context, isRunning, cancelRun, branches]);
+    context.useThread.setState(threadState, true);
+  }, [context, threadState]);
   useMemo4(() => {
     context.useComposer.setState({
       value: vercel.input,
@@ -1284,55 +1302,96 @@ var VercelAIAssistantProvider = ({
 
 // src/adapters/vercel/VercelRSCAssistantProvider.tsx
 import {
-  useCallback as useCallback4,
-  useMemo as useMemo5
+  useCallback as useCallback3,
+  useMemo as useMemo5,
+  useState as useState4
 } from "react";
 import { jsx as jsx20 } from "react/jsx-runtime";
-var ThreadMessageCache2 = /* @__PURE__ */ new WeakMap();
-var vercelToThreadMessage2 = (parentId, message) => {
-  if (message.role !== "user" && message.role !== "assistant")
-    throw new Error("Unsupported role");
+var vercelToThreadMessage2 = (message) => {
   return {
-    parentId,
     id: message.id,
     role: message.role,
     content: [{ type: "ui", display: message.display }],
     createdAt: message.createdAt ?? /* @__PURE__ */ new Date()
   };
 };
-var vercelToCachedThreadMessages2 = (messages) => {
-  return messages.map((m, idx) => {
-    const cached = ThreadMessageCache2.get(m);
-    const parentId = messages[idx - 1]?.id ?? null;
-    if (cached && cached.parentId === parentId)
-      return cached;
-    const newMessage = vercelToThreadMessage2(parentId, m);
-    ThreadMessageCache2.set(m, newMessage);
-    return newMessage;
-  });
+var EMPTY_BRANCHES = [];
+var getBranches = () => {
+  return EMPTY_BRANCHES;
 };
-var VercelRSCAssistantProvider = ({ children, messages: vercelMessages, append: vercelAppend }) => {
+var switchToBranch = () => {
+  throw new Error(
+    "Branch switching is not supported by VercelRSCAssistantProvider."
+  );
+};
+var cancelRun = () => {
+  if (process.env["NODE_ENV"] === "development") {
+    console.warn(
+      "Run cancellation is not supported by VercelRSCAssistantProvider."
+    );
+  }
+};
+var VercelRSCAssistantProvider = ({
+  children,
+  convertMessage,
+  messages: vercelMessages,
+  append: appendCallback,
+  edit,
+  reload
+}) => {
   const context = useDummyAIAssistantContext();
+  const [isRunning, setIsRunning] = useState4(false);
+  const withRunning = useCallback3((callback) => {
+    setIsRunning(true);
+    return callback.finally(() => setIsRunning(false));
+  }, []);
+  const converter2 = useMemo5(() => {
+    const rscConverter = convertMessage ?? ((m) => m);
+    return new ThreadMessageConverter((m) => {
+      return vercelToThreadMessage2(rscConverter(m));
+    });
+  }, [convertMessage]);
   const messages = useMemo5(() => {
-    return vercelToCachedThreadMessages2(vercelMessages);
-  }, [vercelMessages]);
-  const append = useCallback4(
+    return converter2.convertMessages(vercelMessages);
+  }, [converter2, vercelMessages]);
+  const append = useCallback3(
     async (message) => {
-      if (message.parentId !== (context.useThread.getState().messages.at(-1)?.id ?? null))
-        throw new Error("Unexpected: Message editing is not supported");
-      if (message.content[0]?.type !== "text") {
-        throw new Error("Only text content is currently supported");
+      if (message.parentId !== (context.useThread.getState().messages.at(-1)?.id ?? null)) {
+        if (!edit)
+          throw new Error(
+            "Message editing is not enabled, please provide an edit callback to VercelRSCAssistantProvider."
+          );
+        await withRunning(edit(message));
+      } else {
+        await withRunning(appendCallback(message));
       }
-      await vercelAppend(message);
     },
-    [context, vercelAppend]
+    [context, withRunning, appendCallback, edit]
+  );
+  const startRun = useCallback3(
+    async (parentId) => {
+      if (!reload)
+        throw new Error(
+          "Message reloading is not enabled, please provide a reload callback to VercelRSCAssistantProvider."
+        );
+      await withRunning(reload(parentId));
+    },
+    [withRunning, reload]
   );
   useMemo5(() => {
-    context.useThread.setState({
-      messages,
-      append
-    });
-  }, [context, messages, append]);
+    context.useThread.setState(
+      {
+        messages,
+        isRunning,
+        getBranches,
+        switchToBranch,
+        append,
+        startRun,
+        cancelRun
+      },
+      true
+    );
+  }, [context, messages, isRunning, append, startRun]);
   return /* @__PURE__ */ jsx20(AssistantContext.Provider, { value: context, children });
 };
 export {