@assistant-ui/react 0.0.18 → 0.0.20

package/dist/index.mjs

@@ -129,18 +129,22 @@ var ThreadViewport = forwardRef2(({ autoScroll = true, onScroll, children, ...re
   const ref = useComposedRefs(forwardedRef, divRef);
   const { useViewport } = useAssistantContext();
   const firstRenderRef = useRef(true);
+  const isScrollingToBottomRef = useRef(false);
   const lastScrollTop = useRef(0);
   const scrollToBottom = () => {
     const div = messagesEndRef.current;
     if (!div || !autoScroll) return;
     const behavior = firstRenderRef.current ? "instant" : "auto";
     firstRenderRef.current = false;
-    useViewport.setState({ isAtBottom: true });
+    isScrollingToBottomRef.current = true;
     div.scrollIntoView({ behavior });
   };
   useOnResizeContent(divRef, () => {
-    if (!useViewport.getState().isAtBottom) return;
-    scrollToBottom();
+    if (!isScrollingToBottomRef.current && !useViewport.getState().isAtBottom) {
+      handleScroll();
+    } else {
+      scrollToBottom();
+    }
   });
   useOnScrollToBottom(() => {
     scrollToBottom();
@@ -152,6 +156,7 @@ var ThreadViewport = forwardRef2(({ autoScroll = true, onScroll, children, ...re
     const newIsAtBottom = div.scrollHeight - div.scrollTop <= div.clientHeight;
     if (!newIsAtBottom && lastScrollTop.current < div.scrollTop) {
     } else if (newIsAtBottom !== isAtBottom) {
+      isScrollingToBottomRef.current = false;
       useViewport.setState({ isAtBottom: newIsAtBottom });
     }
     lastScrollTop.current = div.scrollTop;
@@ -818,6 +823,7 @@ __export(branchPicker_exports, {
 });
 
 // src/actions/useGoToNextBranch.tsx
+import { useCallback as useCallback2 } from "react";
 var useGoToNextBranch = () => {
   const { useThread } = useAssistantContext();
   const { useMessage, useComposer } = useMessageContext();
@@ -825,11 +831,12 @@ var useGoToNextBranch = () => {
     [useMessage, useComposer],
     (m, c) => c.isEditing || m.branches.indexOf(m.message.id) + 1 >= m.branches.length
   );
-  if (disabled) return null;
-  return () => {
+  const callback = useCallback2(() => {
     const { message, branches } = useMessage.getState();
     useThread.getState().switchToBranch(branches[branches.indexOf(message.id) + 1]);
-  };
+  }, [useMessage, useThread]);
+  if (disabled) return null;
+  return callback;
 };
 
 // src/utils/createActionButton.tsx
@@ -861,6 +868,7 @@ var createActionButton = (useActionButton) => {
 var BranchPickerNext = createActionButton(useGoToNextBranch);
 
 // src/actions/useGoToPreviousBranch.tsx
+import { useCallback as useCallback3 } from "react";
 var useGoToPreviousBranch = () => {
   const { useThread } = useAssistantContext();
   const { useMessage, useComposer } = useMessageContext();
@@ -868,13 +876,12 @@ var useGoToPreviousBranch = () => {
     [useMessage, useComposer],
     (m, c) => c.isEditing || m.branches.indexOf(m.message.id) <= 0
   );
-  if (disabled) return null;
-  return () => {
+  const callback = useCallback3(() => {
     const { message, branches } = useMessage.getState();
-    useThread.getState().switchToBranch(
-      branches[branches.indexOf(message.id) - 1]
-    );
-  };
+    useThread.getState().switchToBranch(branches[branches.indexOf(message.id) - 1]);
+  }, [useMessage, useThread]);
+  if (disabled) return null;
+  return callback;
 };
 
 // src/primitives/branchPicker/BranchPickerPrevious.tsx
@@ -948,6 +955,7 @@ var ActionBarRoot = forwardRef13(({ hideWhenRunning, autohide, autohideFloat, ..
 });
 
 // src/actions/useCopyMessage.tsx
+import { useCallback as useCallback4 } from "react";
 var useCopyMessage = ({ copiedDuration = 3e3 }) => {
   const { useMessage, useComposer } = useMessageContext();
   const hasCopyableContent = useCombinedStore(
@@ -956,21 +964,23 @@ var useCopyMessage = ({ copiedDuration = 3e3 }) => {
       return c.isEditing || m.message.content.some((c2) => c2.type === "text");
     }
   );
-  if (!hasCopyableContent) return null;
-  return () => {
+  const callback = useCallback4(() => {
     const { isEditing, value: composerValue } = useComposer.getState();
     const { message, setIsCopied } = useMessage.getState();
     const valueToCopy = isEditing ? composerValue : getMessageText(message);
     navigator.clipboard.writeText(valueToCopy);
     setIsCopied(true);
     setTimeout(() => setIsCopied(false), copiedDuration);
-  };
+  }, [useComposer, useMessage, copiedDuration]);
+  if (!hasCopyableContent) return null;
+  return callback;
 };
 
 // src/primitives/actionBar/ActionBarCopy.tsx
 var ActionBarCopy = createActionButton(useCopyMessage);
 
 // src/actions/useReloadMessage.tsx
+import { useCallback as useCallback5 } from "react";
 var useReloadMessage = () => {
   const { useThread, useViewport } = useAssistantContext();
   const { useMessage } = useMessageContext();
@@ -978,29 +988,32 @@ var useReloadMessage = () => {
     [useThread, useMessage],
     (t, m) => t.isRunning || m.message.role !== "assistant"
   );
-  if (disabled) return null;
-  return () => {
+  const callback = useCallback5(() => {
     const { parentId } = useMessage.getState();
     useThread.getState().startRun(parentId);
     useViewport.getState().scrollToBottom();
-  };
+  }, [useMessage, useThread, useViewport]);
+  if (disabled) return null;
+  return callback;
 };
 
 // src/primitives/actionBar/ActionBarReload.tsx
 var ActionBarReload = createActionButton(useReloadMessage);
 
 // src/actions/useBeginMessageEdit.tsx
+import { useCallback as useCallback6 } from "react";
 var useBeginMessageEdit = () => {
   const { useMessage, useComposer } = useMessageContext();
   const disabled = useCombinedStore(
     [useMessage, useComposer],
     (m, c) => m.message.role !== "user" || c.isEditing
   );
-  if (disabled) return null;
-  return () => {
+  const callback = useCallback6(() => {
     const { edit } = useComposer.getState();
     edit();
-  };
+  }, [useComposer]);
+  if (disabled) return null;
+  return callback;
 };
 
 // src/primitives/actionBar/ActionBarEdit.tsx
@@ -1014,10 +1027,15 @@ __export(contentPart_exports, {
 });
 
 // src/adapters/vercel/VercelAIAssistantProvider.tsx
-import { useMemo as useMemo6 } from "react";
+import { useEffect as useEffect6 } from "react";
 
-// src/adapters/vercel/useDummyAIAssistantContext.tsx
-import { useState as useState3 } from "react";
+// src/adapters/core/AssistantProvider.tsx
+import {
+  useEffect as useEffect4,
+  useInsertionEffect,
+  useRef as useRef4,
+  useState as useState3
+} from "react";
 import { create as create5 } from "zustand";
 
 // src/utils/context/stores/ViewportStore.tsx
@@ -1040,41 +1058,79 @@ var makeViewportStore = () => {
   }));
 };
 
-// src/adapters/vercel/useDummyAIAssistantContext.tsx
-var makeDummyThreadStore = () => {
-  return create5(() => ({
-    messages: [],
-    isRunning: false,
-    getBranches: () => {
-      return [];
-    },
-    switchToBranch: () => {
-      throw new Error("Not implemented");
-    },
-    append: () => {
-      throw new Error("Not implemented");
-    },
-    startRun: () => {
-      throw new Error("Not implemented");
-    },
-    cancelRun: () => {
-      throw new Error("Not implemented");
-    }
+// src/adapters/core/AssistantProvider.tsx
+import { jsx as jsx21 } from "react/jsx-runtime";
+var makeThreadStore = (runtimeRef) => {
+  const useThread = create5(() => ({
+    messages: runtimeRef.current.messages,
+    isRunning: runtimeRef.current.isRunning,
+    getBranches: (messageId) => runtimeRef.current.getBranches(messageId),
+    switchToBranch: (branchId) => runtimeRef.current.switchToBranch(branchId),
+    startRun: (parentId) => runtimeRef.current.startRun(parentId),
+    append: (message) => runtimeRef.current.append(message),
+    cancelRun: () => runtimeRef.current.cancelRun()
   }));
+  const onRuntimeUpdate = () => {
+    useThread.setState({
+      messages: runtimeRef.current.messages,
+      isRunning: runtimeRef.current.isRunning
+    });
+  };
+  return {
+    useThread,
+    onRuntimeUpdate
+  };
 };
-var useDummyAIAssistantContext = () => {
-  const [context] = useState3(() => {
-    const useThread = makeDummyThreadStore();
+var AssistantProvider = ({ children, runtime }) => {
+  const runtimeRef = useRef4(runtime);
+  useInsertionEffect(() => {
+    runtimeRef.current = runtime;
+  });
+  const [{ context, onRuntimeUpdate }] = useState3(() => {
+    const { useThread, onRuntimeUpdate: onRuntimeUpdate2 } = makeThreadStore(runtimeRef);
     const useViewport = makeViewportStore();
     const useComposer = makeThreadComposerStore(useThread);
-    return { useThread, useViewport, useComposer };
+    return {
+      context: {
+        useViewport,
+        useThread,
+        useComposer
+      },
+      onRuntimeUpdate: onRuntimeUpdate2
+    };
   });
-  return context;
+  useEffect4(() => {
+    onRuntimeUpdate();
+    return runtime.subscribe(onRuntimeUpdate);
+  }, [onRuntimeUpdate, runtime]);
+  return /* @__PURE__ */ jsx21(AssistantContext.Provider, { value: context, children });
 };
 
-// src/adapters/vercel/useVercelAIThreadState.tsx
-import { useCallbackRef as useCallbackRef3 } from "@radix-ui/react-use-callback-ref";
-import { useCallback as useCallback2, useMemo as useMemo5, useRef as useRef4, useState as useState4 } from "react";
+// src/adapters/core/vercel-use-chat/useVercelUseChatRuntime.tsx
+import { useEffect as useEffect5, useInsertionEffect as useInsertionEffect2, useMemo as useMemo5, useState as useState4 } from "react";
+
+// src/adapters/ThreadMessageConverter.ts
+var ThreadMessageConverter = class {
+  cache = /* @__PURE__ */ new WeakMap();
+  convertMessages(converter, messages) {
+    return messages.map((m) => {
+      const cached = this.cache.get(m);
+      const newMessage = converter(m, cached);
+      this.cache.set(m, newMessage);
+      return newMessage;
+    });
+  }
+};
+
+// src/adapters/vercel/VercelThreadMessage.tsx
+var symbolInnerMessage = Symbol("innerMessage");
+var symbolInnerRSCMessage = Symbol("innerRSCMessage");
+var getVercelMessage = (message) => {
+  return message[symbolInnerMessage];
+};
+var getVercelRSCMessage = (message) => {
+  return message[symbolInnerRSCMessage];
+};
 
 // src/adapters/idUtils.tsx
 import { customAlphabet } from "nanoid/non-secure";
@@ -1236,30 +1292,104 @@ var MessageRepository = class {
   }
 };
 
-// src/adapters/ThreadMessageConverter.ts
-var ThreadMessageConverter = class {
-  cache = /* @__PURE__ */ new WeakMap();
-  convertMessages(converter, messages) {
-    return messages.map((m) => {
-      const cached = this.cache.get(m);
-      const newMessage = converter(m, cached);
-      this.cache.set(m, newMessage);
-      return newMessage;
+// src/adapters/core/vercel-use-chat/VercelUseChatRuntime.tsx
+var sliceMessagesUntil = (messages, messageId) => {
+  if (messageId == null) return [];
+  const messageIdx = messages.findIndex((m) => m.id === messageId);
+  if (messageIdx === -1)
+    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 VercelUseChatRuntime = class {
+  constructor(vercel) {
+    this.vercel = vercel;
+  }
+  _subscriptions = /* @__PURE__ */ new Set();
+  repository = new MessageRepository();
+  assistantOptimisticId = null;
+  messages = [];
+  isRunning = false;
+  getBranches(messageId) {
+    return this.repository.getBranches(messageId);
+  }
+  switchToBranch(branchId) {
+    this.repository.switchToBranch(branchId);
+    this.vercel.setMessages(
+      this.repository.getMessages().map(getVercelMessage).filter((m) => m != null)
+    );
+  }
+  async append(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(
+      this.vercel.messages,
+      message.parentId
+    );
+    this.vercel.setMessages(newMessages);
+    await this.vercel.append({
+      role: "user",
+      content: message.content[0].text
     });
   }
+  async startRun(parentId) {
+    const reloadMaybe = "reload" in this.vercel ? this.vercel.reload : void 0;
+    if (!reloadMaybe)
+      throw new Error(
+        "Reload is not supported by Vercel AI SDK's useAssistant."
+      );
+    const newMessages = sliceMessagesUntil(this.vercel.messages, parentId);
+    this.vercel.setMessages(newMessages);
+    await reloadMaybe();
+  }
+  cancelRun() {
+    const lastMessage = this.vercel.messages.at(-1);
+    this.vercel.stop();
+    if (lastMessage?.role === "user") {
+      this.vercel.setInput(lastMessage.content);
+    }
+  }
+  updateData(isRunning, vm) {
+    for (let i = 0; i < vm.length; i++) {
+      const message = vm[i];
+      const parent = vm[i - 1];
+      this.repository.addOrUpdateMessage(parent?.id ?? null, message);
+    }
+    if (this.assistantOptimisticId) {
+      this.repository.deleteMessage(this.assistantOptimisticId, null);
+      this.assistantOptimisticId = null;
+    }
+    if (hasUpcomingMessage(isRunning, vm)) {
+      this.assistantOptimisticId = this.repository.appendOptimisticMessage(
+        vm.at(-1)?.id ?? null,
+        {
+          role: "assistant",
+          content: [{ type: "text", text: "" }]
+        }
+      );
+    }
+    this.repository.resetHead(
+      this.assistantOptimisticId ?? vm.at(-1)?.id ?? null
+    );
+    this.messages = this.repository.getMessages();
+    this.isRunning = isRunning;
+    for (const callback of this._subscriptions) callback();
+  }
+  subscribe(callback) {
+    this._subscriptions.add(callback);
+    return () => this._subscriptions.delete(callback);
+  }
 };
 
-// src/adapters/vercel/VercelThreadMessage.tsx
-var symbolInnerMessage = Symbol("innerMessage");
-var symbolInnerRSCMessage = Symbol("innerRSCMessage");
-var getVercelMessage = (message) => {
-  return message[symbolInnerMessage];
-};
-var getVercelRSCMessage = (message) => {
-  return message[symbolInnerRSCMessage];
+// src/adapters/core/vercel-use-chat/useVercelUseChatRuntime.tsx
+var getIsRunning = (vercel) => {
+  if ("isLoading" in vercel) return vercel.isLoading;
+  return vercel.status === "in_progress";
 };
-
-// src/adapters/vercel/useVercelAIThreadState.tsx
 var vercelToThreadMessage = (message, status) => {
   const common = {
     id: message.id,
@@ -1296,27 +1426,13 @@ var vercelToThreadMessage = (message, status) => {
       );
   }
 };
-var sliceMessagesUntil = (messages, messageId) => {
-  if (messageId == null) return [];
-  const messageIdx = messages.findIndex((m) => m.id === messageId);
-  if (messageIdx === -1)
-    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 getIsRunning = (vercel) => {
-  if ("isLoading" in vercel) return vercel.isLoading;
-  return vercel.status === "in_progress";
-};
-var useVercelAIThreadState = (vercel) => {
-  const [data] = useState4(() => new MessageRepository());
+var useVercelUseChatRuntime = (vercel) => {
+  const [runtime] = useState4(() => new VercelUseChatRuntime(vercel));
+  useInsertionEffect2(() => {
+    runtime.vercel = vercel;
+  });
   const isRunning = getIsRunning(vercel);
   const converter = useMemo5(() => new ThreadMessageConverter(), []);
-  const assistantOptimisticIdRef = useRef4(null);
   const messages = useMemo5(() => {
     const lastMessageId = vercel.messages.at(-1)?.id;
     const convertCallback = (message, cache) => {
@@ -1325,117 +1441,102 @@ var useVercelAIThreadState = (vercel) => {
         return cache;
       return vercelToThreadMessage(message, status);
     };
-    const vm = converter.convertMessages(convertCallback, 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, null);
-      assistantOptimisticIdRef.current = null;
-    }
-    if (hasUpcomingMessage(isRunning, vm)) {
-      assistantOptimisticIdRef.current = data.appendOptimisticMessage(
-        vm.at(-1)?.id ?? null,
-        {
-          role: "assistant",
-          content: [{ type: "text", text: "" }]
-        }
-      );
-    }
-    data.resetHead(assistantOptimisticIdRef.current ?? vm.at(-1)?.id ?? null);
-    return data.getMessages();
-  }, [converter, data, isRunning, vercel.messages]);
-  const getBranches2 = useCallback2(
-    (messageId) => {
-      return data.getBranches(messageId);
-    },
-    [data]
-  );
-  const switchToBranch2 = useCallbackRef3((messageId) => {
-    data.switchToBranch(messageId);
-    vercel.setMessages(
-      data.getMessages().map(getVercelMessage).filter((m) => m != null)
-    );
-  });
-  const startRun = useCallbackRef3(async (parentId) => {
-    const reloadMaybe = "reload" in vercel ? vercel.reload : void 0;
-    if (!reloadMaybe)
-      throw new Error(
-        "Reload is not supported by Vercel AI SDK's useAssistant."
-      );
-    const newMessages = sliceMessagesUntil(vercel.messages, parentId);
-    vercel.setMessages(newMessages);
-    await reloadMaybe();
-  });
-  const append = useCallbackRef3(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(vercel.messages, message.parentId);
-    vercel.setMessages(newMessages);
-    await vercel.append({
-      role: "user",
-      content: message.content[0].text
-    });
-  });
-  const cancelRun2 = useCallbackRef3(() => {
-    const lastMessage = vercel.messages.at(-1);
-    vercel.stop();
-    if (lastMessage?.role === "user") {
-      vercel.setInput(lastMessage.content);
-    }
-  });
-  return useMemo5(
-    () => ({
-      isRunning,
-      messages,
-      getBranches: getBranches2,
-      switchToBranch: switchToBranch2,
-      append,
-      startRun,
-      cancelRun: cancelRun2
-    }),
-    [
-      isRunning,
-      messages,
-      getBranches2,
-      switchToBranch2,
-      append,
-      startRun,
-      cancelRun2
-    ]
-  );
+    return converter.convertMessages(convertCallback, vercel.messages);
+  }, [isRunning, vercel.messages, converter]);
+  useEffect5(() => {
+    runtime.updateData(isRunning, messages);
+  }, [runtime, isRunning, messages]);
+  return runtime;
 };
 
 // src/adapters/vercel/VercelAIAssistantProvider.tsx
-import { jsx as jsx21 } from "react/jsx-runtime";
+import { jsx as jsx22, jsxs as jsxs4 } from "react/jsx-runtime";
 var VercelAIAssistantProvider = ({
   children,
   ...rest
 }) => {
-  const context = useDummyAIAssistantContext();
   const vercel = "chat" in rest ? rest.chat : rest.assistant;
-  const threadState = useVercelAIThreadState(vercel);
-  useMemo6(() => {
-    context.useThread.setState(threadState, true);
-  }, [context, threadState]);
-  useMemo6(() => {
-    context.useComposer.setState({
+  const runtime = useVercelUseChatRuntime(vercel);
+  return /* @__PURE__ */ jsxs4(AssistantProvider, { runtime, children: [
+    /* @__PURE__ */ jsx22(ComposerSync, { vercel }),
+    children
+  ] });
+};
+var ComposerSync = ({
+  vercel
+}) => {
+  const { useComposer } = useAssistantContext();
+  useEffect6(() => {
+    useComposer.setState({
       value: vercel.input,
       setValue: vercel.setInput
     });
-  }, [context, vercel.input, vercel.setInput]);
-  return /* @__PURE__ */ jsx21(AssistantContext.Provider, { value: context, children });
+  }, [useComposer, vercel.input, vercel.setInput]);
+  return null;
 };
 
-// src/adapters/vercel/VercelRSCAssistantProvider.tsx
-import {
-  useCallback as useCallback3,
-  useMemo as useMemo7,
-  useState as useState5
-} from "react";
-import { jsx as jsx22 } from "react/jsx-runtime";
+// src/adapters/core/vercel-rsc/useVercelRSCRuntime.tsx
+import { useEffect as useEffect7, useInsertionEffect as useInsertionEffect3, useMemo as useMemo6, useState as useState5 } from "react";
+
+// src/adapters/core/vercel-rsc/VercelRSCRuntime.tsx
+var EMPTY_BRANCHES = Object.freeze([]);
+var VercelRSCRuntime = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  _subscriptions = /* @__PURE__ */ new Set();
+  isRunning = false;
+  messages = [];
+  withRunning = (callback) => {
+    this.isRunning = true;
+    return callback.finally(() => {
+      this.isRunning = false;
+    });
+  };
+  getBranches() {
+    return EMPTY_BRANCHES;
+  }
+  switchToBranch() {
+    throw new Error(
+      "Branch switching is not supported by VercelRSCAssistantProvider."
+    );
+  }
+  async append(message) {
+    if (message.parentId !== (this.messages.at(-1)?.id ?? null)) {
+      if (!this.adapter.edit)
+        throw new Error(
+          "Message editing is not enabled, please provide an edit callback to VercelRSCAssistantProvider."
+        );
+      await this.withRunning(this.adapter.edit(message));
+    } else {
+      await this.withRunning(this.adapter.append(message));
+    }
+  }
+  async startRun(parentId) {
+    if (!this.adapter.reload)
+      throw new Error(
+        "Message reloading is not enabled, please provide a reload callback to VercelRSCAssistantProvider."
+      );
+    await this.withRunning(this.adapter.reload(parentId));
+  }
+  cancelRun() {
+    if (process.env["NODE_ENV"] === "development") {
+      console.warn(
+        "Run cancellation is not supported by VercelRSCAssistantProvider."
+      );
+    }
+  }
+  updateData(messages) {
+    this.messages = messages;
+    for (const callback of this._subscriptions) callback();
+  }
+  subscribe(callback) {
+    this._subscriptions.add(callback);
+    return () => this._subscriptions.delete(callback);
+  }
+};
+
+// src/adapters/core/vercel-rsc/useVercelRSCRuntime.tsx
 var vercelToThreadMessage2 = (converter, rawMessage) => {
   const message = converter(rawMessage);
   return {
@@ -1447,220 +1548,61 @@ var vercelToThreadMessage2 = (converter, rawMessage) => {
     [symbolInnerRSCMessage]: rawMessage
   };
 };
-var EMPTY_BRANCHES = [];
-var getBranches = () => {
-  return EMPTY_BRANCHES;
-};
-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] = useState5(false);
-  const withRunning = useCallback3((callback) => {
-    setIsRunning(true);
-    return callback.finally(() => setIsRunning(false));
-  }, []);
-  const [converter, convertCallback] = useMemo7(() => {
-    const rscConverter = convertMessage ?? ((m) => m);
+var useVercelRSCRuntime = (adapter) => {
+  const [runtime] = useState5(() => new VercelRSCRuntime(adapter));
+  useInsertionEffect3(() => {
+    runtime.adapter = adapter;
+  });
+  const [converter, convertCallback] = useMemo6(() => {
+    const rscConverter = adapter.convertMessage ?? ((m) => m);
     const convertCallback2 = (m, cache) => {
       if (cache) return cache;
       return vercelToThreadMessage2(rscConverter, m);
     };
     return [new ThreadMessageConverter(), convertCallback2];
-  }, [convertMessage]);
-  const messages = useMemo7(() => {
-    return converter.convertMessages(convertCallback, vercelMessages);
-  }, [converter, convertCallback, vercelMessages]);
-  const append = useCallback3(
-    async (message) => {
-      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));
-      }
-    },
-    [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]
-  );
-  useMemo7(() => {
-    context.useThread.setState(
-      {
-        messages,
-        isRunning,
-        getBranches,
-        switchToBranch,
-        append,
-        startRun,
-        cancelRun
-      },
-      true
+  }, [adapter.convertMessage]);
+  useEffect7(() => {
+    runtime.updateData(
+      converter.convertMessages(convertCallback, adapter.messages)
     );
-  }, [context, messages, isRunning, append, startRun]);
-  return /* @__PURE__ */ jsx22(AssistantContext.Provider, { value: context, children });
-};
-
-// src/adapters/core/utils/useAssistantContext.tsx
-import { useEffect as useEffect4, useRef as useRef5, useState as useState6 } from "react";
-import { create as create6 } from "zustand";
-
-// src/adapters/core/utils/AssistantMessageRepository.tsx
-var AssistantMessageRepository = class {
-  constructor(flushCallback) {
-    this.flushCallback = flushCallback;
-  }
-  repository = new MessageRepository();
-  getBranches(messageId) {
-    return this.repository.getBranches(messageId);
-  }
-  withModifications(callback) {
-    const res = callback(this.repository);
-    this.flushCallback(this.repository.getMessages());
-    return res;
-  }
-};
-
-// src/adapters/core/utils/useAssistantContext.tsx
-var makeThreadStore = (runtimeRef) => {
-  const repository = new AssistantMessageRepository((messages) => {
-    useThread.setState({ messages });
-  });
-  const useThread = create6(() => ({
-    messages: [],
-    isRunning: false,
-    getBranches: (messageId) => repository.getBranches(messageId),
-    switchToBranch: (branchId) => {
-      repository.withModifications((repository2) => {
-        repository2.switchToBranch(branchId);
-      });
-    },
-    startRun: async (parentId) => {
-      const optimisticId = repository.withModifications((repository2) => {
-        const optimisticId2 = repository2.appendOptimisticMessage(parentId, {
-          role: "assistant",
-          content: [{ type: "text", text: "" }]
-        });
-        repository2.resetHead(optimisticId2);
-        return optimisticId2;
-      });
-      const { id } = await runtimeRef.current.startRun(parentId);
-      repository.withModifications((repository2) => {
-        repository2.deleteMessage(optimisticId, id);
-      });
-    },
-    append: async (message) => {
-      const [parentOptimisticId, optimisticId] = repository.withModifications(
-        (repository2) => {
-          const parentOptimisticId2 = repository2.appendOptimisticMessage(
-            message.parentId,
-            {
-              role: "user",
-              content: message.content
-            }
-          );
-          const optimisticId2 = repository2.appendOptimisticMessage(
-            parentOptimisticId2,
-            {
-              role: "assistant",
-              content: [{ type: "text", text: "" }]
-            }
-          );
-          repository2.resetHead(optimisticId2);
-          return [parentOptimisticId2, optimisticId2];
-        }
-      );
-      const { parentId, id } = await runtimeRef.current.append(message);
-      repository.withModifications((repository2) => {
-        repository2.deleteMessage(parentOptimisticId, parentId);
-        repository2.deleteMessage(optimisticId, id);
-      });
-    },
-    cancelRun: () => runtimeRef.current.cancelRun()
-  }));
-  const onNewMessage = (parentId, message) => {
-    repository.withModifications((repository2) => {
-      repository2.addOrUpdateMessage(parentId, message);
-    });
-  };
-  const onRunningChange = (isRunning) => {
-    useThread.setState({ isRunning });
-  };
-  return {
-    useThread,
-    onNewMessage,
-    onRunningChange
-  };
-};
-var useAssistantContext2 = (runtime) => {
-  const runtimeRef = useRef5(runtime);
-  runtimeRef.current = runtime;
-  const [{ context, onNewMessage, onRunningChange }] = useState6(() => {
-    const { useThread, onNewMessage: onNewMessage2, onRunningChange: onRunningChange2 } = makeThreadStore(runtimeRef);
-    const useViewport = makeViewportStore();
-    const useComposer = makeThreadComposerStore(useThread);
-    return {
-      context: { useViewport, useThread, useComposer },
-      onNewMessage: onNewMessage2,
-      onRunningChange: onRunningChange2
-    };
-  });
-  useEffect4(() => {
-    return runtime.subscribeToMessageUpdates(onNewMessage);
-  }, [runtime, onNewMessage]);
-  useEffect4(() => {
-    return runtime.subscribeToStatusUpdates(onRunningChange);
-  }, [runtime, onRunningChange]);
-  return context;
+  }, [runtime, converter, convertCallback, adapter.messages]);
+  return runtime;
 };
 
-// src/adapters/core/AssistantProvider.tsx
+// src/adapters/vercel/VercelRSCAssistantProvider.tsx
 import { jsx as jsx23 } from "react/jsx-runtime";
-var AssistantProvider = ({ children, runtime }) => {
-  const context = useAssistantContext2(runtime);
-  return /* @__PURE__ */ jsx23(AssistantContext.Provider, { value: context, children });
+var VercelRSCAssistantProvider = ({
+  children,
+  ...adapter
+}) => {
+  const runtime = useVercelRSCRuntime(adapter);
+  return /* @__PURE__ */ jsx23(AssistantProvider, { runtime, children });
 };
 
 // src/adapters/core/local/useLocalRuntime.tsx
-import { useState as useState7 } from "react";
+import { useInsertionEffect as useInsertionEffect4, useState as useState6 } from "react";
 
 // src/adapters/core/local/LocalRuntime.tsx
 var LocalRuntime = class {
   constructor(adapter) {
     this.adapter = adapter;
   }
-  _messageUpdateCallbacks = /* @__PURE__ */ new Set();
-  _statusUpdateCallbacks = /* @__PURE__ */ new Set();
+  _subscriptions = /* @__PURE__ */ new Set();
   abortController = null;
   repository = new MessageRepository();
+  get messages() {
+    return this.repository.getMessages();
+  }
+  get isRunning() {
+    return this.abortController != null;
+  }
+  getBranches(messageId) {
+    return this.repository.getBranches(messageId);
+  }
+  switchToBranch(branchId) {
+    this.repository.switchToBranch(branchId);
+    this.notifySubscribers();
+  }
   async append(message) {
     const userMessageId = generateId();
     const userMessage = {
@@ -1669,9 +1611,8 @@ var LocalRuntime = class {
       content: message.content,
       createdAt: /* @__PURE__ */ new Date()
     };
-    this.addOrUpdateMessage(message.parentId, userMessage);
-    const { id } = await this.startRun(userMessageId);
-    return { parentId: userMessageId, id };
+    this.repository.addOrUpdateMessage(message.parentId, userMessage);
+    await this.startRun(userMessageId);
   }
   async startRun(parentId) {
     const id = generateId();
@@ -1684,59 +1625,52 @@ var LocalRuntime = class {
       content: [{ type: "text", text: "" }],
       createdAt: /* @__PURE__ */ new Date()
     };
-    this.addOrUpdateMessage(parentId, message);
-    void this.run(parentId, messages, message);
-    return { id };
-  }
-  addOrUpdateMessage(parentId, message) {
-    const clone = { ...message };
-    this.repository.addOrUpdateMessage(parentId, clone);
-    for (const callback of this._messageUpdateCallbacks)
-      callback(parentId, clone);
-  }
-  async run(parentId, messages, message) {
-    this.cancelRun();
-    for (const callback of this._statusUpdateCallbacks) callback(true);
+    this.repository.addOrUpdateMessage(parentId, { ...message });
+    this.abortController?.abort();
     this.abortController = new AbortController();
+    this.notifySubscribers();
     try {
       await this.adapter.run({
         messages,
         abortSignal: this.abortController.signal,
         onUpdate: ({ content }) => {
           message.content = content;
-          this.addOrUpdateMessage(parentId, message);
+          this.repository.addOrUpdateMessage(parentId, { ...message });
+          this.notifySubscribers();
         }
       });
       message.status = "done";
-      this.addOrUpdateMessage(parentId, message);
+      this.repository.addOrUpdateMessage(parentId, { ...message });
     } catch (e) {
       message.status = "error";
-      this.addOrUpdateMessage(parentId, message);
+      this.repository.addOrUpdateMessage(parentId, { ...message });
       console.error(e);
     } finally {
-      this.cancelRun();
+      this.abortController = null;
+      this.notifySubscribers();
     }
   }
   cancelRun() {
     if (!this.abortController) return;
     this.abortController.abort();
     this.abortController = null;
-    for (const callback of this._statusUpdateCallbacks) callback(false);
+    this.notifySubscribers();
   }
-  subscribeToMessageUpdates(callback) {
-    this._messageUpdateCallbacks.add(callback);
-    return () => this._messageUpdateCallbacks.delete(callback);
+  notifySubscribers() {
+    for (const callback of this._subscriptions) callback();
   }
-  subscribeToStatusUpdates(callback) {
-    this._statusUpdateCallbacks.add(callback);
-    return () => this._statusUpdateCallbacks.delete(callback);
+  subscribe(callback) {
+    this._subscriptions.add(callback);
+    return () => this._subscriptions.delete(callback);
   }
 };
 
 // src/adapters/core/local/useLocalRuntime.tsx
 var useLocalRuntime = (adapter) => {
-  const [runtime] = useState7(() => new LocalRuntime(adapter));
-  runtime.adapter = adapter;
+  const [runtime] = useState6(() => new LocalRuntime(adapter));
+  useInsertionEffect4(() => {
+    runtime.adapter = adapter;
+  });
   return runtime;
 };