@assistant-ui/react 0.5.81 → 0.5.83

package/dist/index.mjs

@@ -10,13 +10,13 @@ import {
   toLanguageModelMessages,
   toLanguageModelTools,
   toolResultStream
-} from "./chunk-RHM73CQE.mjs";
+} from "./chunk-TWIMAOZR.mjs";
 import {
   __export
 } from "./chunk-BJPOCE4O.mjs";
 
 // src/context/providers/AssistantRuntimeProvider.tsx
-import { memo, useEffect as useEffect2, useMemo as useMemo2, useState as useState2 } from "react";
+import { memo, useEffect as useEffect3, useMemo as useMemo2, useState as useState3 } from "react";
 
 // src/context/react/AssistantContext.ts
 import { createContext } from "react";
@@ -86,6 +86,10 @@ var { useToolUIs, useToolUIsStore } = createContextStoreHook(
   useAssistantContext,
   "useToolUIs"
 );
+var { useThreadManager } = createContextStoreHook(
+  useAssistantContext,
+  "useThreadManager"
+);
 
 // src/context/stores/AssistantToolUIs.ts
 import { create } from "zustand";
@@ -120,10 +124,10 @@ var makeAssistantToolUIsStore = () => create((set) => {
 });
 
 // src/context/providers/ThreadRuntimeProvider.tsx
-import { useEffect, useMemo, useState } from "react";
+import { useEffect as useEffect2, useMemo, useState as useState2 } from "react";
 
 // src/context/react/ThreadContext.ts
