@assistant-ui/react 0.5.82 → 0.5.83

package/dist/index.mjs

@@ -86,6 +86,10 @@ var { useToolUIs, useToolUIsStore } = createContextStoreHook(
   useAssistantContext,
   "useToolUIs"
 );
+var { useThreadManager } = createContextStoreHook(
+  useAssistantContext,
+  "useThreadManager"
+);
 
 // src/context/stores/AssistantToolUIs.ts
 import { create } from "zustand";
@@ -260,16 +264,29 @@ var useAssistantRuntimeStore2 = (runtime) => {
 var useAssistantToolUIsStore = () => {
   return useMemo2(() => makeAssistantToolUIsStore(), []);
 };
+var useThreadManagerStore = (runtime) => {
+  const [store] = useState3(
+    () => create4(() => runtime.threadManager.getState())
+  );
+  useEffect3(() => {
+    const updateState = () => writableStore(store).setState(runtime.threadManager.getState(), true);
+    updateState();
+    return runtime.threadManager.subscribe(updateState);
+  }, [runtime, store]);
+  return store;
+};
 var AssistantRuntimeProviderImpl = ({ children, runtime }) => {
   const useAssistantRuntime2 = useAssistantRuntimeStore2(runtime);
   const useToolUIs2 = useAssistantToolUIsStore();
+  const useThreadManager2 = useThreadManagerStore(runtime);
   const context = useMemo2(() => {
     return {
       useToolUIs: useToolUIs2,
       useAssistantRuntime: useAssistantRuntime2,
-      useAssistantActions: useAssistantRuntime2
+      useAssistantActions: useAssistantRuntime2,
+      useThreadManager: useThreadManager2
     };
-  }, [useAssistantRuntime2, useToolUIs2]);
+  }, [useAssistantRuntime2, useToolUIs2, useThreadManager2]);
   return /* @__PURE__ */ jsx2(AssistantContext.Provider, { value: context, children: /* @__PURE__ */ jsx2(ThreadRuntimeProvider, { runtime: runtime.thread, children }) });
 };
 var AssistantRuntimeProvider = memo(AssistantRuntimeProviderImpl);
