@assistant-ui/react 0.5.82 → 0.5.83

package/dist/index.js

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16; var _class17; var _class18;
 
 
 
@@ -85,6 +85,10 @@ var { useToolUIs, useToolUIsStore } = createContextStoreHook(
   useAssistantContext,
   "useToolUIs"
 );
+var { useThreadManager } = createContextStoreHook(
+  useAssistantContext,
+  "useThreadManager"
+);
 
 // src/context/stores/AssistantToolUIs.ts
 var _zustand = require('zustand');
@@ -259,16 +263,29 @@ var useAssistantRuntimeStore2 = (runtime) => {
 var useAssistantToolUIsStore = () => {
   return _react.useMemo.call(void 0, () => makeAssistantToolUIsStore(), []);
 };
+var useThreadManagerStore = (runtime) => {
+  const [store] = _react.useState.call(void 0, 
+    () => _zustand.create.call(void 0, () => runtime.threadManager.getState())
+  );
+  _react.useEffect.call(void 0, () => {
+    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 = _react.useMemo.call(void 0, () => {
     return {
       useToolUIs: useToolUIs2,
       useAssistantRuntime: useAssistantRuntime2,
-      useAssistantActions: useAssistantRuntime2
+      useAssistantActions: useAssistantRuntime2,
+      useThreadManager: useThreadManager2
     };
-  }, [useAssistantRuntime2, useToolUIs2]);
+  }, [useAssistantRuntime2, useToolUIs2, useThreadManager2]);
   return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, AssistantContext.Provider, { value: context, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ThreadRuntimeProvider, { runtime: runtime.thread, children }) });
 };
 var AssistantRuntimeProvider = _react.memo.call(void 0, AssistantRuntimeProviderImpl);
