@assistant-ui/react 0.5.23 → 0.5.25

package/dist/index.js

@@ -159,11 +159,23 @@ var makeComposerStore = (useThreadMessages, useThreadActions) => {
 
 // src/context/stores/Thread.ts
 
+var getThreadStateFromRuntime = (runtime) => {
+  const lastMessage = runtime.messages.at(-1);
+  if (_optionalChain([lastMessage, 'optionalAccess', _11 => _11.role]) !== "assistant")
+    return Object.freeze({
+      isDisabled: runtime.isDisabled,
+      isRunning: false,
+      unstable_canAppendNew: runtime.isDisabled
+    });
+  return Object.freeze({
+    isDisabled: runtime.isDisabled,
+    isRunning: lastMessage.status.type === "running",
+    unstable_canAppendNew: !runtime.isDisabled && lastMessage.status.type !== "running" && lastMessage.status.type !== "requires-action"
+  });
+};
 var makeThreadStore = (runtimeRef) => {
-  return _zustand.create.call(void 0, () => ({
-    isDisabled: runtimeRef.getState().isDisabled,
-    isRunning: runtimeRef.getState().isRunning
-  }));
+  const runtime = runtimeRef.getState();
+  return _zustand.create.call(void 0, () => getThreadStateFromRuntime(runtime));
 };
 
 // src/context/stores/ThreadViewport.tsx
@@ -260,13 +272,11 @@ var ThreadProvider = ({
     _react.useCallback.call(void 0, 
       (thread) => {
         const onThreadUpdate = () => {
-          const threadState = context.useThread.getState();
-          if (thread.isRunning !== threadState.isRunning || thread.isDisabled !== threadState.isDisabled) {
+          const oldState = context.useThread.getState();
+          const state = getThreadStateFromRuntime(thread);
+          if (oldState.isDisabled !== state.isDisabled || oldState.isRunning !== state.isRunning || oldState.unstable_canAppendNew !== state.unstable_canAppendNew) {
             context.useThread.setState(
-              Object.freeze({
-                isRunning: thread.isRunning,
-                isDisabled: thread.isDisabled
-              }),
+              getThreadStateFromRuntime(thread),
               true
             );
           }
@@ -344,7 +354,7 @@ var AssistantRuntimeProvider = _react.memo.call(void 0, AssistantRuntimeProvider
 var MessageContext = _react.createContext.call(void 0, null);
 function useMessageContext(options) {
   const context = _react.useContext.call(void 0, MessageContext);
-  if (!_optionalChain([options, 'optionalAccess', _11 => _11.optional]) && !context)
+  if (!_optionalChain([options, 'optionalAccess', _12 => _12.optional]) && !context)
     throw new Error(
       "This component can only be used inside a component passed to <ThreadPrimitive.Messages components={...} />."
     );
@@ -371,7 +381,7 @@ var ContentPartContext = _react.createContext.call(void 0,
 );
 function useContentPartContext(options) {
   const context = _react.useContext.call(void 0, ContentPartContext);
-  if (!_optionalChain([options, 'optionalAccess', _12 => _12.optional]) && !context)
+  if (!_optionalChain([options, 'optionalAccess', _13 => _13.optional]) && !context)
     throw new Error(
       "This component can only be used inside a component passed to <MessagePrimitive.Content components={...} >."
     );
@@ -383,13 +393,13 @@ function useContentPartContext(options) {
 var toAppendMessage = (useThreadMessages, message) => {
   if (typeof message === "string") {
     return {
-      parentId: _nullishCoalesce(_optionalChain([useThreadMessages, 'access', _13 => _13.getState, 'call', _14 => _14(), 'access', _15 => _15.at, 'call', _16 => _16(-1), 'optionalAccess', _17 => _17.id]), () => ( null)),
+      parentId: _nullishCoalesce(_optionalChain([useThreadMessages, 'access', _14 => _14.getState, 'call', _15 => _15(), 'access', _16 => _16.at, 'call', _17 => _17(-1), 'optionalAccess', _18 => _18.id]), () => ( null)),
       role: "user",
       content: [{ type: "text", text: message }]
     };
   }
   return {
-    parentId: _nullishCoalesce(_nullishCoalesce(message.parentId, () => ( _optionalChain([useThreadMessages, 'access', _18 => _18.getState, 'call', _19 => _19(), 'access', _20 => _20.at, 'call', _21 => _21(-1), 'optionalAccess', _22 => _22.id]))), () => ( null)),
+    parentId: _nullishCoalesce(_nullishCoalesce(message.parentId, () => ( _optionalChain([useThreadMessages, 'access', _19 => _19.getState, 'call', _20 => _20(), 'access', _21 => _21.at, 'call', _22 => _22(-1), 'optionalAccess', _23 => _23.id]))), () => ( null)),
     role: _nullishCoalesce(message.role, () => ( "user")),
     content: message.content
   };
@@ -441,7 +451,7 @@ var useAssistantTool = (tool) => {
     const unsub2 = render ? setToolUI(toolName, render) : void 0;
     return () => {
       unsub1();
-      _optionalChain([unsub2, 'optionalCall', _23 => _23()]);
+      _optionalChain([unsub2, 'optionalCall', _24 => _24()]);
     };
   }, [registerModelConfigProvider, setToolUI, tool]);
 };
@@ -520,8 +530,8 @@ var useCombinedStore = (stores, selector) => {
   return useCombined(selector);
 };
 
-// src/utils/getMessageText.tsx
-var getMessageText = (message) => {
+// src/utils/getThreadMessageText.tsx
+var getThreadMessageText = (message) => {
   const textParts = message.content.filter(
     (part) => part.type === "text"
   );
@@ -543,7 +553,7 @@ var useActionBarCopy = ({
     const { message } = useMessage.getState();
     const { setIsCopied } = useMessageUtils.getState();
     const { isEditing, value: composerValue } = useEditComposer.getState();
-    const valueToCopy = isEditing ? composerValue : getMessageText(message);
+    const valueToCopy = isEditing ? composerValue : getThreadMessageText(message);
     navigator.clipboard.writeText(valueToCopy).then(() => {
       setIsCopied(true);
       setTimeout(() => setIsCopied(false), copiedDuration);
@@ -670,7 +680,7 @@ var useComposerSend = () => {
   const { useComposer } = useComposerContext();
   const disabled = useCombinedStore(
     [useThread, useComposer],
-    (t, c) => t.isDisabled || t.isRunning || !c.isEditing || c.value.length === 0
+    (t, c) => !t.unstable_canAppendNew || !c.isEditing || c.value.length === 0
   );
   const callback = _react.useCallback.call(void 0, () => {
     const composerState = useComposer.getState();
@@ -878,7 +888,7 @@ var createActionButton = (displayName, useActionButton, forwardProps = []) => {
         ...primitiveProps,
         ref: forwardedRef,
         onClick: _primitive.composeEventHandlers.call(void 0, primitiveProps.onClick, () => {
-          _optionalChain([callback, 'optionalCall', _24 => _24()]);
+          _optionalChain([callback, 'optionalCall', _25 => _25()]);
         })
       }
     );
@@ -1166,7 +1176,7 @@ var getContentPartState = ({ message }, useContentPart, partIndex) => {
     }
   }
   const status = toContentPartStatus(message, partIndex, part);
-  const currentState = _optionalChain([useContentPart, 'optionalAccess', _25 => _25.getState, 'call', _26 => _26()]);
+  const currentState = _optionalChain([useContentPart, 'optionalAccess', _26 => _26.getState, 'call', _27 => _27()]);
   if (currentState && currentState.part === part && currentState.status === status)
     return null;
   return Object.freeze({ part, status });
@@ -1242,7 +1252,7 @@ var withSmoothContextProvider = (Component) => {
 };
 function useSmoothContext(options) {
   const context = _react.useContext.call(void 0, SmoothContext);
-  if (!_optionalChain([options, 'optionalAccess', _27 => _27.optional]) && !context)
+  if (!_optionalChain([options, 'optionalAccess', _28 => _28.optional]) && !context)
     throw new Error(
       "This component must be used within a SmoothContextProvider."
     );
@@ -1313,7 +1323,7 @@ var useSmooth = (state, smooth = false) => {
   const [displayedText, setDisplayedText] = _react.useState.call(void 0, text);
   const setText = _reactusecallbackref.useCallbackRef.call(void 0, (text2) => {
     setDisplayedText(text2);
-    _optionalChain([useSmoothStatus2, 'optionalAccess', _28 => _28.setState, 'call', _29 => _29(text2 !== state.part.text ? SMOOTH_STATUS : state.status)]);
+    _optionalChain([useSmoothStatus2, 'optionalAccess', _29 => _29.setState, 'call', _30 => _30(text2 !== state.part.text ? SMOOTH_STATUS : state.status)]);
   });
   const [animatorRef] = _react.useState.call(void 0, 
     new TextStreamAnimator(text, setText)
@@ -1457,7 +1467,7 @@ var MessageContentPartImpl = ({
 };
 var MessageContentPart = _react.memo.call(void 0, 
   MessageContentPartImpl,
-  (prev, next) => prev.partIndex === next.partIndex && _optionalChain([prev, 'access', _30 => _30.components, 'optionalAccess', _31 => _31.Text]) === _optionalChain([next, 'access', _32 => _32.components, 'optionalAccess', _33 => _33.Text]) && _optionalChain([prev, 'access', _34 => _34.components, 'optionalAccess', _35 => _35.Image]) === _optionalChain([next, 'access', _36 => _36.components, 'optionalAccess', _37 => _37.Image]) && _optionalChain([prev, 'access', _38 => _38.components, 'optionalAccess', _39 => _39.UI]) === _optionalChain([next, 'access', _40 => _40.components, 'optionalAccess', _41 => _41.UI]) && _optionalChain([prev, 'access', _42 => _42.components, 'optionalAccess', _43 => _43.tools]) === _optionalChain([next, 'access', _44 => _44.components, 'optionalAccess', _45 => _45.tools])
+  (prev, next) => prev.partIndex === next.partIndex && _optionalChain([prev, 'access', _31 => _31.components, 'optionalAccess', _32 => _32.Text]) === _optionalChain([next, 'access', _33 => _33.components, 'optionalAccess', _34 => _34.Text]) && _optionalChain([prev, 'access', _35 => _35.components, 'optionalAccess', _36 => _36.Image]) === _optionalChain([next, 'access', _37 => _37.components, 'optionalAccess', _38 => _38.Image]) && _optionalChain([prev, 'access', _39 => _39.components, 'optionalAccess', _40 => _40.UI]) === _optionalChain([next, 'access', _41 => _41.components, 'optionalAccess', _42 => _42.UI]) && _optionalChain([prev, 'access', _43 => _43.components, 'optionalAccess', _44 => _44.tools]) === _optionalChain([next, 'access', _45 => _45.components, 'optionalAccess', _46 => _46.tools])
 );
 var MessagePrimitiveContent = ({
   components
@@ -1568,10 +1578,10 @@ var ComposerPrimitiveInput = _react.forwardRef.call(void 0,
     const handleKeyPress = (e) => {
       if (isDisabled) return;
       if (e.key === "Enter" && e.shiftKey === false) {
-        const isRunning = useThread.getState().isRunning;
-        if (!isRunning) {
+        const { unstable_canAppendNew } = useThread.getState();
+        if (unstable_canAppendNew) {
           e.preventDefault();
-          _optionalChain([textareaRef, 'access', _46 => _46.current, 'optionalAccess', _47 => _47.closest, 'call', _48 => _48("form"), 'optionalAccess', _49 => _49.requestSubmit, 'call', _50 => _50()]);
+          _optionalChain([textareaRef, 'access', _47 => _47.current, 'optionalAccess', _48 => _48.closest, 'call', _49 => _49("form"), 'optionalAccess', _50 => _50.requestSubmit, 'call', _51 => _51()]);
         }
       }
     };
@@ -1865,15 +1875,15 @@ var makeMessageUtilsStore = () => _zustand.create.call(void 0, (set) => ({
 // src/context/providers/MessageProvider.tsx
 
 var getIsLast = (messages, message) => {
-  return _optionalChain([messages, 'access', _51 => _51[messages.length - 1], 'optionalAccess', _52 => _52.id]) === message.id;
+  return _optionalChain([messages, 'access', _52 => _52[messages.length - 1], 'optionalAccess', _53 => _53.id]) === message.id;
 };
 var getMessageState = (messages, getBranches, useMessage, messageIndex) => {
-  const parentId = _nullishCoalesce(_optionalChain([messages, 'access', _53 => _53[messageIndex - 1], 'optionalAccess', _54 => _54.id]), () => ( null));
+  const parentId = _nullishCoalesce(_optionalChain([messages, 'access', _54 => _54[messageIndex - 1], 'optionalAccess', _55 => _55.id]), () => ( null));
   const message = messages[messageIndex];
   if (!message) return null;
   const isLast = getIsLast(messages, message);
   const branches = getBranches(message.id);
-  const currentState = _optionalChain([useMessage, 'optionalAccess', _55 => _55.getState, 'call', _56 => _56()]);
+  const currentState = _optionalChain([useMessage, 'optionalAccess', _56 => _56.getState, 'call', _57 => _57()]);
   if (currentState && currentState.message === message && currentState.parentId === parentId && currentState.branches === branches && currentState.isLast === isLast)
     return null;
   return Object.freeze({
@@ -1902,7 +1912,7 @@ var useMessageContext2 = (messageIndex) => {
           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);
+        const text = getThreadMessageText(message);
         return text;
       },
       onSend: (text) => {
@@ -2000,7 +2010,7 @@ var ThreadPrimitiveMessagesImpl = ({
 ThreadPrimitiveMessagesImpl.displayName = "ThreadPrimitive.Messages";
 var ThreadPrimitiveMessages = _react.memo.call(void 0, 
   ThreadPrimitiveMessagesImpl,
-  (prev, next) => _optionalChain([prev, 'access', _57 => _57.components, 'optionalAccess', _58 => _58.Message]) === _optionalChain([next, 'access', _59 => _59.components, 'optionalAccess', _60 => _60.Message]) && _optionalChain([prev, 'access', _61 => _61.components, 'optionalAccess', _62 => _62.UserMessage]) === _optionalChain([next, 'access', _63 => _63.components, 'optionalAccess', _64 => _64.UserMessage]) && _optionalChain([prev, 'access', _65 => _65.components, 'optionalAccess', _66 => _66.EditComposer]) === _optionalChain([next, 'access', _67 => _67.components, 'optionalAccess', _68 => _68.EditComposer]) && _optionalChain([prev, 'access', _69 => _69.components, 'optionalAccess', _70 => _70.AssistantMessage]) === _optionalChain([next, 'access', _71 => _71.components, 'optionalAccess', _72 => _72.AssistantMessage]) && _optionalChain([prev, 'access', _73 => _73.components, 'optionalAccess', _74 => _74.SystemMessage]) === _optionalChain([next, 'access', _75 => _75.components, 'optionalAccess', _76 => _76.SystemMessage])
+  (prev, next) => _optionalChain([prev, 'access', _58 => _58.components, 'optionalAccess', _59 => _59.Message]) === _optionalChain([next, 'access', _60 => _60.components, 'optionalAccess', _61 => _61.Message]) && _optionalChain([prev, 'access', _62 => _62.components, 'optionalAccess', _63 => _63.UserMessage]) === _optionalChain([next, 'access', _64 => _64.components, 'optionalAccess', _65 => _65.UserMessage]) && _optionalChain([prev, 'access', _66 => _66.components, 'optionalAccess', _67 => _67.EditComposer]) === _optionalChain([next, 'access', _68 => _68.components, 'optionalAccess', _69 => _69.EditComposer]) && _optionalChain([prev, 'access', _70 => _70.components, 'optionalAccess', _71 => _71.AssistantMessage]) === _optionalChain([next, 'access', _72 => _72.components, 'optionalAccess', _73 => _73.AssistantMessage]) && _optionalChain([prev, 'access', _74 => _74.components, 'optionalAccess', _75 => _75.SystemMessage]) === _optionalChain([next, 'access', _76 => _76.components, 'optionalAccess', _77 => _77.SystemMessage])
 );
 
 // src/primitives/thread/ThreadScrollToBottom.tsx
@@ -2132,7 +2142,7 @@ var MessageRepository = (_class4 = class {constructor() { _class4.prototype.__in
       parentOrRoot.children = parentOrRoot.children.filter(
         (m) => m !== child.current.id
       );
-      if (_optionalChain([child, 'access', _77 => _77.prev, 'optionalAccess', _78 => _78.next]) === child) {
+      if (_optionalChain([child, 'access', _78 => _78.prev, 'optionalAccess', _79 => _79.next]) === child) {
         const fallbackId = child.prev.children.at(-1);
         const fallback = fallbackId ? this.messages.get(fallbackId) : null;
         if (fallback === void 0) {
@@ -2144,6 +2154,13 @@ var MessageRepository = (_class4 = class {constructor() { _class4.prototype.__in
       }
     }
     if (operation !== "cut") {
+      for (let current = newParent; current; current = current.prev) {
+        if (current.current.id === child.current.id) {
+          throw new Error(
+            "MessageRepository(performOp/link): A message with the same id already exists in the parent tree. This error occurs if the same message id is found multiple times. This is likely an internal bug in assistant-ui."
+          );
+        }
+      }
       newParentOrRoot.children = [
         ...newParentOrRoot.children,
         child.current.id
@@ -2155,7 +2172,7 @@ var MessageRepository = (_class4 = class {constructor() { _class4.prototype.__in
     }
   }
   getMessages() {
-    const messages = new Array(_nullishCoalesce(_optionalChain([this, 'access', _79 => _79.head, 'optionalAccess', _80 => _80.level]), () => ( 0)));
+    const messages = new Array(_nullishCoalesce(_optionalChain([this, 'access', _80 => _80.head, 'optionalAccess', _81 => _81.level]), () => ( 0)));
     for (let current = this.head; current; current = current.prev) {
       messages[current.level] = current.current;
     }
@@ -2193,7 +2210,7 @@ var MessageRepository = (_class4 = class {constructor() { _class4.prototype.__in
         "MessageRepository(updateMessage): Message not found. This is likely an internal bug in assistant-ui."
       );
     return {
-      parentId: _nullishCoalesce(_optionalChain([message, 'access', _81 => _81.prev, 'optionalAccess', _82 => _82.current, 'access', _83 => _83.id]), () => ( null)),
+      parentId: _nullishCoalesce(_optionalChain([message, 'access', _82 => _82.prev, 'optionalAccess', _83 => _83.current, 'access', _84 => _84.id]), () => ( null)),
       message: message.current
     };
   }
@@ -2278,11 +2295,11 @@ var MessageRepository = (_class4 = class {constructor() { _class4.prototype.__in
     for (const [, message] of this.messages) {
       exportItems.push({
         message: message.current,
-        parentId: _nullishCoalesce(_optionalChain([message, 'access', _84 => _84.prev, 'optionalAccess', _85 => _85.current, 'access', _86 => _86.id]), () => ( null))
+        parentId: _nullishCoalesce(_optionalChain([message, 'access', _85 => _85.prev, 'optionalAccess', _86 => _86.current, 'access', _87 => _87.id]), () => ( null))
       });
     }
     return {
-      headId: _nullishCoalesce(_optionalChain([this, 'access', _87 => _87.head, 'optionalAccess', _88 => _88.current, 'access', _89 => _89.id]), () => ( null)),
+      headId: _nullishCoalesce(_optionalChain([this, 'access', _88 => _88.head, 'optionalAccess', _89 => _89.current, 'access', _90 => _90.id]), () => ( null)),
       messages: exportItems
     };
   }
@@ -2290,7 +2307,7 @@ var MessageRepository = (_class4 = class {constructor() { _class4.prototype.__in
     for (const { message, parentId } of messages) {
       this.addOrUpdateMessage(parentId, message);
     }
-    this.resetHead(_nullishCoalesce(_nullishCoalesce(headId, () => ( _optionalChain([messages, 'access', _90 => _90.at, 'call', _91 => _91(-1), 'optionalAccess', _92 => _92.message, 'access', _93 => _93.id]))), () => ( null)));
+    this.resetHead(_nullishCoalesce(_nullishCoalesce(headId, () => ( _optionalChain([messages, 'access', _91 => _91.at, 'call', _92 => _92(-1), 'optionalAccess', _93 => _93.message, 'access', _94 => _94.id]))), () => ( null)));
   }
 }, _class4);
 
@@ -2453,7 +2470,7 @@ var fromLanguageModelMessages = (lm, { mergeRoundtrips }) => {
         });
         if (mergeRoundtrips) {
           const previousMessage = messages[messages.length - 1];
-          if (_optionalChain([previousMessage, 'optionalAccess', _94 => _94.role]) === "assistant") {
+          if (_optionalChain([previousMessage, 'optionalAccess', _95 => _95.role]) === "assistant") {
             previousMessage.content.push(...newContent);
             break;
           }
@@ -2466,7 +2483,7 @@ var fromLanguageModelMessages = (lm, { mergeRoundtrips }) => {
       }
       case "tool": {
         const previousMessage = messages[messages.length - 1];
-        if (_optionalChain([previousMessage, 'optionalAccess', _95 => _95.role]) !== "assistant")
+        if (_optionalChain([previousMessage, 'optionalAccess', _96 => _96.role]) !== "assistant")
           throw new Error(
             "A tool message must be preceded by an assistant message."
           );
@@ -2670,7 +2687,7 @@ var useEdgeRuntime = ({
 };
 
 // src/runtimes/local/shouldContinue.tsx
-var shouldContinue = (result) => _optionalChain([result, 'access', _96 => _96.status, 'optionalAccess', _97 => _97.type]) === "requires-action" && result.status.reason === "tool-calls" && result.content.every((c) => c.type !== "tool-call" || !!c.result);
+var shouldContinue = (result) => _optionalChain([result, 'access', _97 => _97.status, 'optionalAccess', _98 => _98.type]) === "requires-action" && result.status.reason === "tool-calls" && result.content.every((c) => c.type !== "tool-call" || !!c.result);
 
 // src/runtimes/local/LocalThreadRuntime.tsx
 var CAPABILITIES = Object.freeze({
@@ -2685,7 +2702,7 @@ var LocalThreadRuntime = (_class5 = class {
     this.configProvider = configProvider;
     this.adapter = adapter;
     this.options = options;
-    if (_optionalChain([options, 'optionalAccess', _98 => _98.initialMessages])) {
+    if (_optionalChain([options, 'optionalAccess', _99 => _99.initialMessages])) {
       let parentId = null;
       const messages = fromCoreMessages(options.initialMessages);
       for (const message of messages) {
@@ -2702,9 +2719,6 @@ var LocalThreadRuntime = (_class5 = class {
   get messages() {
     return this.repository.getMessages();
   }
-  get isRunning() {
-    return this.abortController != null;
-  }
   getBranches(messageId) {
     return this.repository.getBranches(messageId);
   }
@@ -2743,7 +2757,7 @@ var LocalThreadRuntime = (_class5 = class {
   }
   async performRoundtrip(parentId, message) {
     const messages = this.repository.getMessages();
-    _optionalChain([this, 'access', _99 => _99.abortController, 'optionalAccess', _100 => _100.abort, 'call', _101 => _101()]);
+    _optionalChain([this, 'access', _100 => _100.abortController, 'optionalAccess', _101 => _101.abort, 'call', _102 => _102()]);
     this.abortController = new AbortController();
     const initialContent = message.content;
     const initialRoundtrips = message.roundtrips;
@@ -2752,13 +2766,13 @@ var LocalThreadRuntime = (_class5 = class {
         ...message,
         ...m.content ? { content: [...initialContent, ..._nullishCoalesce(m.content, () => ( []))] } : void 0,
         status: _nullishCoalesce(m.status, () => ( message.status)),
-        ..._optionalChain([m, 'access', _102 => _102.roundtrips, 'optionalAccess', _103 => _103.length]) ? { roundtrips: [..._nullishCoalesce(initialRoundtrips, () => ( [])), ...m.roundtrips] } : void 0
+        ..._optionalChain([m, 'access', _103 => _103.roundtrips, 'optionalAccess', _104 => _104.length]) ? { roundtrips: [..._nullishCoalesce(initialRoundtrips, () => ( [])), ...m.roundtrips] } : void 0
       };
       this.repository.addOrUpdateMessage(parentId, message);
       this.notifySubscribers();
     };
-    const maxToolRoundtrips = _nullishCoalesce(_optionalChain([this, 'access', _104 => _104.options, 'optionalAccess', _105 => _105.maxToolRoundtrips]), () => ( 1));
-    const toolRoundtrips = _nullishCoalesce(_optionalChain([message, 'access', _106 => _106.roundtrips, 'optionalAccess', _107 => _107.length]), () => ( 0));
+    const maxToolRoundtrips = _nullishCoalesce(_optionalChain([this, 'access', _105 => _105.options, 'optionalAccess', _106 => _106.maxToolRoundtrips]), () => ( 1));
+    const toolRoundtrips = _nullishCoalesce(_optionalChain([message, 'access', _107 => _107.roundtrips, 'optionalAccess', _108 => _108.length]), () => ( 0));
     if (toolRoundtrips > maxToolRoundtrips) {
       updateMessage({
         status: {
@@ -2793,8 +2807,6 @@ var LocalThreadRuntime = (_class5 = class {
         updateMessage({
           status: { type: "complete", reason: "unknown" }
         });
-      } else {
-        this.notifySubscribers();
       }
     } catch (e) {
       this.abortController = null;
@@ -2893,18 +2905,12 @@ var useLocalRuntime = (adapter, options) => {
   return runtime;
 };
 
-// src/runtimes/external-store/ExternalStoreThreadRuntime.tsx
-
-
 // src/runtimes/external-store/getExternalStoreMessage.tsx
 var symbolInnerMessage = Symbol("innerMessage");
 var getExternalStoreMessage = (message) => {
   return message[symbolInnerMessage];
 };
 
-// src/runtimes/external-store/useExternalStoreSync.tsx
-
-
 // src/runtimes/external-store/ThreadMessageConverter.ts
 var ThreadMessageConverter = (_class6 = class {constructor() { _class6.prototype.__init16.call(this); }
   __init16() {this.cache = /* @__PURE__ */ new WeakMap()}
@@ -2925,6 +2931,7 @@ var AUTO_STATUS_COMPLETE = Object.freeze({
   type: "complete",
   reason: "unknown"
 });
+var isAutoStatus = (status) => status === AUTO_STATUS_RUNNING || status === AUTO_STATUS_COMPLETE;
 var getAutoStatus = (isLast, isRunning) => isLast && isRunning ? AUTO_STATUS_RUNNING : AUTO_STATUS_COMPLETE;
 
 // src/runtimes/external-store/ThreadMessageLike.tsx
@@ -2995,106 +3002,112 @@ var fromThreadMessageLike = (like, fallbackId, fallbackStatus) => {
   }
 };
 
-// src/runtimes/external-store/useExternalStoreSync.tsx
-var useExternalStoreSync = (adapter, updateData) => {
-  const adapterRef = _react.useRef.call(void 0, adapter);
-  _react.useInsertionEffect.call(void 0, () => {
-    adapterRef.current = adapter;
-  });
-  const [converter, convertCallback] = _react.useMemo.call(void 0, () => {
-    const converter2 = _nullishCoalesce(adapter.convertMessage, () => ( ((m) => m)));
-    const convertCallback2 = (cache, m, idx) => {
-      const autoStatus = getAutoStatus(
-        adapterRef.current.messages.at(-1) === m,
-        _nullishCoalesce(adapterRef.current.isRunning, () => ( false))
-      );
-      if (cache && (cache.role !== "assistant" || cache.status === autoStatus))
-        return cache;
-      const newMessage = fromThreadMessageLike(
-        converter2(m, idx),
-        idx.toString(),
-        autoStatus
-      );
-      newMessage[symbolInnerMessage] = m;
-      return newMessage;
-    };
-    return [new ThreadMessageConverter(), convertCallback2];
-  }, [adapter.convertMessage]);
-  _react.useEffect.call(void 0, () => {
-    updateData(
-      _nullishCoalesce(adapter.isDisabled, () => ( false)),
-      _nullishCoalesce(adapter.isRunning, () => ( false)),
-      converter.convertMessages(adapter.messages, convertCallback)
-    );
-  }, [
-    updateData,
-    converter,
-    convertCallback,
-    adapter.isDisabled,
-    adapter.isRunning,
-    adapter.messages
-  ]);
-};
-
 // src/runtimes/external-store/ExternalStoreThreadRuntime.tsx
 var hasUpcomingMessage = (isRunning, messages) => {
-  return isRunning && _optionalChain([messages, 'access', _108 => _108[messages.length - 1], 'optionalAccess', _109 => _109.role]) !== "assistant";
+  return isRunning && _optionalChain([messages, 'access', _109 => _109[messages.length - 1], 'optionalAccess', _110 => _110.role]) !== "assistant";
 };
 var ExternalStoreThreadRuntime = (_class7 = class {
-  constructor(store) {;_class7.prototype.__init17.call(this);_class7.prototype.__init18.call(this);_class7.prototype.__init19.call(this);_class7.prototype.__init20.call(this);_class7.prototype.__init21.call(this);_class7.prototype.__init22.call(this);_class7.prototype.__init23.call(this);_class7.prototype.__init24.call(this);_class7.prototype.__init25.call(this);
-    this.store = store;
-    this.updateData(
-      _nullishCoalesce(store.isDisabled, () => ( false)),
-      _nullishCoalesce(store.isRunning, () => ( false)),
-      store.messages
-    );
-    this.useStore = _zustand.create.call(void 0, () => ({
-      store
-    }));
-  }
   __init17() {this._subscriptions = /* @__PURE__ */ new Set()}
   __init18() {this.repository = new MessageRepository()}
   __init19() {this.assistantOptimisticId = null}
-  
   get capabilities() {
     return {
-      switchToBranch: this.store.setMessages !== void 0,
-      edit: this.store.onEdit !== void 0,
-      reload: this.store.onReload !== void 0,
-      cancel: this.store.onCancel !== void 0,
-      copy: this.store.onCopy !== null
+      switchToBranch: this._store.setMessages !== void 0,
+      edit: this._store.onEdit !== void 0,
+      reload: this._store.onReload !== void 0,
+      cancel: this._store.onCancel !== void 0,
+      copy: this._store.onCopy !== null
     };
   }
   __init20() {this.messages = []}
   __init21() {this.isDisabled = false}
-  __init22() {this.isRunning = false}
+  __init22() {this.converter = new ThreadMessageConverter()}
+  
+  constructor(store) {;_class7.prototype.__init17.call(this);_class7.prototype.__init18.call(this);_class7.prototype.__init19.call(this);_class7.prototype.__init20.call(this);_class7.prototype.__init21.call(this);_class7.prototype.__init22.call(this);_class7.prototype.__init23.call(this);
+    this.store = store;
+  }
+  set store(store) {
+    const oldStore = this._store;
+    if (oldStore) {
+      if (oldStore.convertMessage !== store.convertMessage) {
+        this.converter = new ThreadMessageConverter();
+      } else if (oldStore.isDisabled === store.isDisabled && oldStore.isRunning === store.isRunning && oldStore.messages === store.messages) {
+        return;
+      }
+    }
+    this._store = store;
+    const isRunning = _nullishCoalesce(store.isRunning, () => ( false));
+    const isDisabled = _nullishCoalesce(store.isDisabled, () => ( false));
+    const convertCallback = (cache, m, idx) => {
+      if (!store.convertMessage) return m;
+      const isLast = idx === store.messages.length - 1;
+      const autoStatus = getAutoStatus(isLast, isRunning);
+      if (cache && (cache.role !== "assistant" || !isAutoStatus(cache.status) || cache.status === autoStatus))
+        return cache;
+      const newMessage = fromThreadMessageLike(
+        store.convertMessage(m, idx),
+        idx.toString(),
+        autoStatus
+      );
+      newMessage[symbolInnerMessage] = m;
+      return newMessage;
+    };
+    const messages = this.converter.convertMessages(
+      store.messages,
+      convertCallback
+    );
+    for (let i = 0; i < messages.length; i++) {
+      const message = messages[i];
+      const parent = messages[i - 1];
+      this.repository.addOrUpdateMessage(_nullishCoalesce(_optionalChain([parent, 'optionalAccess', _114 => _114.id]), () => ( null)), message);
+    }
+    if (this.assistantOptimisticId) {
+      this.repository.deleteMessage(this.assistantOptimisticId);
+      this.assistantOptimisticId = null;
+    }
+    if (hasUpcomingMessage(isRunning, messages)) {
+      this.assistantOptimisticId = this.repository.appendOptimisticMessage(
+        _nullishCoalesce(_optionalChain([messages, 'access', _115 => _115.at, 'call', _116 => _116(-1), 'optionalAccess', _117 => _117.id]), () => ( null)),
+        {
+          role: "assistant",
+          content: []
+        }
+      );
+    }
+    this.repository.resetHead(
+      _nullishCoalesce(_nullishCoalesce(this.assistantOptimisticId, () => ( _optionalChain([messages, 'access', _118 => _118.at, 'call', _119 => _119(-1), 'optionalAccess', _120 => _120.id]))), () => ( null))
+    );
+    this.messages = this.repository.getMessages();
+    this.isDisabled = isDisabled;
+    for (const callback of this._subscriptions) callback();
+  }
   getBranches(messageId) {
     return this.repository.getBranches(messageId);
   }
   switchToBranch(branchId) {
-    if (!this.store.setMessages)
+    if (!this._store.setMessages)
       throw new Error("Runtime does not support switching branches.");
     this.repository.switchToBranch(branchId);
     this.updateMessages(this.repository.getMessages());
   }
   async append(message) {
-    if (message.parentId !== (_nullishCoalesce(_optionalChain([this, 'access', _120 => _120.messages, 'access', _121 => _121.at, 'call', _122 => _122(-1), 'optionalAccess', _123 => _123.id]), () => ( null)))) {
-      if (!this.store.onEdit)
+    if (message.parentId !== (_nullishCoalesce(_optionalChain([this, 'access', _121 => _121.messages, 'access', _122 => _122.at, 'call', _123 => _123(-1), 'optionalAccess', _124 => _124.id]), () => ( null)))) {
+      if (!this._store.onEdit)
         throw new Error("Runtime does not support editing messages.");
-      await this.store.onEdit(message);
+      await this._store.onEdit(message);
     } else {
-      await this.store.onNew(message);
+      await this._store.onNew(message);
     }
   }
   async startRun(parentId) {
-    if (!this.store.onReload)
+    if (!this._store.onReload)
       throw new Error("Runtime does not support reloading messages.");
-    await this.store.onReload(parentId);
+    await this._store.onReload(parentId);
   }
   cancelRun() {
-    if (!this.store.onCancel)
+    if (!this._store.onCancel)
       throw new Error("Runtime does not support cancelling runs.");
-    this.store.onCancel();
+    this._store.onCancel();
     if (this.assistantOptimisticId) {
       this.repository.deleteMessage(this.assistantOptimisticId);
       this.assistantOptimisticId = null;
@@ -3109,66 +3122,26 @@ var ExternalStoreThreadRuntime = (_class7 = class {
     return () => this._subscriptions.delete(callback);
   }
   __init23() {this.updateMessages = (messages) => {
-    _optionalChain([this, 'access', _124 => _124.store, 'access', _125 => _125.setMessages, 'optionalCall', _126 => _126(
+    _optionalChain([this, 'access', _125 => _125._store, 'access', _126 => _126.setMessages, 'optionalCall', _127 => _127(
       messages.flatMap(getExternalStoreMessage).filter((m) => m != null)
     )]);
   }}
-  onStoreUpdated() {
-    if (this.useStore.getState().store !== this.store) {
-      this.useStore.setState({ store: this.store });
-    }
-  }
-  __init24() {this.updateData = (isDisabled, isRunning, vm) => {
-    for (let i = 0; i < vm.length; i++) {
-      const message = vm[i];
-      const parent = vm[i - 1];
-      this.repository.addOrUpdateMessage(_nullishCoalesce(_optionalChain([parent, 'optionalAccess', _127 => _127.id]), () => ( null)), message);
-    }
-    if (this.assistantOptimisticId) {
-      this.repository.deleteMessage(this.assistantOptimisticId);
-      this.assistantOptimisticId = null;
-    }
-    if (hasUpcomingMessage(isRunning, vm)) {
-      this.assistantOptimisticId = this.repository.appendOptimisticMessage(
-        _nullishCoalesce(_optionalChain([vm, 'access', _128 => _128.at, 'call', _129 => _129(-1), 'optionalAccess', _130 => _130.id]), () => ( null)),
-        {
-          role: "assistant",
-          content: []
-        }
-      );
-    }
-    this.repository.resetHead(
-      _nullishCoalesce(_nullishCoalesce(this.assistantOptimisticId, () => ( _optionalChain([vm, 'access', _131 => _131.at, 'call', _132 => _132(-1), 'optionalAccess', _133 => _133.id]))), () => ( null))
-    );
-    this.messages = this.repository.getMessages();
-    this.isDisabled = isDisabled;
-    this.isRunning = isRunning;
-    for (const callback of this._subscriptions) callback();
-  }}
-  __init25() {this.unstable_synchronizer = () => {
-    const { store } = this.useStore();
-    useExternalStoreSync(store, this.updateData);
-    return null;
-  }}
   addToolResult(options) {
-    if (!this.store.onAddToolResult)
+    if (!this._store.onAddToolResult)
       throw new Error("Runtime does not support tool results.");
-    this.store.onAddToolResult(options);
+    this._store.onAddToolResult(options);
   }
 }, _class7);
 
 // src/runtimes/external-store/ExternalStoreRuntime.tsx
 var ExternalStoreRuntime = (_class8 = class extends BaseAssistantRuntime {
-  __init26() {this._proxyConfigProvider = new ProxyConfigProvider()}
+  __init24() {this._proxyConfigProvider = new ProxyConfigProvider()}
   constructor(store) {
-    super(new ExternalStoreThreadRuntime(store));_class8.prototype.__init26.call(this);;
+    super(new ExternalStoreThreadRuntime(store));_class8.prototype.__init24.call(this);;
   }
   set store(store) {
     this.thread.store = store;
   }
-  onStoreUpdated() {
-    return this.thread.onStoreUpdated();
-  }
   getModelConfig() {
     return this._proxyConfigProvider.getModelConfig();
   }
@@ -3195,9 +3168,6 @@ var useExternalStoreRuntime = (store) => {
   _react.useInsertionEffect.call(void 0, () => {
     runtime.store = store;
   });
-  _react.useEffect.call(void 0, () => {
-    runtime.onStoreUpdated();
-  });
   return runtime;
 };
 
@@ -3217,7 +3187,7 @@ var ThreadConfigProvider = ({
 }) => {
   const assistant = useAssistantContext({ optional: true });
   const configProvider = config && Object.keys(_nullishCoalesce(config, () => ( {}))).length > 0 ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ThreadConfigContext.Provider, { value: config, children }) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, { children });
-  if (!_optionalChain([config, 'optionalAccess', _134 => _134.runtime])) return configProvider;
+  if (!_optionalChain([config, 'optionalAccess', _128 => _128.runtime])) return configProvider;
   if (assistant) {
     throw new Error(
       "You provided a runtime to <Thread> while simulataneously using <AssistantRuntimeProvider>. This is not allowed."
@@ -3433,7 +3403,7 @@ var AssistantMessageContent = _react.forwardRef.call(void 0, ({ components: comp
     {
       components: {
         ...componentsProp,
-        Text: _nullishCoalesce(_nullishCoalesce(_optionalChain([componentsProp, 'optionalAccess', _135 => _135.Text]), () => ( components.Text)), () => ( content_part_default.Text))
+        Text: _nullishCoalesce(_nullishCoalesce(_optionalChain([componentsProp, 'optionalAccess', _129 => _129.Text]), () => ( components.Text)), () => ( content_part_default.Text))
       }
     }
   ) });
@@ -3608,7 +3578,7 @@ var ThreadWelcomeSuggestion = ({
 };
 var ThreadWelcomeSuggestions = () => {
   const { welcome: { suggestions } = {} } = useThreadConfig();
-  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ThreadWelcomeSuggestionContainer, { children: _optionalChain([suggestions, 'optionalAccess', _136 => _136.map, 'call', _137 => _137((suggestion, idx) => {
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ThreadWelcomeSuggestionContainer, { children: _optionalChain([suggestions, 'optionalAccess', _130 => _130.map, 'call', _131 => _131((suggestion, idx) => {
     const key = `${suggestion.prompt}-${idx}`;
     return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ThreadWelcomeSuggestion, { suggestion }, key);
   })]) });
@@ -3686,7 +3656,7 @@ var UserMessageContent = _react.forwardRef.call(void 0,
       {
         components: {
           ...components,
-          Text: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _138 => _138.Text]), () => ( content_part_default.Text))
+          Text: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _132 => _132.Text]), () => ( content_part_default.Text))
         }
       }
     ) });
@@ -3788,10 +3758,10 @@ var ThreadMessages = ({ components, ...rest }) => {
     thread_exports.Messages,
     {
       components: {
-        UserMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _139 => _139.UserMessage]), () => ( user_message_default)),
-        EditComposer: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _140 => _140.EditComposer]), () => ( edit_composer_default)),
-        AssistantMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _141 => _141.AssistantMessage]), () => ( assistant_message_default)),
-        SystemMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _142 => _142.SystemMessage]), () => ( SystemMessage))
+        UserMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _133 => _133.UserMessage]), () => ( user_message_default)),
+        EditComposer: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _134 => _134.EditComposer]), () => ( edit_composer_default)),
+        AssistantMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _135 => _135.AssistantMessage]), () => ( assistant_message_default)),
+        SystemMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _136 => _136.SystemMessage]), () => ( SystemMessage))
       },
       ...rest
     }