@assistant-ui/react 0.0.16 → 0.0.18

package/dist/index.mjs

@@ -68,18 +68,18 @@ import { useComposedRefs } from "@radix-ui/react-compose-refs";
 import {
   Primitive as Primitive2
 } from "@radix-ui/react-primitive";
-import { forwardRef as forwardRef2, useRef as useRef3 } from "react";
+import { forwardRef as forwardRef2, useRef } from "react";
 
 // src/utils/hooks/useOnResizeContent.tsx
-import { useEffect, useRef } from "react";
+import { useCallbackRef } from "@radix-ui/react-use-callback-ref";
+import { useEffect } from "react";
 var useOnResizeContent = (ref, callback) => {
-  const callbackRef = useRef(callback);
-  callbackRef.current = callback;
+  const callbackRef = useCallbackRef(callback);
   useEffect(() => {
     const el = ref.current;
     if (!el) return;
     const resizeObserver = new ResizeObserver(() => {
-      callbackRef.current();
+      callbackRef();
     });
     const mutationObserver = new MutationObserver((mutations) => {
       for (const mutation of mutations) {
@@ -94,7 +94,7 @@ var useOnResizeContent = (ref, callback) => {
           }
         }
       }
-      callbackRef.current();
+      callbackRef();
     });
     resizeObserver.observe(el);
     mutationObserver.observe(el, { childList: true });
@@ -105,31 +105,31 @@ var useOnResizeContent = (ref, callback) => {
       resizeObserver.disconnect();
       mutationObserver.disconnect();
     };
-  }, [ref.current]);
+  }, [ref.current, callbackRef]);
 };
 
 // src/utils/hooks/useOnScrollToBottom.tsx