-import { createContext as createContext2 } from "react";
+import { createContext as createContext2, useEffect, useState } from "react";
 var ThreadContext = createContext2(null);
 var useThreadContext = createContextHook(
   ThreadContext,
@@ -156,6 +160,15 @@ var {
   useViewport: useThreadViewport,
   useViewportStore: useThreadViewportStore
 } = createContextStoreHook(useThreadContext, "useViewport");
+function useThreadModelConfig(options) {
+  const [, rerender] = useState({});
+  const runtime = useThreadRuntime(options);
+  useEffect(() => {
+    return runtime?.unstable_on("model-config-update", () => rerender({}));
+  }, [runtime]);
+  if (!runtime) return null;
+  return runtime?.getModelConfig();
+}
 
 // src/context/stores/ThreadViewport.tsx
 import { create as create2 } from "zustand";
@@ -186,15 +199,15 @@ var writableStore = (store) => {
 import { create as create3 } from "zustand";
 import { jsx } from "react/jsx-runtime";
 var useThreadRuntimeStore2 = (runtime) => {
-  const [store] = useState(() => create3(() => runtime));
-  useEffect(() => {
+  const [store] = useState2(() => create3(() => runtime));
+  useEffect2(() => {
     writableStore(store).setState(runtime, true);
   }, [runtime, store]);
   return store;
 };
 var useThreadStore2 = (runtime) => {
-  const [store] = useState(() => create3(() => runtime.getState()));
-  useEffect(() => {
+  const [store] = useState2(() => create3(() => runtime.getState()));
+  useEffect2(() => {
     const updateState = () => writableStore(store).setState(runtime.getState(), true);
     updateState();
     return runtime.subscribe(updateState);
@@ -202,8 +215,8 @@ var useThreadStore2 = (runtime) => {
   return store;
 };
 var useThreadMessagesStore2 = (runtime) => {
-  const [store] = useState(() => create3(() => runtime.messages));
-  useEffect(() => {
+  const [store] = useState2(() => create3(() => runtime.messages));
+  useEffect2(() => {
     const updateState = () => writableStore(store).setState(runtime.messages, true);
     updateState();
     return runtime.subscribe(updateState);
@@ -211,8 +224,8 @@ var useThreadMessagesStore2 = (runtime) => {
   return store;
 };
 var useThreadComposerStore2 = (runtime) => {
-  const [store] = useState(() => create3(() => runtime.getState()));
-  useEffect(() => {
+  const [store] = useState2(() => create3(() => runtime.getState()));
+  useEffect2(() => {
     const updateState = () => writableStore(store).setState(runtime.getState(), true);
     updateState();
     return runtime.subscribe(updateState);
@@ -242,8 +255,8 @@ var ThreadRuntimeProvider = ({ children, runtime }) => {
 import { create as create4 } from "zustand";
 import { jsx as jsx2 } from "react/jsx-runtime";
 var useAssistantRuntimeStore2 = (runtime) => {
-  const [store] = useState2(() => create4(() => runtime));
-  useEffect2(() => {
+  const [store] = useState3(() => create4(() => runtime));
+  useEffect3(() => {
     writableStore(store).setState(runtime, true);
   }, [runtime, store]);
   return store;
@@ -251,22 +264,35 @@ 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);
 
 // src/context/providers/TextContentPartProvider.tsx
-import { useEffect as useEffect3, useState as useState3 } from "react";
+import { useEffect as useEffect4, useState as useState4 } from "react";
 import { create as create5 } from "zustand";
 
 // src/context/react/ContentPartContext.ts
@@ -295,6 +321,9 @@ var ContentPartRuntimeImpl = class {
     this.messageApi = messageApi;
     this.threadApi = threadApi;
   }
+  get path() {
+    return this.contentBinding.path;
+  }
   getState() {
     return this.contentBinding.getState();
   }
@@ -328,7 +357,7 @@ var RUNNING_STATUS = {
   type: "running"
 };
 var TextContentPartProvider = ({ children, text, isRunning }) => {
-  const [context] = useState3(() => {
+  const [context] = useState4(() => {
     const useContentPartRuntime2 = create5(
       // TODO
       () => new ContentPartRuntimeImpl(null, null, null)
@@ -341,7 +370,7 @@ var TextContentPartProvider = ({ children, text, isRunning }) => {
     }));
     return { useContentPartRuntime: useContentPartRuntime2, useContentPart: useContentPart2 };
   });
-  useEffect3(() => {
+  useEffect4(() => {
     const state = context.useContentPart.getState();
     const textUpdated = state.text !== text;
     const targetStatus = isRunning ? RUNNING_STATUS : COMPLETE_STATUS;
@@ -432,11 +461,11 @@ var useSwitchToNewThread = () => {
 };
 
 // src/model-config/useAssistantTool.tsx
-import { useEffect as useEffect4 } from "react";
+import { useEffect as useEffect5 } from "react";
 var useAssistantTool = (tool) => {
   const assistantRuntime = useAssistantRuntime();
   const toolUIsStore = useToolUIsStore();
-  useEffect4(() => {
+  useEffect5(() => {
     const { toolName, render, ...rest } = tool;
     const config = {
       tools: {
@@ -465,10 +494,10 @@ var makeAssistantTool = (tool) => {
 };
 
 // src/model-config/useAssistantToolUI.tsx
-import { useEffect as useEffect5 } from "react";
+import { useEffect as useEffect6 } from "react";
 var useAssistantToolUI = (tool) => {
   const toolUIsStore = useToolUIsStore();
-  useEffect5(() => {
+  useEffect6(() => {
     if (!tool) return;
     const { toolName, render } = tool;
     return toolUIsStore.getState().setToolUI(toolName, render);
@@ -486,10 +515,10 @@ var makeAssistantToolUI = (tool) => {
 };
 
 // src/model-config/useAssistantInstructions.tsx
-import { useEffect as useEffect6 } from "react";
+import { useEffect as useEffect7 } from "react";
 var useAssistantInstructions = (instruction) => {
   const assistantRuntime = useAssistantRuntime();
-  useEffect6(() => {
+  useEffect7(() => {
     const config = {
       system: instruction
     };
@@ -501,64 +530,23 @@ var useAssistantInstructions = (instruction) => {
 
 // src/primitive-hooks/actionBar/useActionBarCopy.tsx
 import { useCallback as useCallback3 } from "react";
-
-// src/utils/combined/useCombinedStore.ts
-import { useMemo as useMemo4 } from "react";
-
-// src/utils/combined/createCombinedStore.ts
-import { useSyncExternalStore } from "react";
-var createCombinedStore = (stores) => {
-  const subscribe = (callback) => {
-    const unsubscribes = stores.map((store) => store.subscribe(callback));
-    return () => {
-      for (const unsub of unsubscribes) {
-        unsub();
-      }
-    };
-  };
-  return (selector) => {
-    const getSnapshot = () => selector(...stores.map((store) => store.getState()));
-    return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-  };
-};
-
-// src/utils/combined/useCombinedStore.ts
-var useCombinedStore = (stores, selector) => {
-  const useCombined = useMemo4(() => createCombinedStore(stores), stores);
-  return useCombined(selector);
-};
-
-// src/utils/getThreadMessageText.tsx
-var getThreadMessageText = (message) => {
-  const textParts = message.content.filter(
-    (part) => part.type === "text"
-  );
-  return textParts.map((part) => part.text).join("\n\n");
-};
-
-// src/primitive-hooks/actionBar/useActionBarCopy.tsx
 var useActionBarCopy = ({
   copiedDuration = 3e3
 } = {}) => {
   const messageRuntime = useMessageRuntime();
   const composerRuntime = useComposerRuntime();
-  const messageUtilsStore = useMessageUtilsStore();
-  const hasCopyableContent = useCombinedStore(
-    [messageRuntime, composerRuntime],
-    (message, c) => {
-      return !c.isEditing && (message.role !== "assistant" || message.status.type !== "running") && message.content.some((c2) => c2.type === "text" && c2.text.length > 0);
-    }
-  );
+  const setIsCopied = useMessageUtils((s) => s.setIsCopied);
+  const hasCopyableContent = useMessage((message) => {
+    return (message.role !== "assistant" || message.status.type !== "running") && message.content.some((c) => c.type === "text" && c.text.length > 0);
+  });
   const callback = useCallback3(() => {
-    const message = messageRuntime.getState();
-    const { setIsCopied } = messageUtilsStore.getState();
     const { isEditing, text: composerValue } = composerRuntime.getState();
-    const valueToCopy = isEditing ? composerValue : getThreadMessageText(message);
+    const valueToCopy = isEditing ? composerValue : messageRuntime.unstable_getCopyText();
     navigator.clipboard.writeText(valueToCopy).then(() => {
       setIsCopied(true);
       setTimeout(() => setIsCopied(false), copiedDuration);
     });
-  }, [messageRuntime, messageUtilsStore, composerRuntime, copiedDuration]);
+  }, [messageRuntime, setIsCopied, composerRuntime, copiedDuration]);
   if (!hasCopyableContent) return null;
   return callback;
 };
@@ -577,6 +565,34 @@ var useActionBarEdit = () => {
 
 // src/primitive-hooks/actionBar/useActionBarReload.tsx
 import { useCallback as useCallback5 } from "react";
+
+// src/utils/combined/useCombinedStore.ts
+import { useMemo as useMemo4 } from "react";
+
+// src/utils/combined/createCombinedStore.ts
+import { useSyncExternalStore } from "react";
+var createCombinedStore = (stores) => {
+  const subscribe = (callback) => {
+    const unsubscribes = stores.map((store) => store.subscribe(callback));
+    return () => {
+      for (const unsub of unsubscribes) {
+        unsub();
+      }
+    };
+  };
+  return (selector) => {
+    const getSnapshot = () => selector(...stores.map((store) => store.getState()));
+    return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  };
+};
+
+// src/utils/combined/useCombinedStore.ts
+var useCombinedStore = (stores, selector) => {
+  const useCombined = useMemo4(() => createCombinedStore(stores), stores);
+  return useCombined(selector);
+};
+
+// src/primitive-hooks/actionBar/useActionBarReload.tsx
 var useActionBarReload = () => {
   const messageRuntime = useMessageRuntime();
   const threadRuntime = useThreadRuntime();
@@ -1084,7 +1100,7 @@ __export(assistantModal_exports, {
 });
 
 // src/primitives/assistantModal/AssistantModalRoot.tsx
-import { useEffect as useEffect7, useState as useState4 } from "react";
+import { useEffect as useEffect8, useState as useState5 } from "react";
 import * as PopoverPrimitive2 from "@radix-ui/react-popover";
 import { composeEventHandlers as composeEventHandlers6 } from "@radix-ui/primitive";
 
@@ -1098,10 +1114,10 @@ var useAssistantModalOpenState = ({
   defaultOpen = false,
   unstable_openOnRunStart = true
 }) => {
-  const state = useState4(defaultOpen);
+  const state = useState5(defaultOpen);
   const [, setOpen] = state;
   const threadRuntime = useThreadRuntime();
-  useEffect7(() => {
+  useEffect8(() => {
     if (!unstable_openOnRunStart) return void 0;
     return threadRuntime.unstable_on("run-start", () => {
       setOpen(true);
@@ -1434,19 +1450,19 @@ MessagePrimitiveIf.displayName = "MessagePrimitive.If";
 import { memo as memo2, useMemo as useMemo6 } from "react";
 
 // src/context/providers/ContentPartRuntimeProvider.tsx
-import { useEffect as useEffect8, useState as useState5 } from "react";
+import { useEffect as useEffect9, useState as useState6 } from "react";
 import { create as create6 } from "zustand";
 import { jsx as jsx19 } from "react/jsx-runtime";
 var useContentPartRuntimeStore = (runtime) => {
-  const [store] = useState5(() => create6(() => runtime));
-  useEffect8(() => {
+  const [store] = useState6(() => create6(() => runtime));
+  useEffect9(() => {
     writableStore(store).setState(runtime, true);
   }, [runtime, store]);
   return store;
 };
 var useContentPartStore2 = (runtime) => {
-  const [store] = useState5(() => create6(() => runtime.getState()));
-  useEffect8(() => {
+  const [store] = useState6(() => create6(() => runtime.getState()));
+  useEffect9(() => {
     const updateState = () => writableStore(store).setState(runtime.getState(), true);
     updateState();
     return runtime.subscribe(updateState);
@@ -1459,7 +1475,7 @@ var ContentPartRuntimeProvider = ({
 }) => {
   const useContentPartRuntime2 = useContentPartRuntimeStore(runtime);
   const useContentPart2 = useContentPartStore2(runtime);
-  const [context] = useState5(() => {
+  const [context] = useState6(() => {
     return { useContentPartRuntime: useContentPartRuntime2, useContentPart: useContentPart2 };
   });
   return /* @__PURE__ */ jsx19(ContentPartContext.Provider, { value: context, children });
@@ -1471,7 +1487,7 @@ import {
 } from "react";
 
 // src/utils/smooth/useSmooth.tsx
-import { useEffect as useEffect9, useMemo as useMemo5, useRef as useRef2, useState as useState7 } from "react";
+import { useEffect as useEffect10, useMemo as useMemo5, useRef as useRef2, useState as useState8 } from "react";
 import { useCallbackRef } from "@radix-ui/react-use-callback-ref";
 
 // src/utils/smooth/SmoothContext.tsx
@@ -1479,7 +1495,7 @@ import {
   createContext as createContext6,
   forwardRef as forwardRef13,
   useContext as useContext3,
-  useState as useState6
+  useState as useState7
 } from "react";
 import { create as create7 } from "zustand";
 import { jsx as jsx20 } from "react/jsx-runtime";
@@ -1491,7 +1507,7 @@ var makeSmoothContext = (initialState) => {
 var SmoothContextProvider = ({ children }) => {
   const outer = useSmoothContext({ optional: true });
   const contentPartStore = useContentPartStore();
-  const [context] = useState6(
+  const [context] = useState7(
     () => makeSmoothContext(contentPartStore.getState().status)
   );
   if (outer) return children;
@@ -1572,7 +1588,7 @@ var useSmooth = (state, smooth = false) => {
     selector: (m) => m.id
   });
   const idRef = useRef2(id);
-  const [displayedText, setDisplayedText] = useState7(text);
+  const [displayedText, setDisplayedText] = useState8(text);
   const smoothStatusStore = useSmoothStatusStore({ optional: true });
   const setText = useCallbackRef((text2) => {
     setDisplayedText(text2);
@@ -1582,17 +1598,17 @@ var useSmooth = (state, smooth = false) => {
       );
     }
   });
-  useEffect9(() => {
+  useEffect10(() => {
     if (smoothStatusStore) {
       writableStore(smoothStatusStore).setState(
         text !== state.text ? SMOOTH_STATUS : state.status
       );
     }
   }, [smoothStatusStore, text, displayedText, state.status, state.text]);
-  const [animatorRef] = useState7(
+  const [animatorRef] = useState8(
     new TextStreamAnimator(text, setText)
   );
-  useEffect9(() => {
+  useEffect10(() => {
     if (!smooth) {
       animatorRef.stop();
       return;
@@ -1608,7 +1624,7 @@ var useSmooth = (state, smooth = false) => {
     animatorRef.targetText = text;
     animatorRef.start();
   }, [setText, animatorRef, id, smooth, text]);
-  useEffect9(() => {
+  useEffect10(() => {
     return () => {
       animatorRef.stop();
     };
@@ -1656,11 +1672,22 @@ var ContentPartPrimitiveInProgress = ({ children }) => {
 };
 ContentPartPrimitiveInProgress.displayName = "ContentPartPrimitive.InProgress";
 
+// src/utils/getThreadMessageText.tsx
+var getThreadMessageText = (message) => {
+  const textParts = message.content.filter(
+    (part) => part.type === "text"
+  );
+  return textParts.map((part) => part.text).join("\n\n");
+};
+
 // src/api/AttachmentRuntime.ts
 var AttachmentRuntimeImpl = class {
   constructor(_core) {
     this._core = _core;
   }
+  get path() {
+    return this._core.path;
+  }
   getState() {
     return this._core.getState();
   }
@@ -1739,6 +1766,9 @@ var LazyMemoizeSubject = class extends BaseSubject {
     super();
     this.binding = binding;
   }
+  get path() {
+    return this.binding.path;
+  }
   _previousStateDirty = true;
   _previousState;
   getState = () => {
@@ -1785,6 +1815,9 @@ var ShallowMemoizeSubject = class extends BaseSubject {
       throw new Error("Entry not available in the store");
     this._previousState = state;
   }
+  get path() {
+    return this.binding.path;
+  }
   _previousState;
   getState = () => {
     if (!this.isConnected) this._syncState();
@@ -1851,6 +1884,9 @@ var ComposerRuntimeImpl = class {
   constructor(_core) {
     this._core = _core;
   }
+  get path() {
+    return this._core.path;
+  }
   /**
    * @deprecated Use `getState().isEditing` instead. This will be removed in 0.6.0.
    */
@@ -1936,16 +1972,21 @@ var ComposerRuntimeImpl = class {
   }
 };
 var ThreadComposerRuntimeImpl = class extends ComposerRuntimeImpl {
+  get path() {
+    return this._core.path;
+  }
   get type() {
     return "thread";
   }
   _getState;
   constructor(core) {
     const stateBinding = new LazyMemoizeSubject({
+      path: core.path,
       getState: () => getThreadComposerState(core.getState()),
       subscribe: (callback) => core.subscribe(callback)
     });
     super({
+      path: core.path,
       getState: () => core.getState(),
       subscribe: (callback) => stateBinding.subscribe(callback)
     });
@@ -1960,6 +2001,12 @@ var ThreadComposerRuntimeImpl = class extends ComposerRuntimeImpl {
   getAttachmentByIndex(idx) {
     return new ThreadComposerAttachmentRuntimeImpl(
       new ShallowMemoizeSubject({
+        path: {
+          ...this.path,
+          attachmentSource: "thread-composer",
+          attachmentSelector: { type: "index", index: idx },
+          ref: this.path.ref + `${this.path.ref}.attachments[${idx}]`
+        },
         getState: () => {
           const attachments = this.getState().attachments;
           const attachment = attachments[idx];
@@ -1979,16 +2026,21 @@ var ThreadComposerRuntimeImpl = class extends ComposerRuntimeImpl {
 var EditComposerRuntimeImpl = class extends ComposerRuntimeImpl {
   constructor(core, _beginEdit) {
     const stateBinding = new LazyMemoizeSubject({
+      path: core.path,
       getState: () => getEditComposerState(core.getState(), this._beginEdit),
       subscribe: (callback) => core.subscribe(callback)
     });
     super({
+      path: core.path,
       getState: () => core.getState(),
       subscribe: (callback) => stateBinding.subscribe(callback)
     });
     this._beginEdit = _beginEdit;
     this._getState = stateBinding.getState.bind(stateBinding);
   }
+  get path() {
+    return this._core.path;
+  }
   get type() {
     return "edit";
   }
@@ -2008,6 +2060,12 @@ var EditComposerRuntimeImpl = class extends ComposerRuntimeImpl {
   getAttachmentByIndex(idx) {
     return new EditComposerAttachmentRuntimeImpl(
       new ShallowMemoizeSubject({
+        path: {
+          ...this.path,
+          attachmentSource: "edit-composer",
+          attachmentSelector: { type: "index", index: idx },
+          ref: this.path.ref + `${this.path.ref}.attachments[${idx}]`
+        },
         getState: () => {
           const attachments = this.getState().attachments;
           const attachment = attachments[idx];
@@ -2031,6 +2089,9 @@ var NestedSubscriptionSubject = class extends BaseSubject {
     super();
     this.binding = binding;
   }
+  get path() {
+    return this.binding.path;
+  }
   getState() {
     return this.binding.getState();
   }
@@ -2097,14 +2158,23 @@ var MessageRuntimeImpl = class {
   constructor(_core, _threadBinding) {
     this._core = _core;
     this._threadBinding = _threadBinding;
+    this.composer = new EditComposerRuntimeImpl(
+      new NestedSubscriptionSubject({
+        path: {
+          ...this.path,
+          ref: this.path.ref + `${this.path.ref}.composer`,
+          composerSource: "edit"
+        },
+        getState: () => this._threadBinding.getState().getEditComposer(this._core.getState().id),
+        subscribe: (callback) => this._threadBinding.subscribe(callback)
+      }),
+      () => this._threadBinding.getState().beginEdit(this._core.getState().id)
+    );
   }
-  composer = new EditComposerRuntimeImpl(
-    new NestedSubscriptionSubject({
-      getState: () => this._threadBinding.getState().getEditComposer(this._core.getState().id),
-      subscribe: (callback) => this._threadBinding.subscribe(callback)
-    }),
-    () => this._threadBinding.getState().beginEdit(this._core.getState().id)
-  );
+  get path() {
+    return this._core.path;
+  }
+  composer;
   getState() {
     return this._core.getState();
   }
@@ -2160,13 +2230,21 @@ var MessageRuntimeImpl = class {
     if (!targetBranch) throw new Error("Branch not found");
     this._threadBinding.getState().switchToBranch(targetBranch);
   }
+  unstable_getCopyText() {
+    return getThreadMessageText(this.getState());
+  }
   subscribe(callback) {
     return this._core.subscribe(callback);
   }
   getContentPartByIndex(idx) {
-    if (idx < 0) throw new Error("Message index must be >= 0");
+    if (idx < 0) throw new Error("Content part index must be >= 0");
     return new ContentPartRuntimeImpl(
       new ShallowMemoizeSubject({
+        path: {
+          ...this.path,
+          ref: this.path.ref + `${this.path.ref}.content[${idx}]`,
+          contentPartSelector: { type: "index", index: idx }
+        },
         getState: () => {
           return getContentPartState(this.getState(), idx);
         },
@@ -2176,9 +2254,37 @@ var MessageRuntimeImpl = class {
       this._threadBinding
     );
   }
+  getContentPartByToolCallId(toolCallId) {
+    return new ContentPartRuntimeImpl(
+      new ShallowMemoizeSubject({
+        path: {
+          ...this.path,
+          ref: this.path.ref + `${this.path.ref}.content[toolCallId=${JSON.stringify(toolCallId)}]`,
+          contentPartSelector: { type: "toolCallId", toolCallId }
+        },
+        getState: () => {
+          const state = this._core.getState();
+          const idx = state.content.findIndex(
+            (part) => part.type === "tool-call" && part.toolCallId === toolCallId
+          );
+          if (idx === -1) return SKIP_UPDATE;
+          return getContentPartState(state, idx);
+        },
+        subscribe: (callback) => this._core.subscribe(callback)
+      }),
+      this._core,
+      this._threadBinding
+    );
+  }
   getAttachmentByIndex(idx) {
     return new MessageAttachmentRuntimeImpl(
       new ShallowMemoizeSubject({
+        path: {
+          ...this.path,
+          ref: this.path.ref + `${this.path.ref}.attachments[${idx}]`,
+          attachmentSource: "message",
+          attachmentSelector: { type: "index", index: idx }
+        },
         getState: () => {
           const attachments = this.getState().attachments;
           const attachment = attachments?.[idx];
@@ -2285,22 +2391,22 @@ import { memo as memo3, useMemo as useMemo8 } from "react";
 
 // src/context/providers/AttachmentRuntimeProvider.tsx
 import {
-  useEffect as useEffect10,
+  useEffect as useEffect11,
   useMemo as useMemo7,
-  useState as useState8
+  useState as useState9
 } from "react";
 import { create as create8 } from "zustand";
 import { jsx as jsx24 } from "react/jsx-runtime";
 var useAttachmentRuntimeStore = (runtime) => {
-  const [store] = useState8(() => create8(() => runtime));
-  useEffect10(() => {
+  const [store] = useState9(() => create8(() => runtime));
+  useEffect11(() => {
     writableStore(store).setState(runtime, true);
   }, [runtime, store]);
   return store;
 };
 var useAttachmentStore = (runtime) => {
-  const [store] = useState8(() => create8(() => runtime.getState()));
-  useEffect10(() => {
+  const [store] = useState9(() => create8(() => runtime.getState()));
+  useEffect11(() => {
     const updateState = () => writableStore(store).setState(runtime.getState(), true);
     updateState();
     return runtime.subscribe(updateState);
@@ -2426,7 +2532,7 @@ import { Slot } from "@radix-ui/react-slot";
 import {
   forwardRef as forwardRef18,
   useCallback as useCallback20,
-  useEffect as useEffect12,
+  useEffect as useEffect13,
   useRef as useRef3
 } from "react";
 import TextareaAutosize from "react-textarea-autosize";
@@ -2434,11 +2540,11 @@ import { useEscapeKeydown as useEscapeKeydown2 } from "@radix-ui/react-use-escap
 
 // src/utils/hooks/useOnScrollToBottom.tsx
 import { useCallbackRef as useCallbackRef2 } from "@radix-ui/react-use-callback-ref";
-import { useEffect as useEffect11 } from "react";
+import { useEffect as useEffect12 } from "react";
 var useOnScrollToBottom = (callback) => {
   const callbackRef = useCallbackRef2(callback);
   const onScrollToBottom = useThreadViewport((vp) => vp.onScrollToBottom);
-  useEffect11(() => {
+  useEffect12(() => {
     return onScrollToBottom(callbackRef);
   }, [onScrollToBottom, callbackRef]);
 };
@@ -2497,18 +2603,18 @@ var ComposerPrimitiveInput = forwardRef18(
         textareaRef.current.value.length
       );
     }, [autoFocusEnabled]);
-    useEffect12(() => focus2(), [focus2]);
+    useEffect13(() => focus2(), [focus2]);
     useOnScrollToBottom(() => {
       if (composerRuntime.type === "thread" && unstable_focusOnScrollToBottom) {
         focus2();
       }
     });
-    useEffect12(() => {
+    useEffect13(() => {
       if (composerRuntime.type !== "thread" || !unstable_focusOnRunStart)
         return void 0;
       return threadRuntime.unstable_on("run-start", focus2);
     }, [unstable_focusOnRunStart]);
-    useEffect12(() => {
+    useEffect13(() => {
       if (composerRuntime.type !== "thread" || !unstable_focusOnThreadSwitched)
         return void 0;
       return threadRuntime.unstable_on("switched-to", focus2);
@@ -2665,7 +2771,7 @@ import { forwardRef as forwardRef20 } from "react";
 
 // src/primitive-hooks/thread/useThreadViewportAutoScroll.tsx
 import { useComposedRefs as useComposedRefs3 } from "@radix-ui/react-compose-refs";
-import { useEffect as useEffect13, useRef as useRef4 } from "react";
+import { useEffect as useEffect14, useRef as useRef4 } from "react";
 
 // src/utils/hooks/useOnResizeContent.tsx
 import { useCallbackRef as useCallbackRef3 } from "@radix-ui/react-use-callback-ref";
@@ -2757,7 +2863,7 @@ var useThreadViewportAutoScroll = ({
     scrollToBottom("auto");
   });
   const threadRuntime = useThreadRuntime();
-  useEffect13(() => {
+  useEffect14(() => {
     if (!unstable_scrollToBottomOnRunStart) return void 0;
     return threadRuntime.unstable_on("run-start", focus);
   }, [unstable_scrollToBottomOnRunStart]);
@@ -2779,7 +2885,7 @@ ThreadPrimitiveViewport.displayName = "ThreadPrimitive.Viewport";
 import { memo as memo5, useMemo as useMemo10 } from "react";
 
 // src/context/providers/MessageRuntimeProvider.tsx
-import { useEffect as useEffect14, useState as useState9 } from "react";
+import { useEffect as useEffect15, useState as useState10 } from "react";
 import { create as create10 } from "zustand";
 
 // src/context/stores/MessageUtils.ts
@@ -2800,15 +2906,15 @@ var makeMessageUtilsStore = () => create9((set) => {
 // src/context/providers/MessageRuntimeProvider.tsx
 import { jsx as jsx32 } from "react/jsx-runtime";
 var useMessageRuntimeStore = (runtime) => {
-  const [store] = useState9(() => create10(() => runtime));
-  useEffect14(() => {
+  const [store] = useState10(() => create10(() => runtime));
+  useEffect15(() => {
     writableStore(store).setState(runtime, true);
   }, [runtime, store]);
   return store;
 };
 var useMessageStore2 = (runtime) => {
-  const [store] = useState9(() => create10(() => runtime.getState()));
-  useEffect14(() => {
+  const [store] = useState10(() => create10(() => runtime.getState()));
+  useEffect15(() => {
     const updateState = () => writableStore(store).setState(runtime.getState(), true);
     updateState();
     return runtime.subscribe(updateState);
@@ -2816,13 +2922,13 @@ var useMessageStore2 = (runtime) => {
   return store;
 };
 var useMessageUtilsStore2 = () => {
-  const [store] = useState9(() => makeMessageUtilsStore());
+  const [store] = useState10(() => makeMessageUtilsStore());
   return store;
 };
 var useEditComposerStore2 = (useMessageRuntime2) => {
   const runtime = useMessageRuntime2.getState().composer;
-  const [store] = useState9(() => create10(() => runtime.getState()));
-  useEffect14(() => {
+  const [store] = useState10(() => create10(() => runtime.getState()));
+  useEffect15(() => {
     const updateState = () => writableStore(store).setState(runtime.getState());
     updateState();
     return runtime.subscribe(updateState);
@@ -2837,7 +2943,7 @@ var MessageRuntimeProvider = ({
   const useMessage2 = useMessageStore2(runtime);
   const useMessageUtils2 = useMessageUtilsStore2();
   const useEditComposer2 = useEditComposerStore2(useMessageRuntime2);
-  const [context] = useState9(() => {
+  const [context] = useState10(() => {
     return { useMessageRuntime: useMessageRuntime2, useMessage: useMessage2, useMessageUtils: useMessageUtils2, useEditComposer: useEditComposer2 };
   });
   return /* @__PURE__ */ jsx32(MessageContext.Provider, { value: context, children });
@@ -2929,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();
@@ -2944,29 +3050,44 @@ var subscribeToMainThread = (runtime, callback) => {
 };
 
 // src/runtimes/local/useLocalRuntime.tsx
-import { useInsertionEffect, useMemo as useMemo11, useState as useState11 } 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
@@ -3102,20 +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);
-    return () => {
-      this._providers.delete(provider);
-    };
-  }
-};
-
 // src/utils/idUtils.tsx
 import { customAlphabet } from "nanoid/non-secure";
 var generateId = customAlphabet(
@@ -3495,7 +3602,9 @@ var getThreadState = (runtime) => {
   });
 };
 var ThreadRuntimeImpl = class {
-  // public path = "assistant.threads[main]"; // TODO
+  get path() {
+    return this._threadBinding.path;
+  }
   /**
    * @deprecated Use `getState().threadId` instead. This will be removed in 0.6.0.
    */
@@ -3550,22 +3659,30 @@ var ThreadRuntimeImpl = class {
   _threadBinding;
   constructor(threadBinding) {
     const stateBinding = new LazyMemoizeSubject({
+      path: threadBinding.path,
       getState: () => getThreadState(threadBinding.getState()),
       subscribe: (callback) => threadBinding.subscribe(callback)
     });
     this._threadBinding = {
+      path: threadBinding.path,
       getState: () => threadBinding.getState(),
       getStateState: () => stateBinding.getState(),
       outerSubscribe: (callback) => threadBinding.outerSubscribe(callback),
       subscribe: (callback) => threadBinding.subscribe(callback)
     };
+    this.composer = new ThreadComposerRuntimeImpl(
+      new NestedSubscriptionSubject({
+        path: {
+          ...this.path,
+          ref: this.path.ref + `${this.path.ref}.composer`,
+          composerSource: "thread"
+        },
+        getState: () => this._threadBinding.getState().composer,
+        subscribe: (callback) => this._threadBinding.subscribe(callback)
+      })
+    );
   }
-  composer = new ThreadComposerRuntimeImpl(
-    new NestedSubscriptionSubject({
-      getState: () => this._threadBinding.getState().composer,
-      subscribe: (callback) => this._threadBinding.subscribe(callback)
-    })
-  );
+  composer;
   getState() {
     return this._threadBinding.getStateState();
   }
@@ -3643,20 +3760,49 @@ var ThreadRuntimeImpl = class {
   }
   getMesssageByIndex(idx) {
     if (idx < 0) throw new Error("Message index must be >= 0");
+    return this._getMessageRuntime(
+      {
+        ...this.path,
+        ref: this.path.ref + `${this.path.ref}.messages[${idx}]`,
+        messageSelector: { type: "index", index: idx }
+      },
+      () => {
+        const messages2 = this._threadBinding.getState().messages;
+        const message = messages2[idx];
+        if (!message) return void 0;
+        return {
+          message,
+          parentId: messages2[idx - 1]?.id ?? null
+        };
+      }
+    );
+  }
+  getMesssageById(messageId) {
+    return this._getMessageRuntime(
+      {
+        ...this.path,
+        ref: this.path.ref + `${this.path.ref}.messages[messageId=${JSON.stringify(messageId)}]`,
+        messageSelector: { type: "messageId", messageId }
+      },
+      () => this._threadBinding.getState().getMessageById(messageId)
+    );
+  }
+  _getMessageRuntime(path, callback) {
     return new MessageRuntimeImpl(
       new ShallowMemoizeSubject({
+        path,
         getState: () => {
-          const { messages: messages2, speech: speechState } = this.getState();
-          const message = messages2[idx];
-          if (!message) return SKIP_UPDATE;
+          const { message, parentId } = callback() ?? {};
+          const { messages: messages2, speech: speechState } = this._threadBinding.getState();
+          if (!message || parentId === void 0) return SKIP_UPDATE;
           const thread = this._threadBinding.getState();
           const branches = thread.getBranches(message.id);
           const submittedFeedback = thread.getSubmittedFeedback(message.id);
           return {
             ...message,
             message,
-            isLast: idx === messages2.length - 1,
-            parentId: messages2[idx - 1]?.id ?? null,
+            isLast: messages2.at(-1)?.id === message.id,
+            parentId,
             branches,
             branchNumber: branches.indexOf(message.id) + 1,
             branchCount: branches.length,
@@ -3664,7 +3810,7 @@ var ThreadRuntimeImpl = class {
             submittedFeedback
           };
         },
-        subscribe: (callback) => this._threadBinding.subscribe(callback)
+        subscribe: (callback2) => this._threadBinding.subscribe(callback2)
       }),
       this._threadBinding
     );
@@ -3674,6 +3820,7 @@ var ThreadRuntimeImpl = class {
     let subject = this._eventListenerNestedSubscriptions.get(event);
     if (!subject) {
       subject = new NestedSubscriptionSubject({
+        path: this.path,
         getState: () => ({
           subscribe: (callback2) => this._threadBinding.getState().unstable_on(event, callback2)
         }),
@@ -3685,43 +3832,94 @@ 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);
   }
-  // TODO events for thread switching
   /**
    * @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 createThreadRuntime(_core, CustomThreadRuntime = ThreadRuntimeImpl) {
+  static createMainThreadRuntime(_core, CustomThreadRuntime = ThreadRuntimeImpl) {
     return new CustomThreadRuntime(
       new NestedSubscriptionSubject({
-        getState: () => _core.thread,
-        subscribe: (callback) => _core.subscribe(callback)
+        path: {
+          ref: "threads.main",
+          threadSelector: { type: "main" }
+        },
+        getState: () => _core.threadManager.mainThread,
+        subscribe: (callback) => _core.threadManager.subscribe(callback)
       })
     );
   }
   static create(_core, CustomThreadRuntime = ThreadRuntimeImpl) {
     return new _AssistantRuntimeImpl(
       _core,
-      _AssistantRuntimeImpl.createThreadRuntime(_core, CustomThreadRuntime)
+      _AssistantRuntimeImpl.createMainThreadRuntime(_core, CustomThreadRuntime)
     );
   }
 };
@@ -3893,7 +4091,7 @@ var streamUtils = {
 };
 
 // src/runtimes/edge/useEdgeRuntime.ts
-import { useState as useState10 } from "react";
+import { useState as useState11 } from "react";
 
 // src/runtimes/edge/streams/assistantDecoderStream.ts
 function assistantDecoderStream() {
@@ -4074,7 +4272,7 @@ var splitLocalRuntimeOptions = (options) => {
 // src/runtimes/edge/useEdgeRuntime.ts
 var useEdgeRuntime = (options) => {
   const { localRuntimeOptions, otherOptions } = splitLocalRuntimeOptions(options);
-  const [adapter] = useState10(() => new EdgeChatAdapter(otherOptions));
+  const [adapter] = useState11(() => new EdgeChatAdapter(otherOptions));
   return useLocalRuntime(adapter, localRuntimeOptions);
 };
 
@@ -4153,6 +4351,9 @@ var BaseThreadRuntimeCore = class {
     );
     this._notifySubscribers();
   }
+  getMessageById(messageId) {
+    return this.repository.getMessage(messageId);
+  }
   getBranches(messageId) {
     return this.repository.getBranches(messageId);
   }
@@ -4191,7 +4392,7 @@ var BaseThreadRuntimeCore = class {
     if (!adapter) throw new Error("Speech adapter not configured");
     const { message } = this.repository.getMessage(messageId);
     this._stopSpeaking?.();
-    const utterance = adapter.speak(message);
+    const utterance = adapter.speak(getThreadMessageText(message));
     const unsub = utterance.subscribe(() => {
       if (utterance.status.type === "ended") {
         this._stopSpeaking = void 0;
@@ -4224,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]));
@@ -4239,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,
@@ -4264,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;
@@ -4353,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({
@@ -4371,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(),
@@ -4444,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.switchToNewThread();
+    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");
+  }
+  _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)
+    );
   }
 };
 
@@ -4497,21 +4800,113 @@ var LocalRuntimeImpl = class _LocalRuntimeImpl extends AssistantRuntimeImpl {
   static create(_core) {
     return new _LocalRuntimeImpl(
       _core,
-      AssistantRuntimeImpl.createThreadRuntime(_core, ThreadRuntimeImpl)
+      AssistantRuntimeImpl.createMainThreadRuntime(_core, ThreadRuntimeImpl)
     );
   }
 };
 var useLocalRuntime = (adapter, options = {}) => {
-  const [runtime] = useState11(() => 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 useEffect15, useMemo as useMemo12, useState as useState12 } 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");
@@ -4616,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";
 };
@@ -4649,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;
-  }
-  get store() {
-    return this._store;
+    this.threadId = threadId;
+    this.setStore(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,
@@ -4677,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) {
@@ -4782,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] = useState12(() => new ExternalStoreRuntimeCore(store));
-  useEffect15(() => {
-    runtime.thread.store = store;
+  const [runtime] = useState13(() => new ExternalStoreRuntimeCore(store));
+  useEffect17(() => {
+    runtime.setStore(store);
   });
   return useMemo12(
     () => AssistantRuntimeImpl.create(runtime, ThreadRuntimeImpl),
@@ -4987,7 +5363,7 @@ var shallowArrayEqual = (a, b) => {
 };
 
 // src/runtimes/dangerous-in-browser/useDangerousInBrowserRuntime.ts
-import { useState as useState13 } from "react";
+import { useState as useState14 } from "react";
 
 // src/runtimes/dangerous-in-browser/DangerousInBrowserAdapter.ts
 var DangerousInBrowserAdapter = class {
@@ -5016,14 +5392,13 @@ var DangerousInBrowserAdapter = class {
 // src/runtimes/dangerous-in-browser/useDangerousInBrowserRuntime.ts
 var useDangerousInBrowserRuntime = (options) => {
   const { localRuntimeOptions, otherOptions } = splitLocalRuntimeOptions(options);
-  const [adapter] = useState13(() => new DangerousInBrowserAdapter(otherOptions));
+  const [adapter] = useState14(() => new DangerousInBrowserAdapter(otherOptions));
   return useLocalRuntime(adapter, localRuntimeOptions);
 };
 
 // src/runtimes/speech/WebSpeechSynthesisAdapter.ts
 var WebSpeechSynthesisAdapter = class {
-  speak(message) {
-    const text = getThreadMessageText(message);
+  speak(text) {
     const utterance = new SpeechSynthesisUtterance(text);
     const subscribers = /* @__PURE__ */ new Set();
     const handleEnd = (reason, error) => {
@@ -5603,8 +5978,8 @@ CircleStopIcon.displayName = "CircleStopIcon";
 // src/ui/attachment.tsx
 import {
   forwardRef as forwardRef28,
-  useEffect as useEffect16,
-  useState as useState14
+  useEffect as useEffect18,
+  useState as useState15
 } from "react";
 import { CircleXIcon, FileIcon } from "lucide-react";
 
@@ -5647,8 +6022,8 @@ var AttachmentRoot = withDefaults(attachment_exports.Root, {
 });
 AttachmentRoot.displayName = "AttachmentRoot";
 var useFileSrc = (file) => {
-  const [src, setSrc] = useState14(void 0);
-  useEffect16(() => {
+  const [src, setSrc] = useState15(void 0);
+  useEffect18(() => {
     if (!file) {
       setSrc(void 0);
       return;
@@ -5672,7 +6047,7 @@ var useAttachmentSrc = () => {
   return useFileSrc(file) ?? src;
 };
 var AttachmentPreview = ({ src }) => {
-  const [isLoaded, setIsLoaded] = useState14(false);
+  const [isLoaded, setIsLoaded] = useState15(false);
   return (
     // eslint-disable-next-line @next/next/no-img-element
     /* @__PURE__ */ jsx46(
@@ -5918,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", {
@@ -6371,8 +6751,10 @@ export {
   useThreadContext,
   useThreadEmpty,
   useThreadIf,
+  useThreadManager,
   useThreadMessages,
   useThreadMessagesStore,
+  useThreadModelConfig,
   useThreadRuntime,
   useThreadRuntimeStore,
   useThreadScrollToBottom,