@assistant-ui/react 0.5.22 → 0.5.24

package/dist/index.js

@@ -2144,6 +2144,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
@@ -2273,6 +2280,25 @@ var MessageRepository = (_class4 = class {constructor() { _class4.prototype.__in
       }
     }
   }
+  export() {
+    const exportItems = [];
+    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))
+      });
+    }
+    return {
+      headId: _nullishCoalesce(_optionalChain([this, 'access', _87 => _87.head, 'optionalAccess', _88 => _88.current, 'access', _89 => _89.id]), () => ( null)),
+      messages: exportItems
+    };
+  }
+  import({ headId, messages }) {
+    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)));
+  }
 }, _class4);
 
 // src/ui/base/tooltip-icon-button.tsx
@@ -2434,7 +2460,7 @@ var fromLanguageModelMessages = (lm, { mergeRoundtrips }) => {
         });
         if (mergeRoundtrips) {
           const previousMessage = messages[messages.length - 1];
-          if (_optionalChain([previousMessage, 'optionalAccess', _84 => _84.role]) === "assistant") {
+          if (_optionalChain([previousMessage, 'optionalAccess', _94 => _94.role]) === "assistant") {
             previousMessage.content.push(...newContent);
             break;
           }
@@ -2447,7 +2473,7 @@ var fromLanguageModelMessages = (lm, { mergeRoundtrips }) => {
       }
       case "tool": {
         const previousMessage = messages[messages.length - 1];
-        if (_optionalChain([previousMessage, 'optionalAccess', _85 => _85.role]) !== "assistant")
+        if (_optionalChain([previousMessage, 'optionalAccess', _95 => _95.role]) !== "assistant")
           throw new Error(
             "A tool message must be preceded by an assistant message."
           );
@@ -2651,7 +2677,7 @@ var useEdgeRuntime = ({
 };
 
 // src/runtimes/local/shouldContinue.tsx
-var shouldContinue = (result) => _optionalChain([result, 'access', _86 => _86.status, 'optionalAccess', _87 => _87.type]) === "requires-action" && result.status.reason === "tool-calls" && result.content.every((c) => c.type !== "tool-call" || !!c.result);
+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);
 
 // src/runtimes/local/LocalThreadRuntime.tsx
 var CAPABILITIES = Object.freeze({
@@ -2666,7 +2692,7 @@ var LocalThreadRuntime = (_class5 = class {
     this.configProvider = configProvider;
     this.adapter = adapter;
     this.options = options;
-    if (_optionalChain([options, 'optionalAccess', _88 => _88.initialMessages])) {
+    if (_optionalChain([options, 'optionalAccess', _98 => _98.initialMessages])) {
       let parentId = null;
       const messages = fromCoreMessages(options.initialMessages);
       for (const message of messages) {
@@ -2724,7 +2750,7 @@ var LocalThreadRuntime = (_class5 = class {
   }
   async performRoundtrip(parentId, message) {
     const messages = this.repository.getMessages();
-    _optionalChain([this, 'access', _89 => _89.abortController, 'optionalAccess', _90 => _90.abort, 'call', _91 => _91()]);
+    _optionalChain([this, 'access', _99 => _99.abortController, 'optionalAccess', _100 => _100.abort, 'call', _101 => _101()]);
     this.abortController = new AbortController();
     const initialContent = message.content;
     const initialRoundtrips = message.roundtrips;
@@ -2733,13 +2759,13 @@ var LocalThreadRuntime = (_class5 = class {
         ...message,
         ...m.content ? { content: [...initialContent, ..._nullishCoalesce(m.content, () => ( []))] } : void 0,
         status: _nullishCoalesce(m.status, () => ( message.status)),
-        ..._optionalChain([m, 'access', _92 => _92.roundtrips, 'optionalAccess', _93 => _93.length]) ? { roundtrips: [..._nullishCoalesce(initialRoundtrips, () => ( [])), ...m.roundtrips] } : void 0
+        ..._optionalChain([m, 'access', _102 => _102.roundtrips, 'optionalAccess', _103 => _103.length]) ? { roundtrips: [..._nullishCoalesce(initialRoundtrips, () => ( [])), ...m.roundtrips] } : void 0
       };
       this.repository.addOrUpdateMessage(parentId, message);
       this.notifySubscribers();
     };
-    const maxToolRoundtrips = _nullishCoalesce(_optionalChain([this, 'access', _94 => _94.options, 'optionalAccess', _95 => _95.maxToolRoundtrips]), () => ( 1));
-    const toolRoundtrips = _nullishCoalesce(_optionalChain([message, 'access', _96 => _96.roundtrips, 'optionalAccess', _97 => _97.length]), () => ( 0));
+    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));
     if (toolRoundtrips > maxToolRoundtrips) {
       updateMessage({
         status: {
@@ -2831,6 +2857,13 @@ var LocalThreadRuntime = (_class5 = class {
       this.performRoundtrip(parentId, message);
     }
   }
+  export() {
+    return this.repository.export();
+  }
+  import(data) {
+    this.repository.import(data);
+    this.notifySubscribers();
+  }
 }, _class5);
 
 // src/runtimes/local/LocalRuntime.tsx
@@ -2867,18 +2900,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()}
@@ -2899,6 +2926,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
@@ -2969,106 +2997,114 @@ 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', _98 => _98[messages.length - 1], 'optionalAccess', _99 => _99.role]) !== "assistant";
+  return isRunning && _optionalChain([messages, 'access', _108 => _108[messages.length - 1], 'optionalAccess', _109 => _109.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}
+  __init23() {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);_class7.prototype.__init24.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', _113 => _113.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', _114 => _114.at, 'call', _115 => _115(-1), 'optionalAccess', _116 => _116.id]), () => ( null)),
+        {
+          role: "assistant",
+          content: []
+        }
+      );
+    }
+    this.repository.resetHead(
+      _nullishCoalesce(_nullishCoalesce(this.assistantOptimisticId, () => ( _optionalChain([messages, 'access', _117 => _117.at, 'call', _118 => _118(-1), 'optionalAccess', _119 => _119.id]))), () => ( null))
+    );
+    this.messages = this.repository.getMessages();
+    this.isDisabled = isDisabled;
+    this.isRunning = isRunning;
+    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', _110 => _110.messages, 'access', _111 => _111.at, 'call', _112 => _112(-1), 'optionalAccess', _113 => _113.id]), () => ( null)))) {
-      if (!this.store.onEdit)
+    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)
         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;
@@ -3082,67 +3118,27 @@ var ExternalStoreThreadRuntime = (_class7 = class {
     this._subscriptions.add(callback);
     return () => this._subscriptions.delete(callback);
   }
-  __init23() {this.updateMessages = (messages) => {
-    _optionalChain([this, 'access', _114 => _114.store, 'access', _115 => _115.setMessages, 'optionalCall', _116 => _116(
+  __init24() {this.updateMessages = (messages) => {
+    _optionalChain([this, 'access', _124 => _124._store, 'access', _125 => _125.setMessages, 'optionalCall', _126 => _126(
       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', _117 => _117.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', _118 => _118.at, 'call', _119 => _119(-1), 'optionalAccess', _120 => _120.id]), () => ( null)),
-        {
-          role: "assistant",
-          content: []
-        }
-      );
-    }
-    this.repository.resetHead(
-      _nullishCoalesce(_nullishCoalesce(this.assistantOptimisticId, () => ( _optionalChain([vm, 'access', _121 => _121.at, 'call', _122 => _122(-1), 'optionalAccess', _123 => _123.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()}
+  __init25() {this._proxyConfigProvider = new ProxyConfigProvider()}
   constructor(store) {
-    super(new ExternalStoreThreadRuntime(store));_class8.prototype.__init26.call(this);;
+    super(new ExternalStoreThreadRuntime(store));_class8.prototype.__init25.call(this);;
   }
   set store(store) {
     this.thread.store = store;
   }
-  onStoreUpdated() {
-    return this.thread.onStoreUpdated();
-  }
   getModelConfig() {
     return this._proxyConfigProvider.getModelConfig();
   }
@@ -3169,9 +3165,6 @@ var useExternalStoreRuntime = (store) => {
   _react.useInsertionEffect.call(void 0, () => {
     runtime.store = store;
   });
-  _react.useEffect.call(void 0, () => {
-    runtime.onStoreUpdated();
-  });
   return runtime;
 };
 
@@ -3191,7 +3184,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', _124 => _124.runtime])) return configProvider;
+  if (!_optionalChain([config, 'optionalAccess', _127 => _127.runtime])) return configProvider;
   if (assistant) {
     throw new Error(
       "You provided a runtime to <Thread> while simulataneously using <AssistantRuntimeProvider>. This is not allowed."
@@ -3407,7 +3400,7 @@ var AssistantMessageContent = _react.forwardRef.call(void 0, ({ components: comp
     {
       components: {
         ...componentsProp,
-        Text: _nullishCoalesce(_nullishCoalesce(_optionalChain([componentsProp, 'optionalAccess', _125 => _125.Text]), () => ( components.Text)), () => ( content_part_default.Text))
+        Text: _nullishCoalesce(_nullishCoalesce(_optionalChain([componentsProp, 'optionalAccess', _128 => _128.Text]), () => ( components.Text)), () => ( content_part_default.Text))
       }
     }
   ) });
@@ -3582,7 +3575,7 @@ var ThreadWelcomeSuggestion = ({
 };
 var ThreadWelcomeSuggestions = () => {
   const { welcome: { suggestions } = {} } = useThreadConfig();
-  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ThreadWelcomeSuggestionContainer, { children: _optionalChain([suggestions, 'optionalAccess', _126 => _126.map, 'call', _127 => _127((suggestion, idx) => {
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ThreadWelcomeSuggestionContainer, { children: _optionalChain([suggestions, 'optionalAccess', _129 => _129.map, 'call', _130 => _130((suggestion, idx) => {
     const key = `${suggestion.prompt}-${idx}`;
     return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ThreadWelcomeSuggestion, { suggestion }, key);
   })]) });
@@ -3660,7 +3653,7 @@ var UserMessageContent = _react.forwardRef.call(void 0,
       {
         components: {
           ...components,
-          Text: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _128 => _128.Text]), () => ( content_part_default.Text))
+          Text: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _131 => _131.Text]), () => ( content_part_default.Text))
         }
       }
     ) });
@@ -3762,10 +3755,10 @@ var ThreadMessages = ({ components, ...rest }) => {
     thread_exports.Messages,
     {
       components: {
-        UserMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _129 => _129.UserMessage]), () => ( user_message_default)),
-        EditComposer: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _130 => _130.EditComposer]), () => ( edit_composer_default)),
-        AssistantMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _131 => _131.AssistantMessage]), () => ( assistant_message_default)),
-        SystemMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _132 => _132.SystemMessage]), () => ( SystemMessage))
+        UserMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _132 => _132.UserMessage]), () => ( user_message_default)),
+        EditComposer: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _133 => _133.EditComposer]), () => ( edit_composer_default)),
+        AssistantMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _134 => _134.AssistantMessage]), () => ( assistant_message_default)),
+        SystemMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _135 => _135.SystemMessage]), () => ( SystemMessage))
       },
       ...rest
     }