-import { useEffect as useEffect2, useRef as useRef2 } from "react";
+import { useCallbackRef as useCallbackRef2 } from "@radix-ui/react-use-callback-ref";
+import { useEffect as useEffect2 } from "react";
 var useOnScrollToBottom = (callback) => {
-  const callbackRef = useRef2(callback);
-  callbackRef.current = callback;
+  const callbackRef = useCallbackRef2(callback);
   const { useViewport } = useAssistantContext();
   useEffect2(() => {
     return useViewport.getState().onScrollToBottom(() => {
-      callbackRef.current();
+      callbackRef();
     });
-  }, [useViewport]);
+  }, [useViewport, callbackRef]);
 };
 
 // src/primitives/thread/ThreadViewport.tsx
 import { jsx as jsx3, jsxs } from "react/jsx-runtime";
 var ThreadViewport = forwardRef2(({ autoScroll = true, onScroll, children, ...rest }, forwardedRef) => {
-  const messagesEndRef = useRef3(null);
-  const divRef = useRef3(null);
+  const messagesEndRef = useRef(null);
+  const divRef = useRef(null);
   const ref = useComposedRefs(forwardedRef, divRef);
   const { useViewport } = useAssistantContext();
-  const firstRenderRef = useRef3(true);
-  const lastScrollTop = useRef3(0);
+  const firstRenderRef = useRef(true);
+  const lastScrollTop = useRef(0);
   const scrollToBottom = () => {
     const div = messagesEndRef.current;
     if (!div || !autoScroll) return;
@@ -214,7 +214,7 @@ var message_exports = {};
 __export(message_exports, {
   Content: () => MessageContent,
   If: () => MessageIf,
-  Loading: () => MessageLoading,
+  InProgress: () => MessageInProgress,
   Provider: () => MessageProvider,
   Root: () => MessageRoot
 });
@@ -296,11 +296,11 @@ var useMessageContext2 = () => {
       parentId: null,
       branches: [],
       isLast: false,
-      loadingIndicator: null,
+      inProgressIndicator: null,
       isCopied: false,
       isHovering: false,
-      setLoadingIndicator: (value) => {
-        set({ loadingIndicator: value });
+      setInProgressIndicator: (value) => {
+        set({ inProgressIndicator: value });
       },
       setIsCopied: (value) => {
         set({ isCopied: value });
@@ -443,15 +443,15 @@ var useContentPartContext = () => {
   return context;
 };
 
-// src/primitives/contentPart/ContentPartLoadingIndicator.tsx
-var ContentPartLoadingIndicator = () => {
+// src/primitives/contentPart/ContentPartInProgressIndicator.tsx
+var ContentPartInProgressIndicator = () => {
   const { useMessage } = useMessageContext();
   const { useContentPart } = useContentPartContext();
-  const loadingIndicator = useCombinedStore(
+  const indicator = useCombinedStore(
     [useMessage, useContentPart],
-    (m, c) => c.isLoading ? m.loadingIndicator : null
+    (m, c) => c.status === "in_progress" ? m.inProgressIndicator : null
   );
-  return loadingIndicator;
+  return indicator;
 };
 
 // src/primitives/contentPart/ContentPartProvider.tsx
@@ -462,7 +462,7 @@ var useContentPartContext2 = () => {
   const [context] = useState2(() => {
     const useContentPart = create3(() => ({
       part: null,
-      isLoading: false
+      status: "done"
     }));
     return { useContentPart };
   });
@@ -470,7 +470,7 @@ var useContentPartContext2 = () => {
 };
 var ContentPartProvider = ({
   part,
-  isLoading,
+  status,
   children
 }) => {
   const context = useContentPartContext2();
@@ -478,11 +478,11 @@ var ContentPartProvider = ({
     context.useContentPart.setState(
       {
         part,
-        isLoading
+        status
       },
       true
     );
-  }, [context, part, isLoading]);
+  }, [context, part, status]);
   return /* @__PURE__ */ jsx6(ContentPartContext.Provider, { value: context, children });
 };
 
@@ -491,7 +491,7 @@ import { Fragment, jsx as jsx7, jsxs as jsxs2 } from "react/jsx-runtime";
 var defaultComponents = {
   Text: ({ part }) => /* @__PURE__ */ jsxs2(Fragment, { children: [
     part.text,
-    /* @__PURE__ */ jsx7(ContentPartLoadingIndicator, {})
+    /* @__PURE__ */ jsx7(ContentPartInProgressIndicator, {})
   ] }),
   Image: () => null,
   UI: ({ part }) => part.display,
@@ -507,13 +507,10 @@ var MessageContent = ({
     tools: { by_name = {}, Fallback = defaultComponents.tools.Fallback } = {}
   } = {}
 }) => {
-  const { useThread } = useAssistantContext();
   const { useMessage } = useMessageContext();
-  const content = useMessage((s) => s.message.content);
-  const isLoading = useCombinedStore(
-    [useThread, useMessage],
-    (t, s) => s.isLast && t.isRunning
-  );
+  const message = useMessage((s) => s.message);
+  const content = message.content;
+  const status = message.role === "assistant" ? message.status : "done";
   return /* @__PURE__ */ jsx7(Fragment, { children: content.map((part, i) => {
     const key = i;
     const type = part.type;
@@ -540,7 +537,7 @@ var MessageContent = ({
       ContentPartProvider,
       {
         part,
-        isLoading: i === content.length - 1 && isLoading,
+        status: i === content.length - 1 ? status : "done",
         children: component
       },
       key
@@ -548,16 +545,16 @@ var MessageContent = ({
   }) });
 };
 
-// src/primitives/message/MessageLoading.tsx
+// src/primitives/message/MessageInProgress.tsx
 import {
   Primitive as Primitive4
 } from "@radix-ui/react-primitive";
 import { forwardRef as forwardRef4, useMemo as useMemo4 } from "react";
 import { jsx as jsx8 } from "react/jsx-runtime";
-var MessageLoading = forwardRef4((props, ref) => {
+var MessageInProgress = forwardRef4((props, ref) => {
   const { useMessage } = useMessageContext();
   useMemo4(() => {
-    useMessage.getState().setLoadingIndicator(/* @__PURE__ */ jsx8(Primitive4.div, { ...props, ref }));
+    useMessage.getState().setInProgressIndicator(/* @__PURE__ */ jsx8(Primitive4.div, { ...props, ref }));
   }, [useMessage, props, ref]);
   return null;
 });
@@ -666,13 +663,13 @@ import { useComposedRefs as useComposedRefs2 } from "@radix-ui/react-compose-ref
 import {
   Primitive as Primitive7
 } from "@radix-ui/react-primitive";
-import { forwardRef as forwardRef7, useRef as useRef4 } from "react";
+import { forwardRef as forwardRef7, useRef as useRef2 } from "react";
 import { jsx as jsx12 } from "react/jsx-runtime";
 var ComposerRoot = forwardRef7(
   ({ onSubmit, ...rest }, forwardedRef) => {
     const { useViewport } = useAssistantContext();
     const { useComposer } = useComposerContext();
-    const formRef = useRef4(null);
+    const formRef = useRef2(null);
     const ref = useComposedRefs2(forwardedRef, formRef);
     const handleSubmit = (e) => {
       const composerState = useComposer.getState();
@@ -700,7 +697,7 @@ import {
   forwardRef as forwardRef8,
   useCallback,
   useEffect as useEffect3,
-  useRef as useRef5
+  useRef as useRef3
 } from "react";
 import TextareaAutosize from "react-textarea-autosize";
 import { jsx as jsx13 } from "react/jsx-runtime";
@@ -729,7 +726,7 @@ var ComposerInput = forwardRef8(
         }
       }
     };
-    const textareaRef = useRef5(null);
+    const textareaRef = useRef3(null);
     const ref = useComposedRefs3(forwardedRef, textareaRef);
     const autoFocusEnabled = autoFocus && !disabled;
     const focus = useCallback(() => {
@@ -876,7 +873,6 @@ var useGoToPreviousBranch = () => {
     const { message, branches } = useMessage.getState();
     useThread.getState().switchToBranch(
       branches[branches.indexOf(message.id) - 1]
-      // TODO probably there's a more elegant way to do this
     );
   };
 };
@@ -1013,7 +1009,7 @@ var ActionBarEdit = createActionButton(useBeginMessageEdit);
 // src/primitives/contentPart/index.ts
 var contentPart_exports = {};
 __export(contentPart_exports, {
-  LoadingIndicator: () => ContentPartLoadingIndicator,
+  InProgressIndicator: () => ContentPartInProgressIndicator,
   Provider: () => ContentPartProvider
 });
 
@@ -1077,9 +1073,10 @@ var useDummyAIAssistantContext = () => {
 };
 
 // src/adapters/vercel/useVercelAIThreadState.tsx
-import { useCallback as useCallback2, useMemo as useMemo5, useRef as useRef6, useState as useState4 } from "react";
+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/MessageRepository.tsx
+// src/adapters/idUtils.tsx
 import { customAlphabet } from "nanoid/non-secure";
 var generateId = customAlphabet(
   "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
@@ -1087,7 +1084,8 @@ var generateId = customAlphabet(
 );
 var optimisticPrefix = "__optimistic__";
 var generateOptimisticId = () => `${optimisticPrefix}${generateId()}`;
-var isOptimisticId = (id) => id.startsWith(optimisticPrefix);
+
+// src/adapters/MessageRepository.tsx
 var findHead = (message) => {
   if (message.next) return findHead(message.next);
   return message;
@@ -1099,15 +1097,6 @@ var MessageRepository = class {
   root = {
     children: []
   };
-  getFallbackChild(p) {
-    const childId = p.children.at(-1);
-    const child = childId ? this.messages.get(childId) : null;
-    if (child === void 0)
-      throw new Error(
-        "MessageRepository(getFallbackChild): Child message not found. This is likely an internal bug in assistant-ui."
-      );
-    return child;
-  }
   performOp(newParent, child, operation) {
     const parentOrRoot = child.prev ?? this.root;
     const newParentOrRoot = newParent ?? this.root;
@@ -1117,7 +1106,14 @@ var MessageRepository = class {
         (m) => m !== child.current.id
       );
       if (child.prev?.next === child) {
-        child.prev.next = this.getFallbackChild(child.prev);
+        const fallbackId = child.prev.children.at(-1);
+        const fallback = fallbackId ? this.messages.get(fallbackId) : null;
+        if (fallback === void 0) {
+          throw new Error(
+            "MessageRepository(performOp/cut): Fallback sibling message not found. This is likely an internal bug in assistant-ui."
+          );
+        }
+        child.prev.next = fallback;
       }
     }
     if (operation !== "cut") {
@@ -1171,18 +1167,19 @@ var MessageRepository = class {
     this.addOrUpdateMessage(parentId, {
       ...message,
       id: optimisticId,
-      createdAt: /* @__PURE__ */ new Date()
+      createdAt: /* @__PURE__ */ new Date(),
+      ...message.role === "assistant" ? { status: "in_progress" } : void 0
     });
     return optimisticId;
   }
-  deleteMessage(messageId, newParentId) {
+  deleteMessage(messageId, replacementId) {
     const message = this.messages.get(messageId);
-    const newParent = newParentId ? this.messages.get(newParentId) : null;
+    const replacement = replacementId ? this.messages.get(replacementId) : null;
     if (!message)
       throw new Error(
         "MessageRepository(deleteMessage): Optimistic message not found. This is likely an internal bug in assistant-ui."
       );
-    if (newParent === void 0)
+    if (replacement === void 0)
       throw new Error(
         "MessageRepository(deleteMessage): New message not found. This is likely an internal bug in assistant-ui."
       );
@@ -1192,11 +1189,11 @@ var MessageRepository = class {
         throw new Error(
           "MessageRepository(deleteMessage): Child message not found. This is likely an internal bug in assistant-ui."
         );
-      this.performOp(newParent, childMessage, "relink");
+      this.performOp(replacement, childMessage, "relink");
     }
     this.messages.delete(messageId);
     if (this.head === message) {
-      this.head = this.getFallbackChild(message.prev ?? this.root);
+      this.head = replacement;
     }
     this.performOp(null, message, "cut");
   }
@@ -1239,50 +1236,68 @@ var MessageRepository = class {
   }
 };
 
-// src/adapters/ThreadMessageConverter.tsx
+// src/adapters/ThreadMessageConverter.ts
 var ThreadMessageConverter = class {
-  constructor(converter2) {
-    this.converter = converter2;
-  }
   cache = /* @__PURE__ */ new WeakMap();
-  convertMessages(messages) {
+  convertMessages(converter, messages) {
     return messages.map((m) => {
       const cached = this.cache.get(m);
-      if (cached) return cached;
-      const newMessage = this.converter(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/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 {
+var vercelToThreadMessage = (message, status) => {
+  const common = {
     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
+    [symbolInnerMessage]: message
   };
+  switch (message.role) {
+    case "user":
+      return {
+        ...common,
+        role: "user",
+        content: [{ type: "text", text: message.content }]
+      };
+    case "assistant":
+      return {
+        ...common,
+        role: "assistant",
+        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
+            })
+          ) ?? []
+        ],
+        status
+      };
+    default:
+      throw new Error(
+        `You have a message with an unsupported role. The role ${message.role} is not supported.`
+      );
+  }
 };
-var converter = new ThreadMessageConverter(vercelToThreadMessage);
 var sliceMessagesUntil = (messages, messageId) => {
   if (messageId == null) return [];
-  if (isOptimisticId(messageId)) return messages;
   const messageIdx = messages.findIndex((m) => m.id === messageId);
   if (messageIdx === -1)
     throw new Error(
@@ -1299,12 +1314,18 @@ var getIsRunning = (vercel) => {
 };
 var useVercelAIThreadState = (vercel) => {
   const [data] = useState4(() => new MessageRepository());
-  const vercelRef = useRef6(vercel);
-  vercelRef.current = vercel;
-  const isRunning = getIsRunning(vercelRef.current);
-  const assistantOptimisticIdRef = useRef6(null);
+  const isRunning = getIsRunning(vercel);
+  const converter = useMemo5(() => new ThreadMessageConverter(), []);
+  const assistantOptimisticIdRef = useRef4(null);
   const messages = useMemo5(() => {
-    const vm = converter.convertMessages(vercel.messages);
+    const lastMessageId = vercel.messages.at(-1)?.id;
+    const convertCallback = (message, cache) => {
+      const status = lastMessageId === message.id && isRunning ? "in_progress" : "done";
+      if (cache && (cache.role === "user" || cache.status === status))
+        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];
@@ -1325,55 +1346,46 @@ var useVercelAIThreadState = (vercel) => {
     }
     data.resetHead(assistantOptimisticIdRef.current ?? vm.at(-1)?.id ?? null);
     return data.getMessages();
-  }, [data, isRunning, vercel.messages]);
+  }, [converter, data, isRunning, vercel.messages]);
   const getBranches2 = useCallback2(
     (messageId) => {
       return data.getBranches(messageId);
     },
     [data]
   );
-  const switchToBranch2 = useCallback2(
-    (messageId) => {
-      data.switchToBranch(messageId);
-      vercelRef.current.setMessages(
-        data.getMessages().filter((m) => !isOptimisticId(m.id)).map((m) => m.innerMessage)
-      );
-    },
-    [data]
-  );
-  const startRun = useCallback2(async (parentId) => {
-    const reloadMaybe = "reload" in vercelRef.current ? vercelRef.current.reload : void 0;
+  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(
-      vercelRef.current.messages,
-      parentId
-    );
-    vercelRef.current.setMessages(newMessages);
+    const newMessages = sliceMessagesUntil(vercel.messages, parentId);
+    vercel.setMessages(newMessages);
     await reloadMaybe();
-  }, []);
-  const append = useCallback2(async (message) => {
+  });
+  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(
-      vercelRef.current.messages,
-      message.parentId
-    );
-    vercelRef.current.setMessages(newMessages);
-    await vercelRef.current.append({
+    const newMessages = sliceMessagesUntil(vercel.messages, message.parentId);
+    vercel.setMessages(newMessages);
+    await vercel.append({
       role: "user",
       content: message.content[0].text
     });
-  }, []);
-  const cancelRun2 = useCallback2(() => {
-    const lastMessage = vercelRef.current.messages.at(-1);
-    vercelRef.current.stop();
+  });
+  const cancelRun2 = useCallbackRef3(() => {
+    const lastMessage = vercel.messages.at(-1);
+    vercel.stop();
     if (lastMessage?.role === "user") {
-      vercelRef.current.setInput(lastMessage.content);
+      vercel.setInput(lastMessage.content);
     }
-  }, []);
+  });
   return useMemo5(
     () => ({
       isRunning,
@@ -1424,12 +1436,15 @@ import {
   useState as useState5
 } from "react";
 import { jsx as jsx22 } from "react/jsx-runtime";
-var vercelToThreadMessage2 = (message) => {
+var vercelToThreadMessage2 = (converter, rawMessage) => {
+  const message = converter(rawMessage);
   return {
     id: message.id,
     role: message.role,
     content: [{ type: "ui", display: message.display }],
-    createdAt: message.createdAt ?? /* @__PURE__ */ new Date()
+    createdAt: message.createdAt ?? /* @__PURE__ */ new Date(),
+    ...{ status: "done" },
+    [symbolInnerRSCMessage]: rawMessage
   };
 };
 var EMPTY_BRANCHES = [];
@@ -1462,15 +1477,17 @@ var VercelRSCAssistantProvider = ({
     setIsRunning(true);
     return callback.finally(() => setIsRunning(false));
   }, []);
-  const converter2 = useMemo7(() => {
+  const [converter, convertCallback] = useMemo7(() => {
     const rscConverter = convertMessage ?? ((m) => m);
-    return new ThreadMessageConverter((m) => {
-      return vercelToThreadMessage2(rscConverter(m));
-    });
+    const convertCallback2 = (m, cache) => {
+      if (cache) return cache;
+      return vercelToThreadMessage2(rscConverter, m);
+    };
+    return [new ThreadMessageConverter(), convertCallback2];
   }, [convertMessage]);
   const messages = useMemo7(() => {
-    return converter2.convertMessages(vercelMessages);
-  }, [converter2, vercelMessages]);
+    return converter.convertMessages(convertCallback, vercelMessages);
+  }, [converter, convertCallback, vercelMessages]);
   const append = useCallback3(
     async (message) => {
       if (message.parentId !== (context.useThread.getState().messages.at(-1)?.id ?? null)) {
@@ -1511,6 +1528,259 @@ var VercelRSCAssistantProvider = ({
   }, [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;
+};
+
+// src/adapters/core/AssistantProvider.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 });
+};
+
+// src/adapters/core/local/useLocalRuntime.tsx
+import { useState as useState7 } from "react";
+
+// src/adapters/core/local/LocalRuntime.tsx
+var LocalRuntime = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  _messageUpdateCallbacks = /* @__PURE__ */ new Set();
+  _statusUpdateCallbacks = /* @__PURE__ */ new Set();
+  abortController = null;
+  repository = new MessageRepository();
+  async append(message) {
+    const userMessageId = generateId();
+    const userMessage = {
+      id: userMessageId,
+      role: "user",
+      content: message.content,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    this.addOrUpdateMessage(message.parentId, userMessage);
+    const { id } = await this.startRun(userMessageId);
+    return { parentId: userMessageId, id };
+  }
+  async startRun(parentId) {
+    const id = generateId();
+    this.repository.resetHead(parentId);
+    const messages = this.repository.getMessages();
+    const message = {
+      id,
+      role: "assistant",
+      status: "in_progress",
+      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.abortController = new AbortController();
+    try {
+      await this.adapter.run({
+        messages,
+        abortSignal: this.abortController.signal,
+        onUpdate: ({ content }) => {
+          message.content = content;
+          this.addOrUpdateMessage(parentId, message);
+        }
+      });
+      message.status = "done";
+      this.addOrUpdateMessage(parentId, message);
+    } catch (e) {
+      message.status = "error";
+      this.addOrUpdateMessage(parentId, message);
+      console.error(e);
+    } finally {
+      this.cancelRun();
+    }
+  }
+  cancelRun() {
+    if (!this.abortController) return;
+    this.abortController.abort();
+    this.abortController = null;
+    for (const callback of this._statusUpdateCallbacks) callback(false);
+  }
+  subscribeToMessageUpdates(callback) {
+    this._messageUpdateCallbacks.add(callback);
+    return () => this._messageUpdateCallbacks.delete(callback);
+  }
+  subscribeToStatusUpdates(callback) {
+    this._statusUpdateCallbacks.add(callback);
+    return () => this._statusUpdateCallbacks.delete(callback);
+  }
+};
+
+// src/adapters/core/local/useLocalRuntime.tsx
+var useLocalRuntime = (adapter) => {
+  const [runtime] = useState7(() => new LocalRuntime(adapter));
+  runtime.adapter = adapter;
+  return runtime;
+};
+
+// src/adapters/core/local/vercel/VercelModelAdapter.tsx
+import { streamText } from "ai";
+var VercelModelAdapter = class {
+  constructor(model) {
+    this.model = model;
+  }
+  async run({ messages, abortSignal, onUpdate }) {
+    const { fullStream } = await streamText({
+      model: this.model,
+      abortSignal,
+      messages: messages.map((m) => ({
+        role: m.role,
+        content: m.content.filter((c) => c.type !== "ui")
+      }))
+    });
+    const content = [];
+    for await (const aiPart of fullStream) {
+      switch (aiPart.type) {
+        case "text-delta": {
+          let part = content.at(-1);
+          if (!part || part.type !== "text") {
+            part = { type: "text", text: "" };
+            content.push(part);
+          }
+          part.text += aiPart.textDelta;
+          break;
+        }
+        case "tool-call": {
+          content.push({
+            type: "tool-call",
+            name: aiPart.toolName,
+            args: aiPart.args
+          });
+          break;
+        }
+      }
+      onUpdate({ content });
+    }
+    return { content };
+  }
+};
 export {
   actionBar_exports as ActionBarPrimitive,
   branchPicker_exports as BranchPickerPrimitive,
@@ -1520,6 +1790,11 @@ export {
   thread_exports as ThreadPrimitive,
   VercelAIAssistantProvider,
   VercelRSCAssistantProvider,
+  AssistantProvider as unstable_AssistantProvider,
+  VercelModelAdapter as unstable_VercelModelAdapter,
+  getVercelMessage as unstable_getVercelMessage,
+  getVercelRSCMessage as unstable_getVercelRSCMessage,
+  useLocalRuntime as unstable_useLocalRuntime,
   useMessageContext as unstable_useMessageContext,
   useBeginMessageEdit,
   useCopyMessage,