@assistant-ui/react 0.5.2 → 0.5.4

package/dist/index.mjs

@@ -3330,9 +3330,7 @@ var EdgeChatAdapter = class {
       signal: abortSignal
     });
     if (result.status !== 200) {
-      throw new Error(
-        `Edge runtime returned status ${result.status}: ${await result.text()}`
-      );
+      throw new Error(`Status ${result.status}: ${await result.text()}`);
     }
     const stream = result.body.pipeThrough(new TextDecoderStream()).pipeThrough(chunkByLineStream()).pipeThrough(assistantDecoderStream()).pipeThrough(toolResultStream(config.tools)).pipeThrough(runResultStream());
     let update;
@@ -3563,6 +3561,213 @@ var useLocalRuntime = (adapter, options) => {
   return runtime;
 };
 
+// src/runtimes/external-store/ExternalStoreThreadRuntime.tsx
+import { create as create14 } from "zustand";
+
+// src/runtimes/external-store/getExternalStoreMessage.tsx
+var symbolInnerMessage = Symbol("innerMessage");
+var getExternalStoreMessage = (message) => {
+  return message[symbolInnerMessage];
+};
+
+// src/runtimes/external-store/useExternalStoreSync.tsx
+import { useEffect as useEffect11, useMemo as useMemo3 } from "react";
+
+// src/runtimes/external-store/ThreadMessageConverter.ts
+var ThreadMessageConverter = class {
+  cache = /* @__PURE__ */ new WeakMap();
+  convertMessages(messages, converter, keyMapper = (key) => key) {
+    return messages.map((m, idx) => {
+      const key = keyMapper(m);
+      const cached = this.cache.get(key);
+      const newMessage = converter(cached, m, idx);
+      this.cache.set(key, newMessage);
+      return newMessage;
+    });
+  }
+};
+
+// src/runtimes/external-store/useExternalStoreSync.tsx
+var useExternalStoreSync = (adapter, updateData) => {
+  const [converter, convertCallback] = useMemo3(() => {
+    const converter2 = adapter.convertMessage ?? ((m) => m);
+    const convertCallback2 = (cache, m, idx) => {
+      if (cache) return cache;
+      const newMessage = converter2(m, idx);
+      newMessage[symbolInnerMessage] = m;
+      return newMessage;
+    };
+    return [new ThreadMessageConverter(), convertCallback2];
+  }, [adapter.convertMessage]);
+  useEffect11(() => {
+    updateData(
+      adapter.isRunning ?? false,
+      converter.convertMessages(adapter.messages, convertCallback)
+    );
+  }, [
+    updateData,
+    converter,
+    convertCallback,
+    adapter.messages,
+    adapter.isRunning
+  ]);
+};
+
+// src/runtimes/external-store/ExternalStoreThreadRuntime.tsx
+var hasUpcomingMessage = (isRunning, messages) => {
+  return isRunning && messages[messages.length - 1]?.role !== "assistant";
+};
+var ExternalStoreThreadRuntime = class {
+  constructor(store) {
+    this.store = store;
+    this.useStore = create14(() => ({
+      store
+    }));
+  }
+  _subscriptions = /* @__PURE__ */ new Set();
+  repository = new MessageRepository();
+  assistantOptimisticId = null;
+  useStore;
+  get capabilities() {
+    return {
+      edit: this.store.onEdit !== void 0,
+      reload: this.store.onReload !== void 0,
+      cancel: this.store.onCancel !== void 0,
+      copy: this.store.onCopy !== null
+    };
+  }
+  messages = [];
+  isRunning = false;
+  getBranches(messageId) {
+    return this.repository.getBranches(messageId);
+  }
+  switchToBranch(branchId) {
+    this.repository.switchToBranch(branchId);
+    this.updateMessages(this.repository.getMessages());
+  }
+  async append(message) {
+    if (message.parentId !== (this.messages.at(-1)?.id ?? null)) {
+      if (!this.store.onEdit)
+        throw new Error("Runtime does not support editing messages.");
+      await this.store.onEdit(message);
+    } else {
+      await this.store.onNew(message);
+    }
+  }
+  async startRun(parentId) {
+    if (!this.store.onReload)
+      throw new Error("Runtime does not support reloading messages.");
+    await this.store.onReload(parentId);
+  }
+  cancelRun() {
+    if (!this.store.onCancel)
+      throw new Error("Runtime does not support cancelling runs.");
+    this.store.onCancel();
+    if (this.assistantOptimisticId) {
+      this.repository.deleteMessage(this.assistantOptimisticId);
+      this.assistantOptimisticId = null;
+    }
+    let messages = this.repository.getMessages();
+    setTimeout(() => {
+      this.updateMessages(messages);
+    }, 0);
+  }
+  subscribe(callback) {
+    this._subscriptions.add(callback);
+    return () => this._subscriptions.delete(callback);
+  }
+  updateMessages = (messages) => {
+    this.store.setMessages?.(
+      messages.flatMap(getExternalStoreMessage).filter((m) => m != null)
+    );
+  };
+  onStoreUpdated() {
+    if (this.useStore.getState().store !== this.store) {
+      this.useStore.setState({ store: this.store });
+    }
+  }
+  updateData = (isRunning, vm) => {
+    for (let i = 0; i < vm.length; i++) {
+      const message = vm[i];
+      const parent = vm[i - 1];
+      this.repository.addOrUpdateMessage(parent?.id ?? null, message);
+    }
+    if (this.assistantOptimisticId) {
+      this.repository.deleteMessage(this.assistantOptimisticId);
+      this.assistantOptimisticId = null;
+    }
+    if (hasUpcomingMessage(isRunning, vm)) {
+      this.assistantOptimisticId = this.repository.appendOptimisticMessage(
+        vm.at(-1)?.id ?? null,
+        {
+          role: "assistant",
+          content: []
+        }
+      );
+    }
+    this.repository.resetHead(
+      this.assistantOptimisticId ?? vm.at(-1)?.id ?? null
+    );
+    this.messages = this.repository.getMessages();
+    this.isRunning = isRunning;
+    for (const callback of this._subscriptions) callback();
+  };
+  unstable_synchronizer = () => {
+    const { store } = this.useStore();
+    useExternalStoreSync(store, this.updateData);
+    return null;
+  };
+  addToolResult(options) {
+    if (!this.store.onAddToolResult)
+      throw new Error("Runtime does not support tool results.");
+    this.store.onAddToolResult(options);
+  }
+};
+
+// src/runtimes/external-store/ExternalStoreRuntime.tsx
+var ExternalStoreRuntime = class extends BaseAssistantRuntime {
+  _proxyConfigProvider = new ProxyConfigProvider();
+  constructor(store) {
+    super(new ExternalStoreThreadRuntime(store));
+  }
+  set store(store) {
+    this.thread.store = store;
+  }
+  onStoreUpdated() {
+    return this.thread.onStoreUpdated();
+  }
+  getModelConfig() {
+    return this._proxyConfigProvider.getModelConfig();
+  }
+  registerModelConfigProvider(provider) {
+    return this._proxyConfigProvider.registerModelConfigProvider(provider);
+  }
+  switchToThread(threadId) {
+    if (threadId) {
+      if (!this.store.onSwitchThread)
+        throw new Error("Runtime does not support switching threads.");
+      return this.store.onSwitchThread(threadId);
+    } else {
+      if (!this.store.onNewThread)
+        throw new Error("Runtime does not support switching to new threads.");
+      return this.store.onNewThread();
+    }
+  }
+};
+
+// src/runtimes/external-store/useExternalStoreRuntime.tsx
+import { useEffect as useEffect12, useInsertionEffect as useInsertionEffect4, useState as useState9 } from "react";
+var useExternalStoreRuntime = (store) => {
+  const [runtime] = useState9(() => new ExternalStoreRuntime(store));
+  useInsertionEffect4(() => {
+    runtime.store = store;
+  });
+  useEffect12(() => {
+    runtime.onStoreUpdated();
+  });
+  return runtime;
+};
+
 // src/ui/thread-config.tsx
 import { createContext as createContext5, useContext as useContext5 } from "react";
 import { Fragment as Fragment3, jsx as jsx29 } from "react/jsx-runtime";
@@ -4263,6 +4468,7 @@ export {
   contentPart_exports as ContentPartPrimitive,
   EdgeChatAdapter,
   edit_composer_default as EditComposer,
+  ExternalStoreRuntime,
   internal_exports as INTERNAL,
   message_exports as MessagePrimitive,
   thread_default as Thread,
@@ -4275,6 +4481,7 @@ export {
   fromCoreMessages,
   fromLanguageModelMessages,
   fromLanguageModelTools,
+  getExternalStoreMessage,
   makeAssistantTool,
   makeAssistantToolUI,
   toCoreMessage,
@@ -4302,6 +4509,7 @@ export {
   useContentPartImage,
   useContentPartText,
   useEdgeRuntime,
+  useExternalStoreRuntime,
   useLocalRuntime,
   useMessageContext,
   useMessageIf,