@@ -3017,13 +3034,13 @@ var subscribeToMainThread = (runtime, callback) => {
   let cleanup;
   const inner = () => {
     _optionalChain([cleanup, 'optionalCall', _154 => _154()]);
-    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();
@@ -3034,29 +3051,44 @@ var subscribeToMainThread = (runtime, callback) => {
 // src/runtimes/local/useLocalRuntime.tsx
 
 
-// src/runtimes/core/BaseAssistantRuntimeCore.tsx
-var BaseAssistantRuntimeCore = (_class5 = class {
-  constructor(_thread) {;_class5.prototype.__init9.call(this);_class5.prototype.__init10.call(this);
-    this._thread = _thread;
-    this._thread = _thread;
+// src/utils/ProxyConfigProvider.ts
+var ProxyConfigProvider = (_class5 = class {constructor() { _class5.prototype.__init9.call(this);_class5.prototype.__init10.call(this); }
+  __init9() {this._providers = /* @__PURE__ */ new Set()}
+  getModelConfig() {
+    return _chunkC6UZOY5Ajs.mergeModelConfigs.call(void 0, this._providers);
   }
-  get thread() {
-    return this._thread;
+  registerModelConfigProvider(provider) {
+    this._providers.add(provider);
+    const unsubscribe = _optionalChain([provider, 'access', _156 => _156.subscribe, 'optionalCall', _157 => _157(() => {
+      this.notifySubscribers();
+    })]);
+    this.notifySubscribers();
+    return () => {
+      this._providers.delete(provider);
+      _optionalChain([unsubscribe, 'optionalCall', _158 => _158()]);
+      this.notifySubscribers();
+    };
   }
-  set thread(thread) {
-    this._thread = thread;
-    this.subscriptionHandler();
+  __init10() {this._subscribers = /* @__PURE__ */ new Set()}
+  notifySubscribers() {
+    for (const callback of this._subscribers) callback();
   }
-  __init9() {this._subscriptions = /* @__PURE__ */ new Set()}
   subscribe(callback) {
-    this._subscriptions.add(callback);
-    return () => this._subscriptions.delete(callback);
+    this._subscribers.add(callback);
+    return () => this._subscribers.delete(callback);
   }
-  __init10() {this.subscriptionHandler = () => {
-    for (const callback of this._subscriptions) callback();
-  }}
 }, _class5);
 
+// src/runtimes/core/BaseAssistantRuntimeCore.tsx
+var BaseAssistantRuntimeCore = (_class6 = class {
+  __init11() {this._proxyConfigProvider = new ProxyConfigProvider()}
+  constructor() {;_class6.prototype.__init11.call(this);
+  }
+  registerModelConfigProvider(provider) {
+    return this._proxyConfigProvider.registerModelConfigProvider(provider);
+  }
+}, _class6);
+
 // src/internal.ts
 var internal_exports = {};
 _chunkPZ5AY32Cjs.__export.call(void 0, internal_exports, {
@@ -3075,12 +3107,12 @@ _chunkPZ5AY32Cjs.__export.call(void 0, internal_exports, {
 
 // src/runtimes/composer/BaseComposerRuntimeCore.tsx
 var isAttachmentComplete = (a) => a.status.type === "complete";
-var BaseComposerRuntimeCore = (_class6 = class {constructor() { _class6.prototype.__init11.call(this);_class6.prototype.__init12.call(this);_class6.prototype.__init13.call(this);_class6.prototype.__init14.call(this); }
-  __init11() {this.isEditing = true}
+var BaseComposerRuntimeCore = (_class7 = class {constructor() { _class7.prototype.__init12.call(this);_class7.prototype.__init13.call(this);_class7.prototype.__init14.call(this);_class7.prototype.__init15.call(this); }
+  __init12() {this.isEditing = true}
   getAttachmentAccept() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _156 => _156.getAttachmentAdapter, 'call', _157 => _157(), 'optionalAccess', _158 => _158.accept]), () => ( "*"));
+    return _nullishCoalesce(_optionalChain([this, 'access', _159 => _159.getAttachmentAdapter, 'call', _160 => _160(), 'optionalAccess', _161 => _161.accept]), () => ( "*"));
   }
-  __init12() {this._attachments = []}
+  __init13() {this._attachments = []}
   set attachments(value) {
     this._attachments = value;
     this.notifySubscribers();
@@ -3091,7 +3123,7 @@ var BaseComposerRuntimeCore = (_class6 = class {constructor() { _class6.prototyp
   get isEmpty() {
     return !this.text.trim() && !this.attachments.length;
   }
-  __init13() {this._text = ""}
+  __init14() {this._text = ""}
   get text() {
     return this._text;
   }
@@ -3110,7 +3142,7 @@ var BaseComposerRuntimeCore = (_class6 = class {constructor() { _class6.prototyp
       this.attachments.map(async (a) => {
         if (isAttachmentComplete(a)) return a;
         const result = await adapter.send(a);
-        if (_optionalChain([result, 'access', _159 => _159.status, 'optionalAccess', _160 => _160.type]) !== "complete") {
+        if (_optionalChain([result, 'access', _162 => _162.status, 'optionalAccess', _163 => _163.type]) !== "complete") {
           result.status = { type: "complete" };
         }
         return result;
@@ -3144,7 +3176,7 @@ var BaseComposerRuntimeCore = (_class6 = class {constructor() { _class6.prototyp
     this._attachments = this._attachments.toSpliced(index, 1);
     this.notifySubscribers();
   }
-  __init14() {this._subscriptions = /* @__PURE__ */ new Set()}
+  __init15() {this._subscriptions = /* @__PURE__ */ new Set()}
   notifySubscribers() {
     for (const callback of this._subscriptions) callback();
   }
@@ -3152,16 +3184,16 @@ var BaseComposerRuntimeCore = (_class6 = class {constructor() { _class6.prototyp
     this._subscriptions.add(callback);
     return () => this._subscriptions.delete(callback);
   }
-}, _class6);
+}, _class7);
 
 // src/runtimes/composer/DefaultThreadComposerRuntimeCore.tsx
-var DefaultThreadComposerRuntimeCore = (_class7 = class extends BaseComposerRuntimeCore {
+var DefaultThreadComposerRuntimeCore = (_class8 = class extends BaseComposerRuntimeCore {
   constructor(runtime) {
-    super();_class7.prototype.__init15.call(this);;
+    super();_class8.prototype.__init16.call(this);;
     this.runtime = runtime;
     this.connect();
   }
-  __init15() {this._canCancel = false}
+  __init16() {this._canCancel = false}
   get canCancel() {
     return this._canCancel;
   }
@@ -3169,7 +3201,7 @@ var DefaultThreadComposerRuntimeCore = (_class7 = class extends BaseComposerRunt
     return super.attachments;
   }
   getAttachmentAdapter() {
-    return _optionalChain([this, 'access', _161 => _161.runtime, 'access', _162 => _162.adapters, 'optionalAccess', _163 => _163.attachments]);
+    return _optionalChain([this, 'access', _164 => _164.runtime, 'access', _165 => _165.adapters, 'optionalAccess', _166 => _166.attachments]);
   }
   connect() {
     return this.runtime.subscribe(() => {
@@ -3182,40 +3214,12 @@ var DefaultThreadComposerRuntimeCore = (_class7 = class extends BaseComposerRunt
   async handleSend(message) {
     this.runtime.append({
       ...message,
-      parentId: _nullishCoalesce(_optionalChain([this, 'access', _164 => _164.runtime, 'access', _165 => _165.messages, 'access', _166 => _166.at, 'call', _167 => _167(-1), 'optionalAccess', _168 => _168.id]), () => ( null))
+      parentId: _nullishCoalesce(_optionalChain([this, 'access', _167 => _167.runtime, 'access', _168 => _168.messages, 'access', _169 => _169.at, 'call', _170 => _170(-1), 'optionalAccess', _171 => _171.id]), () => ( null))
     });
   }
   async cancel() {
     this.runtime.cancelRun();
   }
-}, _class7);
-
-// src/utils/ProxyConfigProvider.ts
-var ProxyConfigProvider = (_class8 = class {constructor() { _class8.prototype.__init16.call(this);_class8.prototype.__init17.call(this); }
-  __init16() {this._providers = /* @__PURE__ */ new Set()}
-  getModelConfig() {
-    return _chunkC6UZOY5Ajs.mergeModelConfigs.call(void 0, this._providers);
-  }
-  registerModelConfigProvider(provider) {
-    this._providers.add(provider);
-    const unsubscribe = _optionalChain([provider, 'access', _169 => _169.subscribe, 'optionalCall', _170 => _170(() => {
-      this.notifySubscribers();
-    })]);
-    this.notifySubscribers();
-    return () => {
-      this._providers.delete(provider);
-      _optionalChain([unsubscribe, 'optionalCall', _171 => _171()]);
-      this.notifySubscribers();
-    };
-  }
-  __init17() {this._subscribers = /* @__PURE__ */ new Set()}
-  notifySubscribers() {
-    for (const callback of this._subscribers) callback();
-  }
-  subscribe(callback) {
-    this._subscribers.add(callback);
-    return () => this._subscribers.delete(callback);
-  }
 }, _class8);
 
 // src/utils/idUtils.tsx
@@ -3283,11 +3287,11 @@ var findHead = (message) => {
   if ("current" in message) return message;
   return null;
 };
-var MessageRepository = (_class9 = class {constructor() { _class9.prototype.__init18.call(this);_class9.prototype.__init19.call(this);_class9.prototype.__init20.call(this); }
-  __init18() {this.messages = /* @__PURE__ */ new Map()}
+var MessageRepository = (_class9 = class {constructor() { _class9.prototype.__init17.call(this);_class9.prototype.__init18.call(this);_class9.prototype.__init19.call(this); }
+  __init17() {this.messages = /* @__PURE__ */ new Map()}
   // message_id -> item
-  __init19() {this.head = null}
-  __init20() {this.root = {
+  __init18() {this.head = null}
+  __init19() {this.root = {
     children: [],
     next: null
   }}
@@ -3652,7 +3656,7 @@ var ThreadRuntimeImpl = (_class10 = class {
     return this._threadBinding.getState();
   }
   
-  constructor(threadBinding) {;_class10.prototype.__init21.call(this);
+  constructor(threadBinding) {;_class10.prototype.__init20.call(this);
     const stateBinding = new LazyMemoizeSubject({
       path: threadBinding.path,
       getState: () => getThreadState(threadBinding.getState()),
@@ -3810,7 +3814,7 @@ var ThreadRuntimeImpl = (_class10 = class {
       this._threadBinding
     );
   }
-  __init21() {this._eventListenerNestedSubscriptions = /* @__PURE__ */ new Map()}
+  __init20() {this._eventListenerNestedSubscriptions = /* @__PURE__ */ new Map()}
   unstable_on(event, callback) {
     let subject = this._eventListenerNestedSubscriptions.get(event);
     if (!subject) {
@@ -3827,20 +3831,67 @@ var ThreadRuntimeImpl = (_class10 = class {
   }
 }, _class10);
 
+// 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() {
+    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);
   }
+  
   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);
@@ -3848,8 +3899,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(
@@ -3858,8 +3910,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)
       })
     );
   }
@@ -4269,22 +4321,19 @@ var DefaultEditComposerRuntimeCore = class extends BaseComposerRuntimeCore {
 
 // src/runtimes/core/BaseThreadRuntimeCore.tsx
 var BaseThreadRuntimeCore = (_class11 = class {
-  constructor(configProvider) {;_class11.prototype.__init22.call(this);_class11.prototype.__init23.call(this);_class11.prototype.__init24.call(this);_class11.prototype.__init25.call(this);_class11.prototype.__init26.call(this);_class11.prototype.__init27.call(this);
+  constructor(configProvider) {;_class11.prototype.__init21.call(this);_class11.prototype.__init22.call(this);_class11.prototype.__init23.call(this);_class11.prototype.__init24.call(this);_class11.prototype.__init25.call(this);_class11.prototype.__init26.call(this);
     this.configProvider = configProvider;
-    _optionalChain([this, 'access', _208 => _208.configProvider, 'access', _209 => _209.subscribe, 'optionalCall', _210 => _210(() => {
-      this._notifyEventSubscribers("model-config-update");
-    })]);
   }
-  __init22() {this._subscriptions = /* @__PURE__ */ new Set()}
-  __init23() {this.repository = new MessageRepository()}
+  __init21() {this._subscriptions = /* @__PURE__ */ new Set()}
+  __init22() {this.repository = new MessageRepository()}
   get messages() {
     return this.repository.getMessages();
   }
-  __init24() {this.composer = new DefaultThreadComposerRuntimeCore(this)}
+  __init23() {this.composer = new DefaultThreadComposerRuntimeCore(this)}
   getModelConfig() {
     return this.configProvider.getModelConfig();
   }
-  __init25() {this._editComposers = /* @__PURE__ */ new Map()}
+  __init24() {this._editComposers = /* @__PURE__ */ new Map()}
   getEditComposer(messageId) {
     return this._editComposers.get(messageId);
   }
@@ -4323,12 +4372,12 @@ var BaseThreadRuntimeCore = (_class11 = class {
     this._subscriptions.add(callback);
     return () => this._subscriptions.delete(callback);
   }
-  __init26() {this._submittedFeedback = {}}
+  __init25() {this._submittedFeedback = {}}
   getSubmittedFeedback(messageId) {
     return this._submittedFeedback[messageId];
   }
   submitFeedback({ messageId, type }) {
-    const adapter = _optionalChain([this, 'access', _211 => _211.adapters, 'optionalAccess', _212 => _212.feedback]);
+    const adapter = _optionalChain([this, 'access', _208 => _208.adapters, 'optionalAccess', _209 => _209.feedback]);
     if (!adapter) throw new Error("Feedback adapter not configured");
     const { message } = this.repository.getMessage(messageId);
     adapter.submit({ message, type });
@@ -4338,10 +4387,10 @@ var BaseThreadRuntimeCore = (_class11 = class {
   
   
   speak(messageId) {
-    const adapter = _optionalChain([this, 'access', _213 => _213.adapters, 'optionalAccess', _214 => _214.speech]);
+    const adapter = _optionalChain([this, 'access', _210 => _210.adapters, 'optionalAccess', _211 => _211.speech]);
     if (!adapter) throw new Error("Speech adapter not configured");
     const { message } = this.repository.getMessage(messageId);
-    _optionalChain([this, 'access', _215 => _215._stopSpeaking, 'optionalCall', _216 => _216()]);
+    _optionalChain([this, 'access', _212 => _212._stopSpeaking, 'optionalCall', _213 => _213()]);
     const utterance = adapter.speak(getThreadMessageText(message));
     const unsub = utterance.subscribe(() => {
       if (utterance.status.type === "ended") {
@@ -4373,8 +4422,12 @@ var BaseThreadRuntimeCore = (_class11 = class {
     this.repository.import(data);
     this._notifySubscribers();
   }
-  __init27() {this._eventSubscribers = /* @__PURE__ */ new Map()}
+  __init26() {this._eventSubscribers = /* @__PURE__ */ new Map()}
   unstable_on(event, callback) {
+    if (event === "model-config-update") {
+      return _nullishCoalesce(_optionalChain([this, 'access', _214 => _214.configProvider, 'access', _215 => _215.subscribe, 'optionalCall', _216 => _216(callback)]), () => ( (() => {
+      })));
+    }
     const subscribers = this._eventSubscribers.get(event);
     if (!subscribers) {
       this._eventSubscribers.set(event, /* @__PURE__ */ new Set([callback]));
@@ -4390,21 +4443,12 @@ var BaseThreadRuntimeCore = (_class11 = class {
 
 // src/runtimes/local/LocalThreadRuntimeCore.tsx
 var LocalThreadRuntimeCore = (_class12 = class extends BaseThreadRuntimeCore {
-  constructor(configProvider, adapter, { initialMessages, ...options }) {
-    super(configProvider);_class12.prototype.__init28.call(this);_class12.prototype.__init29.call(this);_class12.prototype.__init30.call(this);_class12.prototype.__init31.call(this);;
-    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;
-      }
-    }
+  constructor(configProvider, threadId, options) {
+    super(configProvider);_class12.prototype.__init27.call(this);_class12.prototype.__init28.call(this);_class12.prototype.__init29.call(this);_class12.prototype.__init30.call(this);;
+    this.threadId = threadId;
+    this._options = options;
   }
-  __init28() {this.capabilities = {
+  __init27() {this.capabilities = {
     switchToBranch: true,
     edit: true,
     reload: true,
@@ -4414,21 +4458,18 @@ var LocalThreadRuntimeCore = (_class12 = class extends BaseThreadRuntimeCore {
     attachments: false,
     feedback: false
   }}
-  __init29() {this.abortController = null}
-  
-  __init30() {this.isDisabled = false}
-  __init31() {this.suggestions = []}
+  __init28() {this.abortController = null}
+  __init29() {this.isDisabled = false}
+  __init30() {this.suggestions = []}
   get adapters() {
-    return this.options.adapters;
+    return this._options.adapters;
   }
   
-  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 = _optionalChain([options, 'access', _217 => _217.adapters, 'optionalAccess', _218 => _218.speech]) !== void 0;
@@ -4504,7 +4545,7 @@ var LocalThreadRuntimeCore = (_class12 = class extends BaseThreadRuntimeCore {
       this.repository.addOrUpdateMessage(parentId, message);
       this._notifySubscribers();
     };
-    const maxSteps = this.options.maxSteps ? this.options.maxSteps : (_nullishCoalesce(this.options.maxToolRoundtrips, () => ( 1))) + 1;
+    const maxSteps = this._options.maxSteps ? this._options.maxSteps : (_nullishCoalesce(this._options.maxToolRoundtrips, () => ( 1))) + 1;
     const steps = _nullishCoalesce(_optionalChain([message, 'access', _236 => _236.metadata, 'optionalAccess', _237 => _237.steps, 'optionalAccess', _238 => _238.length]), () => ( 0));
     if (steps >= maxSteps) {
       updateMessage({
@@ -4522,7 +4563,7 @@ var LocalThreadRuntimeCore = (_class12 = class extends BaseThreadRuntimeCore {
       });
     }
     try {
-      const promiseOrGenerator = this.adapter.run({
+      const promiseOrGenerator = this.adapters.chatModel.run({
         messages: messages2,
         abortSignal: this.abortController.signal,
         config: this.getModelConfig(),
@@ -4595,44 +4636,154 @@ var LocalThreadRuntimeCore = (_class12 = class extends BaseThreadRuntimeCore {
   }
 }, _class12);
 
-// src/runtimes/local/LocalRuntimeCore.tsx
-var LocalRuntimeCore = class extends BaseAssistantRuntimeCore {
+// src/runtimes/local/LocalThreadManagerRuntimeCore.tsx
+var LocalThreadManagerRuntimeCore = (_class13 = class {
+  constructor(_threadFactory) {;_class13.prototype.__init31.call(this);_class13.prototype.__init32.call(this);_class13.prototype.__init33.call(this);_class13.prototype.__init34.call(this);
+    this._threadFactory = _threadFactory;
+    this._mainThread = this._threadFactory(generateId(), { messages: [] });
+  }
+  __init31() {this._threadData = /* @__PURE__ */ new Map()}
+  __init32() {this._threads = []}
+  __init33() {this._archivedThreads = []}
+  get threads() {
+    return this._threads;
+  }
+  get archivedThreads() {
+    return this._archivedThreads;
+  }
   
-  constructor(adapter, options) {
-    const proxyConfigProvider = new ProxyConfigProvider();
-    super(new LocalThreadRuntimeCore(proxyConfigProvider, adapter, options));
-    this._proxyConfigProvider = proxyConfigProvider;
+  get mainThread() {
+    return this._mainThread;
   }
-  registerModelConfigProvider(provider) {
-    return this._proxyConfigProvider.registerModelConfigProvider(provider);
+  switchToThread(threadId) {
+    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() {
-    const { initialMessages, ...options } = this.thread.options;
-    this.thread = new LocalThreadRuntimeCore(
-      this._proxyConfigProvider,
-      this.thread.adapter,
-      options
-    );
-    this.thread._notifyEventSubscribers("switched-to");
+    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();
   }
-  switchToThread(threadId) {
-    if (threadId !== null) {
-      throw new Error("LocalRuntime does not yet support switching threads");
+  _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._notifySubscribers();
+  }
+  async archive(threadId) {
+    this._performMoveOp(threadId, "archive");
+  }
+  async unarchive(threadId) {
+    this._performMoveOp(threadId, "unarchive");
+  }
+  async delete(threadId) {
+    this._performMoveOp(threadId, "delete");
+  }
+  __init34() {this._subscriptions = /* @__PURE__ */ new Set()}
+  subscribe(callback) {
+    this._subscriptions.add(callback);
+    return () => this._subscriptions.delete(callback);
+  }
+  _notifySubscribers() {
+    for (const callback of this._subscriptions) callback();
+  }
+}, _class13);
+
+// src/runtimes/local/LocalRuntimeCore.tsx
+var getExportFromInitialMessages = (initialMessages) => {
+  const messages2 = fromCoreMessages(initialMessages);
+  return {
+    messages: messages2.map((m, idx) => ({
+      parentId: _nullishCoalesce(_optionalChain([messages2, 'access', _242 => _242[idx - 1], 'optionalAccess', _243 => _243.id]), () => ( null)),
+      message: m
+    }))
+  };
+};
+var LocalRuntimeCore = class extends BaseAssistantRuntimeCore {
+  
+  
+  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)
+      );
     }
-    this.switchToNewThread();
+  }
+  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: _nullishCoalesce(_optionalChain([messages2, 'access', _242 => _242[idx - 1], 'optionalAccess', _243 => _243.id]), () => ( null)),
-        message: m
-      }))
-    });
+    this.threadManager.mainThread.import(
+      getExportFromInitialMessages(initialMessages)
+    );
   }
 };
 
@@ -4653,10 +4804,16 @@ var LocalRuntimeImpl = class _LocalRuntimeImpl extends AssistantRuntimeImpl {
   }
 };
 var useLocalRuntime = (adapter, options = {}) => {
-  const [runtime] = _react.useState.call(void 0, () => new LocalRuntimeCore(adapter, options));
-  _react.useInsertionEffect.call(void 0, () => {
-    runtime.thread.adapter = adapter;
-    runtime.thread.options = options;
+  const opt = {
+    ...options,
+    adapters: {
+      ...options.adapters,
+      chatModel: adapter
+    }
+  };
+  const [runtime] = _react.useState.call(void 0, () => new LocalRuntimeCore(opt));
+  _react.useEffect.call(void 0, () => {
+    runtime.setOptions(opt);
   });
   return _react.useMemo.call(void 0, () => LocalRuntimeImpl.create(runtime), [runtime]);
 };
@@ -4664,6 +4821,92 @@ var useLocalRuntime = (adapter, options = {}) => {
 // src/runtimes/external-store/useExternalStoreRuntime.tsx
 
 
+// src/runtimes/external-store/ExternalStoreThreadManagementAdapter.tsx
+var EMPTY_ARRAY2 = Object.freeze([]);
+var DEFAULT_THREAD_ID = "DEFAULT_THREAD_ID";
+var ExternalStoreThreadManagerRuntimeCore = (_class14 = class {
+  constructor(adapter = {}, threadFactory) {;_class14.prototype.__init35.call(this);
+    this.adapter = adapter;
+    this.threadFactory = threadFactory;
+    this._mainThread = this.threadFactory(DEFAULT_THREAD_ID);
+  }
+  get threads() {
+    return _nullishCoalesce(this.adapter.threads, () => ( EMPTY_ARRAY2));
+  }
+  get archivedThreads() {
+    return _nullishCoalesce(this.adapter.archivedThreads, () => ( EMPTY_ARRAY2));
+  }
+  
+  get mainThread() {
+    return this._mainThread;
+  }
+  setAdapter(adapter) {
+    const previousAdapter = this.adapter;
+    this.adapter = adapter;
+    const newThreadId = _nullishCoalesce(adapter.threadId, () => ( DEFAULT_THREAD_ID));
+    const newThreads = _nullishCoalesce(adapter.threads, () => ( EMPTY_ARRAY2));
+    const newArchivedThreads = _nullishCoalesce(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 (_optionalChain([this, 'access', _244 => _244._mainThread, 'optionalAccess', _245 => _245.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);
+  }
+  __init35() {this._subscriptions = /* @__PURE__ */ new Set()}
+  subscribe(callback) {
+    this._subscriptions.add(callback);
+    return () => this._subscriptions.delete(callback);
+  }
+  _notifySubscribers() {
+    for (const callback of this._subscriptions) callback();
+  }
+}, _class14);
+
 // src/runtimes/external-store/getExternalStoreMessage.tsx
 var symbolInnerMessage = Symbol("innerMessage");
 var getExternalStoreMessage = (message) => {
@@ -4671,8 +4914,8 @@ var getExternalStoreMessage = (message) => {
 };
 
 // src/runtimes/external-store/ThreadMessageConverter.ts
-var ThreadMessageConverter = (_class13 = class {constructor() { _class13.prototype.__init32.call(this); }
-  __init32() {this.cache = /* @__PURE__ */ new WeakMap()}
+var ThreadMessageConverter = (_class15 = class {constructor() { _class15.prototype.__init36.call(this); }
+  __init36() {this.cache = /* @__PURE__ */ new WeakMap()}
   convertMessages(messages2, converter) {
     return messages2.map((m, idx) => {
       const cached = this.cache.get(m);
@@ -4681,7 +4924,7 @@ var ThreadMessageConverter = (_class13 = class {constructor() { _class13.prototy
       return newMessage;
     });
   }
-}, _class13);
+}, _class15);
 
 // src/runtimes/external-store/auto-status.tsx
 var AUTO_STATUS_RUNNING = Object.freeze({ type: "running" });
@@ -4767,13 +5010,13 @@ 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 && _optionalChain([messages2, 'access', _244 => _244[messages2.length - 1], 'optionalAccess', _245 => _245.role]) !== "assistant";
+  return isRunning && _optionalChain([messages2, 'access', _246 => _246[messages2.length - 1], 'optionalAccess', _247 => _247.role]) !== "assistant";
 };
-var ExternalStoreThreadRuntimeCore = (_class14 = class extends BaseThreadRuntimeCore {
-  __init33() {this.assistantOptimisticId = null}
-  __init34() {this._capabilities = {
+var ExternalStoreThreadRuntimeCore = (_class16 = class extends BaseThreadRuntimeCore {
+  __init37() {this.assistantOptimisticId = null}
+  __init38() {this._capabilities = {
     switchToBranch: false,
     edit: false,
     reload: false,
@@ -4795,41 +5038,38 @@ var ExternalStoreThreadRuntimeCore = (_class14 = class extends BaseThreadRuntime
   get adapters() {
     return this._store.adapters;
   }
-  __init35() {this.suggestions = []}
-  __init36() {this.extras = void 0}
-  __init37() {this._converter = new ThreadMessageConverter()}
+  __init39() {this.suggestions = []}
+  __init40() {this.extras = void 0}
+  __init41() {this._converter = new ThreadMessageConverter()}
   
   beginEdit(messageId) {
-    if (!this.store.onEdit)
+    if (!this._store.onEdit)
       throw new Error("Runtime does not support editing.");
     super.beginEdit(messageId);
   }
-  constructor(configProvider, store) {
-    super(configProvider);_class14.prototype.__init33.call(this);_class14.prototype.__init34.call(this);_class14.prototype.__init35.call(this);_class14.prototype.__init36.call(this);_class14.prototype.__init37.call(this);_class14.prototype.__init38.call(this);;
-    this.store = store;
-  }
-  get store() {
-    return this._store;
+  constructor(configProvider, threadId, store) {
+    super(configProvider);_class16.prototype.__init37.call(this);_class16.prototype.__init38.call(this);_class16.prototype.__init39.call(this);_class16.prototype.__init40.call(this);_class16.prototype.__init41.call(this);_class16.prototype.__init42.call(this);;
+    this.threadId = threadId;
+    this.setStore(store);
   }
-  set store(store) {
+  setStore(store) {
     if (this._store === store) return;
-    this.threadId = _nullishCoalesce(_nullishCoalesce(store.threadId, () => ( this.threadId)), () => ( generateId()));
     const isRunning = _nullishCoalesce(store.isRunning, () => ( false));
     this.isDisabled = _nullishCoalesce(store.isDisabled, () => ( false));
     const oldStore = this._store;
     this._store = store;
     this.extras = store.extras;
-    this.suggestions = _nullishCoalesce(store.suggestions, () => ( EMPTY_ARRAY2));
+    this.suggestions = _nullishCoalesce(store.suggestions, () => ( EMPTY_ARRAY3));
     this._capabilities = {
       switchToBranch: this._store.setMessages !== void 0,
       edit: this._store.onEdit !== void 0,
       reload: this._store.onReload !== void 0,
       cancel: this._store.onCancel !== void 0,
-      speech: _optionalChain([this, 'access', _249 => _249._store, 'access', _250 => _250.adapters, 'optionalAccess', _251 => _251.speech]) !== void 0,
-      unstable_copy: _optionalChain([this, 'access', _252 => _252._store, 'access', _253 => _253.unstable_capabilities, 'optionalAccess', _254 => _254.copy]) !== false,
+      speech: _optionalChain([this, 'access', _251 => _251._store, 'access', _252 => _252.adapters, 'optionalAccess', _253 => _253.speech]) !== void 0,
+      unstable_copy: _optionalChain([this, 'access', _254 => _254._store, 'access', _255 => _255.unstable_capabilities, 'optionalAccess', _256 => _256.copy]) !== false,
       // default true
-      attachments: !!_optionalChain([this, 'access', _255 => _255.store, 'access', _256 => _256.adapters, 'optionalAccess', _257 => _257.attachments]),
-      feedback: !!_optionalChain([this, 'access', _258 => _258.store, 'access', _259 => _259.adapters, 'optionalAccess', _260 => _260.feedback])
+      attachments: !!_optionalChain([this, 'access', _257 => _257._store, 'access', _258 => _258.adapters, 'optionalAccess', _259 => _259.attachments]),
+      feedback: !!_optionalChain([this, 'access', _260 => _260._store, 'access', _261 => _261.adapters, 'optionalAccess', _262 => _262.feedback])
     };
     if (oldStore) {
       if (oldStore.convertMessage !== store.convertMessage) {
@@ -4856,7 +5096,7 @@ var ExternalStoreThreadRuntimeCore = (_class14 = class extends BaseThreadRuntime
     for (let i = 0; i < messages2.length; i++) {
       const message = messages2[i];
       const parent = messages2[i - 1];
-      this.repository.addOrUpdateMessage(_nullishCoalesce(_optionalChain([parent, 'optionalAccess', _261 => _261.id]), () => ( null)), message);
+      this.repository.addOrUpdateMessage(_nullishCoalesce(_optionalChain([parent, 'optionalAccess', _263 => _263.id]), () => ( null)), message);
     }
     if (this.assistantOptimisticId) {
       this.repository.deleteMessage(this.assistantOptimisticId);
@@ -4864,7 +5104,7 @@ var ExternalStoreThreadRuntimeCore = (_class14 = class extends BaseThreadRuntime
     }
     if (hasUpcomingMessage(isRunning, messages2)) {
       this.assistantOptimisticId = this.repository.appendOptimisticMessage(
-        _nullishCoalesce(_optionalChain([messages2, 'access', _262 => _262.at, 'call', _263 => _263(-1), 'optionalAccess', _264 => _264.id]), () => ( null)),
+        _nullishCoalesce(_optionalChain([messages2, 'access', _264 => _264.at, 'call', _265 => _265(-1), 'optionalAccess', _266 => _266.id]), () => ( null)),
         {
           role: "assistant",
           content: []
@@ -4872,7 +5112,7 @@ var ExternalStoreThreadRuntimeCore = (_class14 = class extends BaseThreadRuntime
       );
     }
     this.repository.resetHead(
-      _nullishCoalesce(_nullishCoalesce(this.assistantOptimisticId, () => ( _optionalChain([messages2, 'access', _265 => _265.at, 'call', _266 => _266(-1), 'optionalAccess', _267 => _267.id]))), () => ( null))
+      _nullishCoalesce(_nullishCoalesce(this.assistantOptimisticId, () => ( _optionalChain([messages2, 'access', _267 => _267.at, 'call', _268 => _268(-1), 'optionalAccess', _269 => _269.id]))), () => ( null))
     );
     this._messages = this.repository.getMessages();
     this._notifySubscribers();
@@ -4884,7 +5124,7 @@ var ExternalStoreThreadRuntimeCore = (_class14 = class extends BaseThreadRuntime
     this.updateMessages(this.repository.getMessages());
   }
   async append(message) {
-    if (message.parentId !== (_nullishCoalesce(_optionalChain([this, 'access', _268 => _268.messages, 'access', _269 => _269.at, 'call', _270 => _270(-1), 'optionalAccess', _271 => _271.id]), () => ( null)))) {
+    if (message.parentId !== (_nullishCoalesce(_optionalChain([this, 'access', _270 => _270.messages, 'access', _271 => _271.at, 'call', _272 => _272(-1), 'optionalAccess', _273 => _273.id]), () => ( null)))) {
       if (!this._store.onEdit)
         throw new Error("Runtime does not support editing messages.");
       await this._store.onEdit(message);
@@ -4907,7 +5147,7 @@ var ExternalStoreThreadRuntimeCore = (_class14 = class extends BaseThreadRuntime
     }
     let messages2 = this.repository.getMessages();
     const previousMessage = messages2[messages2.length - 1];
-    if (_optionalChain([previousMessage, 'optionalAccess', _272 => _272.role]) === "user" && previousMessage.id === _optionalChain([messages2, 'access', _273 => _273.at, 'call', _274 => _274(-1), 'optionalAccess', _275 => _275.id])) {
+    if (_optionalChain([previousMessage, 'optionalAccess', _274 => _274.role]) === "user" && previousMessage.id === _optionalChain([messages2, 'access', _275 => _275.at, 'call', _276 => _276(-1), 'optionalAccess', _277 => _277.id])) {
       this.repository.deleteMessage(previousMessage.id);
       if (!this.composer.text.trim()) {
         this.composer.setText(getThreadMessageText(previousMessage));
@@ -4925,57 +5165,41 @@ var ExternalStoreThreadRuntimeCore = (_class14 = class extends BaseThreadRuntime
       throw new Error("Runtime does not support tool results.");
     this._store.onAddToolResult(options);
   }
-  __init38() {this.updateMessages = (messages2) => {
-    _optionalChain([this, 'access', _276 => _276._store, 'access', _277 => _277.setMessages, 'optionalCall', _278 => _278(
+  __init42() {this.updateMessages = (messages2) => {
+    _optionalChain([this, 'access', _278 => _278._store, 'access', _279 => _279.setMessages, 'optionalCall', _280 => _280(
       messages2.flatMap(getExternalStoreMessage).filter((m) => m != null)
     )]);
   }}
-}, _class14);
+}, _class16);
 
 // src/runtimes/external-store/ExternalStoreRuntimeCore.tsx
+var getThreadManagerAdapter = (store) => {
+  return {
+    threadId: store.threadId,
+    onSwitchToNewThread: store.onSwitchToNewThread,
+    onSwitchToThread: store.onSwitchToThread,
+    ..._optionalChain([store, 'access', _281 => _281.adapters, 'optionalAccess', _282 => _282.threadManager])
+  };
+};
 var ExternalStoreRuntimeCore = class extends BaseAssistantRuntimeCore {
   
+  
   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);
   }
 };
 
@@ -4983,7 +5207,7 @@ var ExternalStoreRuntimeCore = class extends BaseAssistantRuntimeCore {
 var useExternalStoreRuntime = (store) => {
   const [runtime] = _react.useState.call(void 0, () => new ExternalStoreRuntimeCore(store));
   _react.useEffect.call(void 0, () => {
-    runtime.thread.store = store;
+    runtime.setStore(store);
   });
   return _react.useMemo.call(void 0, 
     () => AssistantRuntimeImpl.create(runtime, ThreadRuntimeImpl),
@@ -5212,8 +5436,8 @@ var WebSpeechSynthesisAdapter = class {
 };
 
 // src/runtimes/attachment/SimpleImageAttachmentAdapter.ts
-var SimpleImageAttachmentAdapter = (_class15 = class {constructor() { _class15.prototype.__init39.call(this); }
-  __init39() {this.accept = "image/*"}
+var SimpleImageAttachmentAdapter = (_class17 = class {constructor() { _class17.prototype.__init43.call(this); }
+  __init43() {this.accept = "image/*"}
   async add(state) {
     return {
       id: state.file.name,
@@ -5238,7 +5462,7 @@ var SimpleImageAttachmentAdapter = (_class15 = class {constructor() { _class15.p
   }
   async remove() {
   }
-}, _class15);
+}, _class17);
 var getFileDataURL = (file) => new Promise((resolve, reject) => {
   const reader = new FileReader();
   reader.onload = () => resolve(reader.result);
@@ -5247,8 +5471,8 @@ var getFileDataURL = (file) => new Promise((resolve, reject) => {
 });
 
 // src/runtimes/attachment/SimpleTextAttachmentAdapter.ts
-var SimpleTextAttachmentAdapter = (_class16 = class {constructor() { _class16.prototype.__init40.call(this); }
-  __init40() {this.accept = "text/plain,text/html,text/markdown,text/csv,text/xml,text/json,text/css"}
+var SimpleTextAttachmentAdapter = (_class18 = class {constructor() { _class18.prototype.__init44.call(this); }
+  __init44() {this.accept = "text/plain,text/html,text/markdown,text/csv,text/xml,text/json,text/css"}
   async add(state) {
     return {
       id: state.file.name,
@@ -5275,7 +5499,7 @@ ${await getFileText(attachment.file)}
   }
   async remove() {
   }
-}, _class16);
+}, _class18);
 var getFileText = (file) => new Promise((resolve, reject) => {
   const reader = new FileReader();
   reader.onload = () => resolve(reader.result);
@@ -5376,7 +5600,7 @@ var ThreadConfigProvider = ({
 }) => {
   const hasAssistant = !!useAssistantRuntime({ 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', _279 => _279.runtime])) return configProvider;
+  if (!_optionalChain([config, 'optionalAccess', _283 => _283.runtime])) return configProvider;
   if (hasAssistant) {
     throw new Error(
       "You provided a runtime to <Thread> while simulataneously using <AssistantRuntimeProvider>. This is not allowed."
@@ -5704,7 +5928,7 @@ var AssistantMessageContent = _react.forwardRef.call(void 0, ({ components: comp
     {
       components: {
         ...componentsProp,
-        Text: _nullishCoalesce(_nullishCoalesce(_optionalChain([componentsProp, 'optionalAccess', _280 => _280.Text]), () => ( components.Text)), () => ( content_part_default.Text)),
+        Text: _nullishCoalesce(_nullishCoalesce(_optionalChain([componentsProp, 'optionalAccess', _284 => _284.Text]), () => ( components.Text)), () => ( content_part_default.Text)),
         tools: toolsComponents
       }
     }
@@ -5815,7 +6039,7 @@ var useAttachmentSrc = () => {
   const { file, src } = useAttachment((a) => {
     if (a.type !== "image") return {};
     if (a.file) return { file: a.file };
-    const src2 = _optionalChain([a, 'access', _281 => _281.content, 'optionalAccess', _282 => _282.filter, 'call', _283 => _283((c) => c.type === "image"), 'access', _284 => _284[0], 'optionalAccess', _285 => _285.image]);
+    const src2 = _optionalChain([a, 'access', _285 => _285.content, 'optionalAccess', _286 => _286.filter, 'call', _287 => _287((c) => c.type === "image"), 'access', _288 => _288[0], 'optionalAccess', _289 => _289.image]);
     if (!src2) return {};
     return { src: src2 };
   });
@@ -5959,7 +6183,7 @@ var ComposerAttachments = ({ components }) => {
     {
       components: {
         ...components,
-        Attachment: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _286 => _286.Attachment]), () => ( attachment_default))
+        Attachment: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _290 => _290.Attachment]), () => ( attachment_default))
       }
     }
   ) });
@@ -6068,8 +6292,13 @@ var ThreadWelcomeMessageStyled = withDefaults("p", {
   className: "aui-thread-welcome-message"
 });
 var ThreadWelcomeMessage = _react.forwardRef.call(void 0, ({ message: messageProp, ...rest }, ref) => {
-  const { welcome: { message = "How can I help you today?" } = {} } = useThreadConfig();
-  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ThreadWelcomeMessageStyled, { ...rest, ref, children: _nullishCoalesce(messageProp, () => ( message)) });
+  const {
+    welcome: { message } = {},
+    strings: {
+      welcome: { message: defaultMessage = "How can I help you today?" } = {}
+    } = {}
+  } = useThreadConfig();
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ThreadWelcomeMessageStyled, { ...rest, ref, children: _nullishCoalesce(_nullishCoalesce(messageProp, () => ( message)), () => ( defaultMessage)) });
 });
 ThreadWelcomeMessage.displayName = "ThreadWelcomeMessage";
 var ThreadWelcomeSuggestionContainer = withDefaults("div", {
@@ -6087,7 +6316,7 @@ var ThreadWelcomeSuggestions = () => {
   const suggestions2 = useThread((t) => t.suggestions);
   const { welcome: { suggestions } = {} } = useThreadConfig();
   const finalSuggestions = suggestions2.length ? suggestions2 : suggestions;
-  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ThreadWelcomeSuggestionContainer, { children: _optionalChain([finalSuggestions, 'optionalAccess', _287 => _287.map, 'call', _288 => _288((suggestion, idx) => {
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ThreadWelcomeSuggestionContainer, { children: _optionalChain([finalSuggestions, 'optionalAccess', _291 => _291.map, 'call', _292 => _292((suggestion, idx) => {
     const key = `${suggestion.prompt}-${idx}`;
     return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ThreadWelcomeSuggestion, { suggestion }, key);
   })]) });
@@ -6165,7 +6394,7 @@ var UserMessageContent = _react.forwardRef.call(void 0, ({ components, ...props
     {
       components: {
         ...components,
-        Text: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _289 => _289.Text]), () => ( content_part_default.Text))
+        Text: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _293 => _293.Text]), () => ( content_part_default.Text))
       }
     }
   ) });
@@ -6182,7 +6411,7 @@ var UserMessageAttachments = ({
     {
       components: {
         ...components,
-        Attachment: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _290 => _290.Attachment]), () => ( attachment_default))
+        Attachment: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _294 => _294.Attachment]), () => ( attachment_default))
       }
     }
   ) }) });
@@ -6285,10 +6514,10 @@ var ThreadMessages = ({ components, unstable_flexGrowDiv: flexGrowDiv = true, ..
       thread_exports.Messages,
       {
         components: {
-          UserMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _291 => _291.UserMessage]), () => ( user_message_default)),
-          EditComposer: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _292 => _292.EditComposer]), () => ( edit_composer_default)),
-          AssistantMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _293 => _293.AssistantMessage]), () => ( assistant_message_default)),
-          SystemMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _294 => _294.SystemMessage]), () => ( SystemMessage))
+          UserMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _295 => _295.UserMessage]), () => ( user_message_default)),
+          EditComposer: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _296 => _296.EditComposer]), () => ( edit_composer_default)),
+          AssistantMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _297 => _297.AssistantMessage]), () => ( assistant_message_default)),
+          SystemMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _298 => _298.SystemMessage]), () => ( SystemMessage))
         },
         ...rest
       }
@@ -6299,7 +6528,7 @@ var ThreadMessages = ({ components, unstable_flexGrowDiv: flexGrowDiv = true, ..
 ThreadMessages.displayName = "ThreadMessages";
 var ThreadFollowupSuggestions = () => {
   const suggestions = useThread((t) => t.suggestions);
-  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, thread_exports.If, { empty: false, running: false, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "aui-thread-followup-suggestions", children: _optionalChain([suggestions, 'optionalAccess', _295 => _295.map, 'call', _296 => _296((suggestion, idx) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, thread_exports.If, { empty: false, running: false, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "aui-thread-followup-suggestions", children: _optionalChain([suggestions, 'optionalAccess', _299 => _299.map, 'call', _300 => _300((suggestion, idx) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
     thread_exports.Suggestion,
     {
       className: "aui-thread-followup-suggestion",
@@ -6533,5 +6762,6 @@ var assistant_modal_default = Object.assign(AssistantModal, exports12);
 
 
 
-exports.ActionBarPrimitive = actionBar_exports; exports.AssistantActionBar = assistant_action_bar_default; exports.AssistantMessage = assistant_message_default; exports.AssistantModal = assistant_modal_default; exports.AssistantModalPrimitive = assistantModal_exports; exports.AssistantRuntimeProvider = AssistantRuntimeProvider; exports.AttachmentPrimitive = attachment_exports; exports.AttachmentUI = attachment_default; exports.BranchPicker = branch_picker_default; exports.BranchPickerPrimitive = branchPicker_exports; exports.Composer = composer_default; exports.ComposerAttachment = attachment_default; exports.ComposerPrimitive = composer_exports; exports.CompositeAttachmentAdapter = CompositeAttachmentAdapter; exports.ContentPart = content_part_default; exports.ContentPartPrimitive = contentPart_exports; exports.EdgeChatAdapter = EdgeChatAdapter; exports.EditComposer = edit_composer_default; exports.INTERNAL = internal_exports; exports.MessagePrimitive = message_exports; exports.SimpleImageAttachmentAdapter = SimpleImageAttachmentAdapter; exports.SimpleTextAttachmentAdapter = SimpleTextAttachmentAdapter; exports.TextContentPartProvider = TextContentPartProvider; exports.Thread = thread_default; exports.ThreadConfigProvider = ThreadConfigProvider; exports.ThreadPrimitive = thread_exports; exports.ThreadWelcome = thread_welcome_default; exports.UserActionBar = user_action_bar_default; exports.UserMessage = user_message_default; exports.UserMessageAttachment = attachment_default; exports.WebSpeechSynthesisAdapter = WebSpeechSynthesisAdapter; exports.fromCoreMessage = fromCoreMessage; exports.fromCoreMessages = fromCoreMessages; exports.fromLanguageModelMessages = fromLanguageModelMessages; exports.fromLanguageModelTools = fromLanguageModelTools; exports.getExternalStoreMessage = getExternalStoreMessage; exports.makeAssistantTool = makeAssistantTool; exports.makeAssistantToolUI = makeAssistantToolUI; exports.streamUtils = streamUtils; exports.subscribeToMainThread = subscribeToMainThread; exports.toCoreMessage = _chunkC6UZOY5Ajs.toCoreMessage; exports.toCoreMessages = _chunkC6UZOY5Ajs.toCoreMessages; exports.toLanguageModelMessages = _chunkC6UZOY5Ajs.toLanguageModelMessages; exports.toLanguageModelTools = _chunkC6UZOY5Ajs.toLanguageModelTools; exports.useActionBarCopy = useActionBarCopy; exports.useActionBarEdit = useActionBarEdit; exports.useActionBarFeedbackNegative = useActionBarFeedbackNegative; exports.useActionBarFeedbackPositive = useActionBarFeedbackPositive; exports.useActionBarReload = useActionBarReload; exports.useActionBarSpeak = useActionBarSpeak; exports.useActionBarStopSpeaking = useActionBarStopSpeaking; exports.useAppendMessage = useAppendMessage; exports.useAssistantActions = useAssistantActions; exports.useAssistantActionsStore = useAssistantActionsStore; exports.useAssistantContext = useAssistantContext; exports.useAssistantInstructions = useAssistantInstructions; exports.useAssistantRuntime = useAssistantRuntime; exports.useAssistantRuntimeStore = useAssistantRuntimeStore; exports.useAssistantTool = useAssistantTool; exports.useAssistantToolUI = useAssistantToolUI; exports.useBranchPickerCount = useBranchPickerCount; exports.useBranchPickerNext = useBranchPickerNext; exports.useBranchPickerNumber = useBranchPickerNumber; exports.useBranchPickerPrevious = useBranchPickerPrevious; exports.useComposer = useComposer; exports.useComposerAddAttachment = useComposerAddAttachment; exports.useComposerCancel = useComposerCancel; exports.useComposerContext = useComposerContext; exports.useComposerIf = useComposerIf; exports.useComposerRuntime = useComposerRuntime; exports.useComposerSend = useComposerSend; exports.useComposerStore = useComposerStore; exports.useContentPart = useContentPart; exports.useContentPartContext = useContentPartContext; exports.useContentPartDisplay = useContentPartDisplay; exports.useContentPartImage = useContentPartImage; exports.useContentPartRuntime = useContentPartRuntime; exports.useContentPartStore = useContentPartStore; exports.useContentPartText = useContentPartText; exports.useDangerousInBrowserRuntime = useDangerousInBrowserRuntime; exports.useEdgeRuntime = useEdgeRuntime; exports.useEditComposer = useEditComposer; exports.useEditComposerStore = useEditComposerStore; exports.useExternalMessageConverter = useExternalMessageConverter; exports.useExternalStoreRuntime = useExternalStoreRuntime; exports.useLocalRuntime = useLocalRuntime; exports.useMessage = useMessage; exports.useMessageContext = useMessageContext; exports.useMessageIf = useMessageIf; exports.useMessageRuntime = useMessageRuntime; exports.useMessageStore = useMessageStore; exports.useMessageUtils = useMessageUtils; exports.useMessageUtilsStore = useMessageUtilsStore; exports.useSwitchToNewThread = useSwitchToNewThread; exports.useThread = useThread; exports.useThreadActions = useThreadActions; exports.useThreadActionsStore = useThreadActionsStore; exports.useThreadComposer = useThreadComposer; exports.useThreadComposerStore = useThreadComposerStore; exports.useThreadConfig = useThreadConfig; exports.useThreadContext = useThreadContext; exports.useThreadEmpty = useThreadEmpty; exports.useThreadIf = useThreadIf; exports.useThreadMessages = useThreadMessages; exports.useThreadMessagesStore = useThreadMessagesStore; exports.useThreadModelConfig = useThreadModelConfig; exports.useThreadRuntime = useThreadRuntime; exports.useThreadRuntimeStore = useThreadRuntimeStore; exports.useThreadScrollToBottom = useThreadScrollToBottom; exports.useThreadStore = useThreadStore; exports.useThreadSuggestion = useThreadSuggestion; exports.useThreadViewport = useThreadViewport; exports.useThreadViewportStore = useThreadViewportStore; exports.useToolUIs = useToolUIs; exports.useToolUIsStore = useToolUIsStore;
+
+exports.ActionBarPrimitive = actionBar_exports; exports.AssistantActionBar = assistant_action_bar_default; exports.AssistantMessage = assistant_message_default; exports.AssistantModal = assistant_modal_default; exports.AssistantModalPrimitive = assistantModal_exports; exports.AssistantRuntimeProvider = AssistantRuntimeProvider; exports.AttachmentPrimitive = attachment_exports; exports.AttachmentUI = attachment_default; exports.BranchPicker = branch_picker_default; exports.BranchPickerPrimitive = branchPicker_exports; exports.Composer = composer_default; exports.ComposerAttachment = attachment_default; exports.ComposerPrimitive = composer_exports; exports.CompositeAttachmentAdapter = CompositeAttachmentAdapter; exports.ContentPart = content_part_default; exports.ContentPartPrimitive = contentPart_exports; exports.EdgeChatAdapter = EdgeChatAdapter; exports.EditComposer = edit_composer_default; exports.INTERNAL = internal_exports; exports.MessagePrimitive = message_exports; exports.SimpleImageAttachmentAdapter = SimpleImageAttachmentAdapter; exports.SimpleTextAttachmentAdapter = SimpleTextAttachmentAdapter; exports.TextContentPartProvider = TextContentPartProvider; exports.Thread = thread_default; exports.ThreadConfigProvider = ThreadConfigProvider; exports.ThreadPrimitive = thread_exports; exports.ThreadWelcome = thread_welcome_default; exports.UserActionBar = user_action_bar_default; exports.UserMessage = user_message_default; exports.UserMessageAttachment = attachment_default; exports.WebSpeechSynthesisAdapter = WebSpeechSynthesisAdapter; exports.fromCoreMessage = fromCoreMessage; exports.fromCoreMessages = fromCoreMessages; exports.fromLanguageModelMessages = fromLanguageModelMessages; exports.fromLanguageModelTools = fromLanguageModelTools; exports.getExternalStoreMessage = getExternalStoreMessage; exports.makeAssistantTool = makeAssistantTool; exports.makeAssistantToolUI = makeAssistantToolUI; exports.streamUtils = streamUtils; exports.subscribeToMainThread = subscribeToMainThread; exports.toCoreMessage = _chunkC6UZOY5Ajs.toCoreMessage; exports.toCoreMessages = _chunkC6UZOY5Ajs.toCoreMessages; exports.toLanguageModelMessages = _chunkC6UZOY5Ajs.toLanguageModelMessages; exports.toLanguageModelTools = _chunkC6UZOY5Ajs.toLanguageModelTools; exports.useActionBarCopy = useActionBarCopy; exports.useActionBarEdit = useActionBarEdit; exports.useActionBarFeedbackNegative = useActionBarFeedbackNegative; exports.useActionBarFeedbackPositive = useActionBarFeedbackPositive; exports.useActionBarReload = useActionBarReload; exports.useActionBarSpeak = useActionBarSpeak; exports.useActionBarStopSpeaking = useActionBarStopSpeaking; exports.useAppendMessage = useAppendMessage; exports.useAssistantActions = useAssistantActions; exports.useAssistantActionsStore = useAssistantActionsStore; exports.useAssistantContext = useAssistantContext; exports.useAssistantInstructions = useAssistantInstructions; exports.useAssistantRuntime = useAssistantRuntime; exports.useAssistantRuntimeStore = useAssistantRuntimeStore; exports.useAssistantTool = useAssistantTool; exports.useAssistantToolUI = useAssistantToolUI; exports.useBranchPickerCount = useBranchPickerCount; exports.useBranchPickerNext = useBranchPickerNext; exports.useBranchPickerNumber = useBranchPickerNumber; exports.useBranchPickerPrevious = useBranchPickerPrevious; exports.useComposer = useComposer; exports.useComposerAddAttachment = useComposerAddAttachment; exports.useComposerCancel = useComposerCancel; exports.useComposerContext = useComposerContext; exports.useComposerIf = useComposerIf; exports.useComposerRuntime = useComposerRuntime; exports.useComposerSend = useComposerSend; exports.useComposerStore = useComposerStore; exports.useContentPart = useContentPart; exports.useContentPartContext = useContentPartContext; exports.useContentPartDisplay = useContentPartDisplay; exports.useContentPartImage = useContentPartImage; exports.useContentPartRuntime = useContentPartRuntime; exports.useContentPartStore = useContentPartStore; exports.useContentPartText = useContentPartText; exports.useDangerousInBrowserRuntime = useDangerousInBrowserRuntime; exports.useEdgeRuntime = useEdgeRuntime; exports.useEditComposer = useEditComposer; exports.useEditComposerStore = useEditComposerStore; exports.useExternalMessageConverter = useExternalMessageConverter; exports.useExternalStoreRuntime = useExternalStoreRuntime; exports.useLocalRuntime = useLocalRuntime; exports.useMessage = useMessage; exports.useMessageContext = useMessageContext; exports.useMessageIf = useMessageIf; exports.useMessageRuntime = useMessageRuntime; exports.useMessageStore = useMessageStore; exports.useMessageUtils = useMessageUtils; exports.useMessageUtilsStore = useMessageUtilsStore; exports.useSwitchToNewThread = useSwitchToNewThread; exports.useThread = useThread; exports.useThreadActions = useThreadActions; exports.useThreadActionsStore = useThreadActionsStore; exports.useThreadComposer = useThreadComposer; exports.useThreadComposerStore = useThreadComposerStore; exports.useThreadConfig = useThreadConfig; exports.useThreadContext = useThreadContext; exports.useThreadEmpty = useThreadEmpty; exports.useThreadIf = useThreadIf; exports.useThreadManager = useThreadManager; exports.useThreadMessages = useThreadMessages; exports.useThreadMessagesStore = useThreadMessagesStore; exports.useThreadModelConfig = useThreadModelConfig; exports.useThreadRuntime = useThreadRuntime; exports.useThreadRuntimeStore = useThreadRuntimeStore; exports.useThreadScrollToBottom = useThreadScrollToBottom; exports.useThreadStore = useThreadStore; exports.useThreadSuggestion = useThreadSuggestion; exports.useThreadViewport = useThreadViewport; exports.useThreadViewportStore = useThreadViewportStore; exports.useToolUIs = useToolUIs; exports.useToolUIsStore = useToolUIsStore;
 //# sourceMappingURL=index.js.map