@@ -3018,13 +3035,13 @@ var subscribeToMainThread = (runtime, callback) => {
   let cleanup;
   const inner = () => {
     cleanup?.();
-    cleanup = runtime.thread.subscribe(callback);
+    cleanup = runtime.threadManager.mainThread.subscribe(callback);
     if (!first) {
       callback();
     }
     first = false;
   };
-  const unsubscribe = runtime.subscribe(inner);
+  const unsubscribe = runtime.threadManager.mainThread.subscribe(inner);
   inner();
   return () => {
     unsubscribe();
@@ -3033,29 +3050,44 @@ var subscribeToMainThread = (runtime, callback) => {
 };
 
 // src/runtimes/local/useLocalRuntime.tsx
-import { useInsertionEffect, useMemo as useMemo11, useState as useState12 } from "react";
+import { useEffect as useEffect16, useMemo as useMemo11, useState as useState12 } from "react";
 
-// src/runtimes/core/BaseAssistantRuntimeCore.tsx
-var BaseAssistantRuntimeCore = class {
-  constructor(_thread) {
-    this._thread = _thread;
-    this._thread = _thread;
+// src/utils/ProxyConfigProvider.ts
+var ProxyConfigProvider = class {
+  _providers = /* @__PURE__ */ new Set();
+  getModelConfig() {
+    return mergeModelConfigs(this._providers);
   }
-  get thread() {
-    return this._thread;
+  registerModelConfigProvider(provider) {
+    this._providers.add(provider);
+    const unsubscribe = provider.subscribe?.(() => {
+      this.notifySubscribers();
+    });
+    this.notifySubscribers();
+    return () => {
+      this._providers.delete(provider);
+      unsubscribe?.();
+      this.notifySubscribers();
+    };
   }
-  set thread(thread) {
-    this._thread = thread;
-    this.subscriptionHandler();
+  _subscribers = /* @__PURE__ */ new Set();
+  notifySubscribers() {
+    for (const callback of this._subscribers) callback();
   }
-  _subscriptions = /* @__PURE__ */ new Set();
   subscribe(callback) {
-    this._subscriptions.add(callback);
-    return () => this._subscriptions.delete(callback);
+    this._subscribers.add(callback);
+    return () => this._subscribers.delete(callback);
+  }
+};
+
+// src/runtimes/core/BaseAssistantRuntimeCore.tsx
+var BaseAssistantRuntimeCore = class {
+  _proxyConfigProvider = new ProxyConfigProvider();
+  constructor() {
+  }
+  registerModelConfigProvider(provider) {
+    return this._proxyConfigProvider.registerModelConfigProvider(provider);
   }
-  subscriptionHandler = () => {
-    for (const callback of this._subscriptions) callback();
-  };
 };
 
 // src/internal.ts
@@ -3191,34 +3223,6 @@ var DefaultThreadComposerRuntimeCore = class extends BaseComposerRuntimeCore {
   }
 };
 
-// src/utils/ProxyConfigProvider.ts
-var ProxyConfigProvider = class {
-  _providers = /* @__PURE__ */ new Set();
-  getModelConfig() {
-    return mergeModelConfigs(this._providers);
-  }
-  registerModelConfigProvider(provider) {
-    this._providers.add(provider);
-    const unsubscribe = provider.subscribe?.(() => {
-      this.notifySubscribers();
-    });
-    this.notifySubscribers();
-    return () => {
-      this._providers.delete(provider);
-      unsubscribe?.();
-      this.notifySubscribers();
-    };
-  }
-  _subscribers = /* @__PURE__ */ new Set();
-  notifySubscribers() {
-    for (const callback of this._subscribers) callback();
-  }
-  subscribe(callback) {
-    this._subscribers.add(callback);
-    return () => this._subscribers.delete(callback);
-  }
-};
-
 // src/utils/idUtils.tsx
 import { customAlphabet } from "nanoid/non-secure";
 var generateId = customAlphabet(
@@ -3828,20 +3832,67 @@ var ThreadRuntimeImpl = class {
   }
 };
 
+// src/api/ThreadManagerRuntime.ts
+var getThreadManagerState = (threadManager) => {
+  return {
+    threads: threadManager.threads,
+    archivedThreads: threadManager.archivedThreads
+  };
+};
+var THREAD_MANAGER_PATH = {
+  ref: "threadManager"
+};
+var ThreadManagerRuntimeImpl = class {
+  constructor(_core) {
+    this._core = _core;
+    const stateBinding = new LazyMemoizeSubject({
+      path: THREAD_MANAGER_PATH,
+      getState: () => getThreadManagerState(_core),
+      subscribe: (callback) => _core.subscribe(callback)
+    });
+    this._getState = stateBinding.getState.bind(stateBinding);
+  }
+  get path() {
+    return THREAD_MANAGER_PATH;
+  }
+  _getState;
+  getState() {
+    return this._getState();
+  }
+  rename(threadId, newTitle) {
+    return this._core.rename(threadId, newTitle);
+  }
+  archive(threadId) {
+    return this._core.archive(threadId);
+  }
+  unarchive(threadId) {
+    return this._core.unarchive(threadId);
+  }
+  delete(threadId) {
+    return this._core.delete(threadId);
+  }
+  subscribe(callback) {
+    return this._core.subscribe(callback);
+  }
+};
+
 // src/api/AssistantRuntime.ts
 var AssistantRuntimeImpl = class _AssistantRuntimeImpl {
   constructor(_core, _thread) {
     this._core = _core;
     this._thread = _thread;
+    this.threadManager = new ThreadManagerRuntimeImpl(_core.threadManager);
   }
+  threadManager;
   get thread() {
     return this._thread;
   }
   switchToNewThread() {
-    return this._core.switchToNewThread();
+    return this._core.threadManager.switchToNewThread();
   }
   switchToThread(threadId) {
-    return this._core.switchToThread(threadId);
+    if (threadId === null) return this.switchToNewThread();
+    return this._core.threadManager.switchToThread(threadId);
   }
   registerModelConfigProvider(provider) {
     return this._core.registerModelConfigProvider(provider);
@@ -3849,8 +3900,9 @@ var AssistantRuntimeImpl = class _AssistantRuntimeImpl {
   /**
    * @deprecated Thread is now static and never gets updated. This will be removed in 0.6.0.
    */
-  subscribe(callback) {
-    return this._core.subscribe(callback);
+  subscribe() {
+    return () => {
+    };
   }
   static createMainThreadRuntime(_core, CustomThreadRuntime = ThreadRuntimeImpl) {
     return new CustomThreadRuntime(
@@ -3859,8 +3911,8 @@ var AssistantRuntimeImpl = class _AssistantRuntimeImpl {
           ref: "threads.main",
           threadSelector: { type: "main" }
         },
-        getState: () => _core.thread,
-        subscribe: (callback) => _core.subscribe(callback)
+        getState: () => _core.threadManager.mainThread,
+        subscribe: (callback) => _core.threadManager.subscribe(callback)
       })
     );
   }
@@ -4272,9 +4324,6 @@ var DefaultEditComposerRuntimeCore = class extends BaseComposerRuntimeCore {
 var BaseThreadRuntimeCore = class {
   constructor(configProvider) {
     this.configProvider = configProvider;
-    this.configProvider.subscribe?.(() => {
-      this._notifyEventSubscribers("model-config-update");
-    });
   }
   _subscriptions = /* @__PURE__ */ new Set();
   repository = new MessageRepository();
@@ -4376,6 +4425,10 @@ var BaseThreadRuntimeCore = class {
   }
   _eventSubscribers = /* @__PURE__ */ new Map();
   unstable_on(event, callback) {
+    if (event === "model-config-update") {
+      return this.configProvider.subscribe?.(callback) ?? (() => {
+      });
+    }
     const subscribers = this._eventSubscribers.get(event);
     if (!subscribers) {
       this._eventSubscribers.set(event, /* @__PURE__ */ new Set([callback]));
@@ -4391,19 +4444,10 @@ var BaseThreadRuntimeCore = class {
 
 // src/runtimes/local/LocalThreadRuntimeCore.tsx
 var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
-  constructor(configProvider, adapter, { initialMessages, ...options }) {
+  constructor(configProvider, threadId, options) {
     super(configProvider);
-    this.adapter = adapter;
-    this.threadId = generateId();
-    this.options = options;
-    if (initialMessages) {
-      let parentId = null;
-      const messages2 = fromCoreMessages(initialMessages);
-      for (const message of messages2) {
-        this.repository.addOrUpdateMessage(parentId, message);
-        parentId = message.id;
-      }
-    }
+    this.threadId = threadId;
+    this._options = options;
   }
   capabilities = {
     switchToBranch: true,
@@ -4416,20 +4460,17 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
     feedback: false
   };
   abortController = null;
-  threadId;
   isDisabled = false;
   suggestions = [];
   get adapters() {
-    return this.options.adapters;
+    return this._options.adapters;
   }
   _options;
-  get options() {
-    return this._options;
-  }
   get extras() {
     return void 0;
   }
-  set options({ initialMessages, ...options }) {
+  setOptions(options) {
+    if (this._options === options) return;
     this._options = options;
     let hasUpdates = false;
     const canSpeak = options.adapters?.speech !== void 0;
@@ -4505,7 +4546,7 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
       this.repository.addOrUpdateMessage(parentId, message);
       this._notifySubscribers();
     };
-    const maxSteps = this.options.maxSteps ? this.options.maxSteps : (this.options.maxToolRoundtrips ?? 1) + 1;
+    const maxSteps = this._options.maxSteps ? this._options.maxSteps : (this._options.maxToolRoundtrips ?? 1) + 1;
     const steps = message.metadata?.steps?.length ?? 0;
     if (steps >= maxSteps) {
       updateMessage({
@@ -4523,7 +4564,7 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
       });
     }
     try {
-      const promiseOrGenerator = this.adapter.run({
+      const promiseOrGenerator = this.adapters.chatModel.run({
         messages: messages2,
         abortSignal: this.abortController.signal,
         config: this.getModelConfig(),
@@ -4596,44 +4637,154 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
   }
 };
 
-// src/runtimes/local/LocalRuntimeCore.tsx
-var LocalRuntimeCore = class extends BaseAssistantRuntimeCore {
-  _proxyConfigProvider;
-  constructor(adapter, options) {
-    const proxyConfigProvider = new ProxyConfigProvider();
-    super(new LocalThreadRuntimeCore(proxyConfigProvider, adapter, options));
-    this._proxyConfigProvider = proxyConfigProvider;
+// src/runtimes/local/LocalThreadManagerRuntimeCore.tsx
+var LocalThreadManagerRuntimeCore = class {
+  constructor(_threadFactory) {
+    this._threadFactory = _threadFactory;
+    this._mainThread = this._threadFactory(generateId(), { messages: [] });
   }
-  registerModelConfigProvider(provider) {
-    return this._proxyConfigProvider.registerModelConfigProvider(provider);
+  _threadData = /* @__PURE__ */ new Map();
+  _threads = [];
+  _archivedThreads = [];
+  get threads() {
+    return this._threads;
   }
-  switchToNewThread() {
-    const { initialMessages, ...options } = this.thread.options;
-    this.thread = new LocalThreadRuntimeCore(
-      this._proxyConfigProvider,
-      this.thread.adapter,
-      options
-    );
-    this.thread._notifyEventSubscribers("switched-to");
+  get archivedThreads() {
+    return this._archivedThreads;
+  }
+  _mainThread;
+  get mainThread() {
+    return this._mainThread;
   }
   switchToThread(threadId) {
-    if (threadId !== null) {
-      throw new Error("LocalRuntime does not yet support switching threads");
+    if (this._mainThread.threadId === threadId) return;
+    const data = this._threadData.get(threadId);
+    if (!data) throw new Error("Thread not found");
+    const thread = this._threadFactory(threadId, data.data);
+    this._performThreadSwitch(thread);
+  }
+  switchToNewThread() {
+    if (!this._mainThread) return;
+    const thread = this._threadFactory(generateId(), { messages: [] });
+    this._performThreadSwitch(thread);
+  }
+  _performThreadSwitch(newThreadCore) {
+    if (this._mainThread) {
+      const data = this._threadData.get(this._mainThread.threadId);
+      if (!data) throw new Error("Thread not found");
+      const exprt = this._mainThread.export();
+      data.data = exprt;
+    }
+    this._mainThread._notifyEventSubscribers("switched-away");
+    this._mainThread = newThreadCore;
+    newThreadCore._notifyEventSubscribers("switched-to");
+    this._notifySubscribers();
+  }
+  _performMoveOp(threadId, operation) {
+    const data = this._threadData.get(threadId);
+    if (!data) throw new Error("Thread not found");
+    if (operation === "archive" && data.isArchived) return;
+    if (operation === "unarchive" && !data.isArchived) return;
+    if (operation === "archive") {
+      data.isArchived = true;
+      this._archivedThreads = [...this._archivedThreads, data.metadata];
+    }
+    if (operation === "unarchive") {
+      data.isArchived = false;
+      this._threads = [...this._threads, data.metadata];
+    }
+    if (operation === "delete") {
+      this._threadData.delete(threadId);
+    }
+    if (operation === "archive" || operation === "delete" && data.isArchived) {
+      this._archivedThreads = this._archivedThreads.filter(
+        (t) => t.threadId !== threadId
+      );
+    }
+    if (operation === "unarchive" || operation === "delete" && !data.isArchived) {
+      this._threads = this._threads.filter((t) => t.threadId !== threadId);
+    }
+    this._notifySubscribers();
+  }
+  async rename(threadId, newTitle) {
+    const data = this._threadData.get(threadId);
+    if (!data) throw new Error("Thread not found");
+    data.metadata = {
+      ...data.metadata,
+      title: newTitle
+    };
+    const threadList = data.isArchived ? this.archivedThreads : this.threads;
+    const idx = threadList.findIndex((t) => t.threadId === threadId);
+    const updatedThreadList = threadList.toSpliced(idx, 1, data.metadata);
+    if (data.isArchived) {
+      this._archivedThreads = updatedThreadList;
+    } else {
+      this._threads = updatedThreadList;
     }
-    this.switchToNewThread();
+    this._notifySubscribers();
+  }
+  async archive(threadId) {
+    this._performMoveOp(threadId, "archive");
+  }
+  async unarchive(threadId) {
+    this._performMoveOp(threadId, "unarchive");
+  }
+  async delete(threadId) {
+    this._performMoveOp(threadId, "delete");
+  }
+  _subscriptions = /* @__PURE__ */ new Set();
+  subscribe(callback) {
+    this._subscriptions.add(callback);
+    return () => this._subscriptions.delete(callback);
+  }
+  _notifySubscribers() {
+    for (const callback of this._subscriptions) callback();
+  }
+};
+
+// src/runtimes/local/LocalRuntimeCore.tsx
+var getExportFromInitialMessages = (initialMessages) => {
+  const messages2 = fromCoreMessages(initialMessages);
+  return {
+    messages: messages2.map((m, idx) => ({
+      parentId: messages2[idx - 1]?.id ?? null,
+      message: m
+    }))
+  };
+};
+var LocalRuntimeCore = class extends BaseAssistantRuntimeCore {
+  threadManager;
+  _options;
+  constructor(options, initialMessages) {
+    super();
+    this._options = options;
+    this.threadManager = new LocalThreadManagerRuntimeCore((threadId, data) => {
+      const thread = new LocalThreadRuntimeCore(
+        this._proxyConfigProvider,
+        threadId,
+        this._options
+      );
+      thread.import(data);
+      return thread;
+    });
+    if (initialMessages) {
+      this.threadManager.mainThread.import(
+        getExportFromInitialMessages(initialMessages)
+      );
+    }
+  }
+  setOptions(options) {
+    this._options = options;
+    this.threadManager.mainThread.setOptions(options);
   }
   reset({
     initialMessages
   } = {}) {
-    this.switchToThread(null);
+    this.threadManager.switchToNewThread();
     if (!initialMessages) return;
-    const messages2 = fromCoreMessages(initialMessages);
-    this.thread.import({
-      messages: messages2.map((m, idx) => ({
-        parentId: messages2[idx - 1]?.id ?? null,
-        message: m
-      }))
-    });
+    this.threadManager.mainThread.import(
+      getExportFromInitialMessages(initialMessages)
+    );
   }
 };
 
@@ -4654,16 +4805,108 @@ var LocalRuntimeImpl = class _LocalRuntimeImpl extends AssistantRuntimeImpl {
   }
 };
 var useLocalRuntime = (adapter, options = {}) => {
-  const [runtime] = useState12(() => new LocalRuntimeCore(adapter, options));
-  useInsertionEffect(() => {
-    runtime.thread.adapter = adapter;
-    runtime.thread.options = options;
+  const opt = {
+    ...options,
+    adapters: {
+      ...options.adapters,
+      chatModel: adapter
+    }
+  };
+  const [runtime] = useState12(() => new LocalRuntimeCore(opt));
+  useEffect16(() => {
+    runtime.setOptions(opt);
   });
   return useMemo11(() => LocalRuntimeImpl.create(runtime), [runtime]);
 };
 
 // src/runtimes/external-store/useExternalStoreRuntime.tsx
-import { useEffect as useEffect16, useMemo as useMemo12, useState as useState13 } from "react";
+import { useEffect as useEffect17, useMemo as useMemo12, useState as useState13 } from "react";
+
+// src/runtimes/external-store/ExternalStoreThreadManagementAdapter.tsx
+var EMPTY_ARRAY2 = Object.freeze([]);
+var DEFAULT_THREAD_ID = "DEFAULT_THREAD_ID";
+var ExternalStoreThreadManagerRuntimeCore = class {
+  constructor(adapter = {}, threadFactory) {
+    this.adapter = adapter;
+    this.threadFactory = threadFactory;
+    this._mainThread = this.threadFactory(DEFAULT_THREAD_ID);
+  }
+  get threads() {
+    return this.adapter.threads ?? EMPTY_ARRAY2;
+  }
+  get archivedThreads() {
+    return this.adapter.archivedThreads ?? EMPTY_ARRAY2;
+  }
+  _mainThread;
+  get mainThread() {
+    return this._mainThread;
+  }
+  setAdapter(adapter) {
+    const previousAdapter = this.adapter;
+    this.adapter = adapter;
+    const newThreadId = adapter.threadId ?? DEFAULT_THREAD_ID;
+    const newThreads = adapter.threads ?? EMPTY_ARRAY2;
+    const newArchivedThreads = adapter.archivedThreads ?? EMPTY_ARRAY2;
+    if (previousAdapter.threadId === newThreadId && previousAdapter.threads === newThreads && previousAdapter.archivedThreads === newArchivedThreads) {
+      return;
+    }
+    if (previousAdapter.threadId !== newThreadId) {
+      this._mainThread._notifyEventSubscribers("switched-away");
+      this._mainThread = this.threadFactory(newThreadId);
+      this._mainThread._notifyEventSubscribers("switched-to");
+    }
+    this._notifySubscribers();
+  }
+  switchToThread(threadId) {
+    if (this._mainThread?.threadId === threadId) return;
+    const onSwitchToThread = this.adapter.onSwitchToThread;
+    if (!onSwitchToThread)
+      throw new Error(
+        "External store adapter does not support switching to thread"
+      );
+    onSwitchToThread(threadId);
+  }
+  switchToNewThread() {
+    const onSwitchToNewThread = this.adapter.onSwitchToNewThread;
+    if (!onSwitchToNewThread)
+      throw new Error(
+        "External store adapter does not support switching to new thread"
+      );
+    onSwitchToNewThread();
+  }
+  async rename(threadId, newTitle) {
+    const onRename = this.adapter.onRename;
+    if (!onRename)
+      throw new Error("External store adapter does not support renaming");
+    onRename(threadId, newTitle);
+  }
+  async archive(threadId) {
+    const onArchive = this.adapter.onArchive;
+    if (!onArchive)
+      throw new Error("External store adapter does not support archiving");
+    onArchive(threadId);
+  }
+  async unarchive(threadId) {
+    const onUnarchive = this.adapter.onUnarchive;
+    if (!onUnarchive)
+      throw new Error("External store adapter does not support unarchiving");
+    onUnarchive(threadId);
+  }
+  async delete(threadId) {
+    const onDelete = this.adapter.onDelete;
+    if (!onDelete)
+      throw new Error("External store adapter does not support deleting");
+    onDelete(threadId);
+  }
+  _subscriptions = /* @__PURE__ */ new Set();
+  subscribe(callback) {
+    this._subscriptions.add(callback);
+    return () => this._subscriptions.delete(callback);
+  }
+  _notifySubscribers() {
+    for (const callback of this._subscriptions) callback();
+  }
+};
 
 // src/runtimes/external-store/getExternalStoreMessage.tsx
 var symbolInnerMessage = Symbol("innerMessage");
@@ -4768,7 +5011,7 @@ var fromThreadMessageLike = (like, fallbackId, fallbackStatus) => {
 };
 
 // src/runtimes/external-store/ExternalStoreThreadRuntimeCore.tsx
-var EMPTY_ARRAY2 = Object.freeze([]);
+var EMPTY_ARRAY3 = Object.freeze([]);
 var hasUpcomingMessage = (isRunning, messages2) => {
   return isRunning && messages2[messages2.length - 1]?.role !== "assistant";
 };
@@ -4801,26 +5044,23 @@ var ExternalStoreThreadRuntimeCore = class extends BaseThreadRuntimeCore {
   _converter = new ThreadMessageConverter();
   _store;
   beginEdit(messageId) {
-    if (!this.store.onEdit)
+    if (!this._store.onEdit)
       throw new Error("Runtime does not support editing.");
     super.beginEdit(messageId);
   }
-  constructor(configProvider, store) {
+  constructor(configProvider, threadId, store) {
     super(configProvider);
-    this.store = store;
+    this.threadId = threadId;
+    this.setStore(store);
   }
-  get store() {
-    return this._store;
-  }
-  set store(store) {
+  setStore(store) {
     if (this._store === store) return;
-    this.threadId = store.threadId ?? this.threadId ?? generateId();
     const isRunning = store.isRunning ?? false;
     this.isDisabled = store.isDisabled ?? false;
     const oldStore = this._store;
     this._store = store;
     this.extras = store.extras;
-    this.suggestions = store.suggestions ?? EMPTY_ARRAY2;
+    this.suggestions = store.suggestions ?? EMPTY_ARRAY3;
     this._capabilities = {
       switchToBranch: this._store.setMessages !== void 0,
       edit: this._store.onEdit !== void 0,
@@ -4829,8 +5069,8 @@ var ExternalStoreThreadRuntimeCore = class extends BaseThreadRuntimeCore {
       speech: this._store.adapters?.speech !== void 0,
       unstable_copy: this._store.unstable_capabilities?.copy !== false,
       // default true
-      attachments: !!this.store.adapters?.attachments,
-      feedback: !!this.store.adapters?.feedback
+      attachments: !!this._store.adapters?.attachments,
+      feedback: !!this._store.adapters?.feedback
     };
     if (oldStore) {
       if (oldStore.convertMessage !== store.convertMessage) {
@@ -4934,57 +5174,41 @@ var ExternalStoreThreadRuntimeCore = class extends BaseThreadRuntimeCore {
 };
 
 // src/runtimes/external-store/ExternalStoreRuntimeCore.tsx
+var getThreadManagerAdapter = (store) => {
+  return {
+    threadId: store.threadId,
+    onSwitchToNewThread: store.onSwitchToNewThread,
+    onSwitchToThread: store.onSwitchToThread,
+    ...store.adapters?.threadManager
+  };
+};
 var ExternalStoreRuntimeCore = class extends BaseAssistantRuntimeCore {
-  _proxyConfigProvider;
+  threadManager;
+  _store;
   constructor(store) {
-    const provider = new ProxyConfigProvider();
-    super(new ExternalStoreThreadRuntimeCore(provider, store));
-    this._proxyConfigProvider = provider;
-  }
-  getModelConfig() {
-    return this._proxyConfigProvider.getModelConfig();
-  }
-  registerModelConfigProvider(provider) {
-    return this._proxyConfigProvider.registerModelConfigProvider(provider);
-  }
-  async switchToNewThread() {
-    if (!this.thread.store.onSwitchToNewThread)
-      throw new Error("Runtime does not support switching to new threads.");
-    this.thread = new ExternalStoreThreadRuntimeCore(
-      this._proxyConfigProvider,
-      {
-        ...this.thread.store,
-        messages: []
-      }
-    );
-    await this.thread.store.onSwitchToNewThread();
-    this.thread._notifyEventSubscribers("switched-to");
-  }
-  async switchToThread(threadId) {
-    if (threadId !== null) {
-      if (!this.thread.store.onSwitchToThread)
-        throw new Error("Runtime does not support switching threads.");
-      this.thread = new ExternalStoreThreadRuntimeCore(
+    super();
+    this._store = store;
+    this.threadManager = new ExternalStoreThreadManagerRuntimeCore(
+      getThreadManagerAdapter(store),
+      (threadId) => new ExternalStoreThreadRuntimeCore(
         this._proxyConfigProvider,
-        {
-          ...this.thread.store,
-          messages: []
-          // ignore messages until rerender
-        }
-      );
-      await this.thread.store.onSwitchToThread(threadId);
-      this.thread._notifyEventSubscribers("switched-to");
-    } else {
-      this.switchToNewThread();
-    }
+        threadId,
+        this._store
+      )
+    );
+  }
+  setStore(store) {
+    this._store = store;
+    this.threadManager.setAdapter(getThreadManagerAdapter(store));
+    this.threadManager.mainThread.setStore(store);
   }
 };
 
 // src/runtimes/external-store/useExternalStoreRuntime.tsx
 var useExternalStoreRuntime = (store) => {
   const [runtime] = useState13(() => new ExternalStoreRuntimeCore(store));
-  useEffect16(() => {
-    runtime.thread.store = store;
+  useEffect17(() => {
+    runtime.setStore(store);
   });
   return useMemo12(
     () => AssistantRuntimeImpl.create(runtime, ThreadRuntimeImpl),
@@ -5754,7 +5978,7 @@ CircleStopIcon.displayName = "CircleStopIcon";
 // src/ui/attachment.tsx
 import {
   forwardRef as forwardRef28,
-  useEffect as useEffect17,
+  useEffect as useEffect18,
   useState as useState15
 } from "react";
 import { CircleXIcon, FileIcon } from "lucide-react";
@@ -5799,7 +6023,7 @@ var AttachmentRoot = withDefaults(attachment_exports.Root, {
 AttachmentRoot.displayName = "AttachmentRoot";
 var useFileSrc = (file) => {
   const [src, setSrc] = useState15(void 0);
-  useEffect17(() => {
+  useEffect18(() => {
     if (!file) {
       setSrc(void 0);
       return;
@@ -6069,8 +6293,13 @@ var ThreadWelcomeMessageStyled = withDefaults("p", {
   className: "aui-thread-welcome-message"
 });
 var ThreadWelcomeMessage = forwardRef30(({ message: messageProp, ...rest }, ref) => {
-  const { welcome: { message = "How can I help you today?" } = {} } = useThreadConfig();
-  return /* @__PURE__ */ jsx48(ThreadWelcomeMessageStyled, { ...rest, ref, children: messageProp ?? message });
+  const {
+    welcome: { message } = {},
+    strings: {
+      welcome: { message: defaultMessage = "How can I help you today?" } = {}
+    } = {}
+  } = useThreadConfig();
+  return /* @__PURE__ */ jsx48(ThreadWelcomeMessageStyled, { ...rest, ref, children: messageProp ?? message ?? defaultMessage });
 });
 ThreadWelcomeMessage.displayName = "ThreadWelcomeMessage";
 var ThreadWelcomeSuggestionContainer = withDefaults("div", {
@@ -6522,6 +6751,7 @@ export {
   useThreadContext,
   useThreadEmpty,
   useThreadIf,
+  useThreadManager,
   useThreadMessages,
   useThreadMessagesStore,
   useThreadModelConfig,