@assistant-ui/react 0.5.82 → 0.5.84

package/dist/index.mjs

@@ -86,6 +86,10 @@ var { useToolUIs, useToolUIsStore } = createContextStoreHook(
   useAssistantContext,
   "useToolUIs"
 );
+var { useThreadManager } = createContextStoreHook(
+  useAssistantContext,
+  "useThreadManager"
+);
 
 // src/context/stores/AssistantToolUIs.ts
 import { create } from "zustand";
@@ -260,16 +264,29 @@ var useAssistantRuntimeStore2 = (runtime) => {
 var useAssistantToolUIsStore = () => {
   return useMemo2(() => makeAssistantToolUIsStore(), []);
 };
+var useThreadManagerStore = (runtime) => {
+  const [store] = useState3(
+    () => create4(() => runtime.threadManager.getState())
+  );
+  useEffect3(() => {
+    const updateState = () => writableStore(store).setState(runtime.threadManager.getState(), true);
+    updateState();
+    return runtime.threadManager.subscribe(updateState);
+  }, [runtime, store]);
+  return store;
+};
 var AssistantRuntimeProviderImpl = ({ children, runtime }) => {
   const useAssistantRuntime2 = useAssistantRuntimeStore2(runtime);
   const useToolUIs2 = useAssistantToolUIsStore();
+  const useThreadManager2 = useThreadManagerStore(runtime);
   const context = useMemo2(() => {
     return {
       useToolUIs: useToolUIs2,
       useAssistantRuntime: useAssistantRuntime2,
-      useAssistantActions: useAssistantRuntime2
+      useAssistantActions: useAssistantRuntime2,
+      useThreadManager: useThreadManager2
     };
-  }, [useAssistantRuntime2, useToolUIs2]);
+  }, [useAssistantRuntime2, useToolUIs2, useThreadManager2]);
   return /* @__PURE__ */ jsx2(AssistantContext.Provider, { value: context, children: /* @__PURE__ */ jsx2(ThreadRuntimeProvider, { runtime: runtime.thread, children }) });
 };
 var AssistantRuntimeProvider = memo(AssistantRuntimeProviderImpl);
@@ -448,22 +465,20 @@ import { useEffect as useEffect5 } from "react";
 var useAssistantTool = (tool) => {
   const assistantRuntime = useAssistantRuntime();
   const toolUIsStore = useToolUIsStore();
+  useEffect5(() => {
+    return tool.render ? toolUIsStore.getState().setToolUI(tool.toolName, tool.render) : void 0;
+  }, [toolUIsStore, tool.toolName, tool.render]);
   useEffect5(() => {
     const { toolName, render, ...rest } = tool;
     const config = {
       tools: {
-        [tool.toolName]: rest
+        [toolName]: rest
       }
     };
-    const unsub1 = assistantRuntime.registerModelConfigProvider({
+    return assistantRuntime.registerModelConfigProvider({
       getModelConfig: () => config
     });
-    const unsub2 = render ? toolUIsStore.getState().setToolUI(toolName, render) : void 0;
-    return () => {
-      unsub1();
-      unsub2?.();
-    };
-  }, [assistantRuntime, toolUIsStore, tool]);
+  }, [assistantRuntime, tool]);
 };
 
 // src/model-config/makeAssistantTool.tsx
@@ -482,9 +497,8 @@ var useAssistantToolUI = (tool) => {
   const toolUIsStore = useToolUIsStore();
   useEffect6(() => {
     if (!tool) return;
-    const { toolName, render } = tool;
-    return toolUIsStore.getState().setToolUI(toolName, render);
-  }, [toolUIsStore, tool]);
+    return toolUIsStore.getState().setToolUI(tool.toolName, tool.render);
+  }, [toolUIsStore, tool?.toolName, tool?.render]);
 };
 
 // src/model-config/makeAssistantToolUI.tsx
@@ -511,8 +525,22 @@ var useAssistantInstructions = (instruction) => {
   }, [assistantRuntime, instruction]);
 };
 
+// src/model-config/useInlineRender.tsx
+import { useCallback as useCallback3, useEffect as useEffect8, useState as useState5 } from "react";
+import { create as create6 } from "zustand";
+var useInlineRender = (toolUI) => {
+  const [useToolUI] = useState5(() => create6(() => toolUI));
+  useEffect8(() => {
+    useToolUI.setState(toolUI);
+  });
+  return useCallback3((args) => {
+    const toolUI2 = useToolUI();
+    return toolUI2(args);
+  }, []);
+};
+
 // src/primitive-hooks/actionBar/useActionBarCopy.tsx
-import { useCallback as useCallback3 } from "react";
+import { useCallback as useCallback4 } from "react";
 var useActionBarCopy = ({
   copiedDuration = 3e3
 } = {}) => {
@@ -522,7 +550,7 @@ var useActionBarCopy = ({
   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 callback = useCallback4(() => {
     const { isEditing, text: composerValue } = composerRuntime.getState();
     const valueToCopy = isEditing ? composerValue : messageRuntime.unstable_getCopyText();
     navigator.clipboard.writeText(valueToCopy).then(() => {
@@ -535,11 +563,11 @@ var useActionBarCopy = ({
 };
 
 // src/primitive-hooks/actionBar/useActionBarEdit.tsx
-import { useCallback as useCallback4 } from "react";
+import { useCallback as useCallback5 } from "react";
 var useActionBarEdit = () => {
   const messageRuntime = useMessageRuntime();
   const disabled = useEditComposer((c) => c.isEditing);
-  const callback = useCallback4(() => {
+  const callback = useCallback5(() => {
     messageRuntime.composer.beginEdit();
   }, [messageRuntime]);
   if (disabled) return null;
@@ -547,7 +575,7 @@ var useActionBarEdit = () => {
 };
 
 // src/primitive-hooks/actionBar/useActionBarReload.tsx
-import { useCallback as useCallback5 } from "react";
+import { useCallback as useCallback6 } from "react";
 
 // src/utils/combined/useCombinedStore.ts
 import { useMemo as useMemo4 } from "react";
@@ -583,7 +611,7 @@ var useActionBarReload = () => {
     [threadRuntime, messageRuntime],
     (t, m) => t.isRunning || t.isDisabled || m.role !== "assistant"
   );
-  const callback = useCallback5(() => {
+  const callback = useCallback6(() => {
     messageRuntime.reload();
   }, [messageRuntime]);
   if (disabled) return null;
@@ -591,10 +619,10 @@ var useActionBarReload = () => {
 };
 
 // src/primitive-hooks/actionBar/useActionBarSpeak.tsx
-import { useCallback as useCallback6 } from "react";
+import { useCallback as useCallback7 } from "react";
 var useActionBarSpeak = () => {
   const messageRunime = useMessageRuntime();
-  const callback = useCallback6(async () => {
+  const callback = useCallback7(async () => {
     messageRunime.speak();
   }, [messageRunime]);
   const hasSpeakableContent = useMessage((m) => {
@@ -605,11 +633,11 @@ var useActionBarSpeak = () => {
 };
 
 // src/primitive-hooks/actionBar/useActionBarStopSpeaking.tsx
-import { useCallback as useCallback7 } from "react";
+import { useCallback as useCallback8 } from "react";
 var useActionBarStopSpeaking = () => {
   const messageRuntime = useMessageRuntime();
   const isSpeaking = useMessage((u) => u.speech != null);
-  const callback = useCallback7(async () => {
+  const callback = useCallback8(async () => {
     messageRuntime.stopSpeaking();
   }, [messageRuntime]);
   if (!isSpeaking) return null;
@@ -617,20 +645,20 @@ var useActionBarStopSpeaking = () => {
 };
 
 // src/primitive-hooks/actionBar/useActionBarFeedbackPositive.tsx
-import { useCallback as useCallback8 } from "react";
+import { useCallback as useCallback9 } from "react";
 var useActionBarFeedbackPositive = () => {
   const messageRuntime = useMessageRuntime();
-  const callback = useCallback8(() => {
+  const callback = useCallback9(() => {
     messageRuntime.submitFeedback({ type: "positive" });
   }, [messageRuntime]);
   return callback;
 };
 
 // src/primitive-hooks/actionBar/useActionBarFeedbackNegative.tsx
-import { useCallback as useCallback9 } from "react";
+import { useCallback as useCallback10 } from "react";
 var useActionBarFeedbackNegative = () => {
   const messageRuntime = useMessageRuntime();
-  const callback = useCallback9(() => {
+  const callback = useCallback10(() => {
     messageRuntime.submitFeedback({ type: "negative" });
   }, [messageRuntime]);
   return callback;
@@ -643,11 +671,11 @@ var useBranchPickerCount = () => {
 };
 
 // src/primitive-hooks/branchPicker/useBranchPickerNext.tsx
-import { useCallback as useCallback10 } from "react";
+import { useCallback as useCallback11 } from "react";
 var useBranchPickerNext = () => {
   const messageRuntime = useMessageRuntime();
   const disabled = useMessage((m) => m.branchNumber >= m.branchCount);
-  const callback = useCallback10(() => {
+  const callback = useCallback11(() => {
     messageRuntime.switchToBranch({ position: "next" });
   }, [messageRuntime]);
   if (disabled) return null;
@@ -661,11 +689,11 @@ var useBranchPickerNumber = () => {
 };
 
 // src/primitive-hooks/branchPicker/useBranchPickerPrevious.tsx
-import { useCallback as useCallback11 } from "react";
+import { useCallback as useCallback12 } from "react";
 var useBranchPickerPrevious = () => {
   const messageRuntime = useMessageRuntime();
   const disabled = useMessage((m) => m.branchNumber <= 1);
-  const callback = useCallback11(() => {
+  const callback = useCallback12(() => {
     messageRuntime.switchToBranch({ position: "previous" });
   }, [messageRuntime]);
   if (disabled) return null;
@@ -673,11 +701,11 @@ var useBranchPickerPrevious = () => {
 };
 
 // src/primitive-hooks/composer/useComposerCancel.tsx
-import { useCallback as useCallback12 } from "react";
+import { useCallback as useCallback13 } from "react";
 var useComposerCancel = () => {
   const composerRuntime = useComposerRuntime();
   const disabled = useComposer((c) => !c.canCancel);
-  const callback = useCallback12(() => {
+  const callback = useCallback13(() => {
     composerRuntime.cancel();
   }, [composerRuntime]);
   if (disabled) return null;
@@ -694,7 +722,7 @@ var useComposerIf = (props) => {
 };
 
 // src/primitive-hooks/composer/useComposerSend.tsx
-import { useCallback as useCallback13 } from "react";
+import { useCallback as useCallback14 } from "react";
 var useComposerSend = () => {
   const composerRuntime = useComposerRuntime();
   const threadRuntime = useThreadRuntime();
@@ -702,7 +730,7 @@ var useComposerSend = () => {
     [threadRuntime, composerRuntime],
     (t, c) => t.isRunning || !c.isEditing || c.isEmpty
   );
-  const callback = useCallback13(() => {
+  const callback = useCallback14(() => {
     if (!composerRuntime.getState().isEditing) return;
     composerRuntime.send();
   }, [threadRuntime]);
@@ -711,11 +739,11 @@ var useComposerSend = () => {
 };
 
 // src/primitive-hooks/composer/useComposerAddAttachment.tsx
-import { useCallback as useCallback14 } from "react";
+import { useCallback as useCallback15 } from "react";
 var useComposerAddAttachment = () => {
   const disabled = useComposer((c) => !c.isEditing);
   const composerRuntime = useComposerRuntime();
-  const callback = useCallback14(() => {
+  const callback = useCallback15(() => {
     const input = document.createElement("input");
     input.type = "file";
     const attachmentAccept = composerRuntime.getAttachmentAccept();
@@ -825,11 +853,11 @@ var useThreadEmpty = () => {
 };
 
 // src/primitive-hooks/thread/useThreadScrollToBottom.tsx
-import { useCallback as useCallback15 } from "react";
+import { useCallback as useCallback16 } from "react";
 var useThreadScrollToBottom = () => {
   const isAtBottom = useThreadViewport((s) => s.isAtBottom);
   const threadViewportStore = useThreadViewportStore();
-  const handleScrollToBottom = useCallback15(() => {
+  const handleScrollToBottom = useCallback16(() => {
     threadViewportStore.getState().scrollToBottom();
   }, [threadViewportStore]);
   if (isAtBottom) return null;
@@ -837,14 +865,14 @@ var useThreadScrollToBottom = () => {
 };
 
 // src/primitive-hooks/thread/useThreadSuggestion.tsx
-import { useCallback as useCallback16 } from "react";
+import { useCallback as useCallback17 } from "react";
 var useThreadSuggestion = ({
   prompt,
   autoSend
 }) => {
   const threadRuntime = useThreadRuntime();
   const disabled = useThread((t) => t.isDisabled);
-  const callback = useCallback16(() => {
+  const callback = useCallback17(() => {
     if (autoSend && !threadRuntime.getState().isRunning) {
       threadRuntime.append(prompt);
       threadRuntime.composer.setText("");
@@ -1083,7 +1111,7 @@ __export(assistantModal_exports, {
 });
 
 // src/primitives/assistantModal/AssistantModalRoot.tsx
-import { useEffect as useEffect8, useState as useState5 } from "react";
+import { useEffect as useEffect9, useState as useState6 } from "react";
 import * as PopoverPrimitive2 from "@radix-ui/react-popover";
 import { composeEventHandlers as composeEventHandlers6 } from "@radix-ui/primitive";
 
@@ -1097,10 +1125,10 @@ var useAssistantModalOpenState = ({
   defaultOpen = false,
   unstable_openOnRunStart = true
 }) => {
-  const state = useState5(defaultOpen);
+  const state = useState6(defaultOpen);
   const [, setOpen] = state;
   const threadRuntime = useThreadRuntime();
-  useEffect8(() => {
+  useEffect9(() => {
     if (!unstable_openOnRunStart) return void 0;
     return threadRuntime.unstable_on("run-start", () => {
       setOpen(true);
@@ -1294,10 +1322,10 @@ var AttachmentPrimitiveName = () => {
 AttachmentPrimitiveName.displayName = "AttachmentPrimitive.Name";
 
 // src/primitive-hooks/attachment/useAttachmentRemove.ts
-import { useCallback as useCallback17 } from "react";
+import { useCallback as useCallback18 } from "react";
 var useAttachmentRemove = () => {
   const attachmentRuntime = useAttachmentRuntime();
-  const handleRemoveAttachment = useCallback17(() => {
+  const handleRemoveAttachment = useCallback18(() => {
     attachmentRuntime.remove();
   }, [attachmentRuntime]);
   return handleRemoveAttachment;
@@ -1365,14 +1393,14 @@ __export(message_exports, {
 import { Primitive as Primitive9 } from "@radix-ui/react-primitive";
 import {
   forwardRef as forwardRef12,
-  useCallback as useCallback19
+  useCallback as useCallback20
 } from "react";
 
 // src/utils/hooks/useManagedRef.ts
-import { useCallback as useCallback18, useRef } from "react";
+import { useCallback as useCallback19, useRef } from "react";
 var useManagedRef = (callback) => {
   const cleanupRef = useRef();
-  const ref = useCallback18(
+  const ref = useCallback19(
     (el) => {
       if (cleanupRef.current) {
         cleanupRef.current();
@@ -1391,7 +1419,7 @@ import { useComposedRefs } from "@radix-ui/react-compose-refs";
 import { jsx as jsx18 } from "react/jsx-runtime";
 var useIsHoveringRef = () => {
   const messageUtilsStore = useMessageUtilsStore();
-  const callbackRef = useCallback19(
+  const callbackRef = useCallback20(
     (el) => {
       const setIsHovering = messageUtilsStore.getState().setIsHovering;
       const handleMouseEnter = () => {
@@ -1433,19 +1461,19 @@ MessagePrimitiveIf.displayName = "MessagePrimitive.If";
 import { memo as memo2, useMemo as useMemo6 } from "react";
 
 // src/context/providers/ContentPartRuntimeProvider.tsx
-import { useEffect as useEffect9, useState as useState6 } from "react";
-import { create as create6 } from "zustand";
+import { useEffect as useEffect10, useState as useState7 } from "react";
+import { create as create7 } from "zustand";
 import { jsx as jsx19 } from "react/jsx-runtime";
 var useContentPartRuntimeStore = (runtime) => {
-  const [store] = useState6(() => create6(() => runtime));
-  useEffect9(() => {
+  const [store] = useState7(() => create7(() => runtime));
+  useEffect10(() => {
     writableStore(store).setState(runtime, true);
   }, [runtime, store]);
   return store;
 };
 var useContentPartStore2 = (runtime) => {
-  const [store] = useState6(() => create6(() => runtime.getState()));
-  useEffect9(() => {
+  const [store] = useState7(() => create7(() => runtime.getState()));
+  useEffect10(() => {
     const updateState = () => writableStore(store).setState(runtime.getState(), true);
     updateState();
     return runtime.subscribe(updateState);
@@ -1458,7 +1486,7 @@ var ContentPartRuntimeProvider = ({
 }) => {
   const useContentPartRuntime2 = useContentPartRuntimeStore(runtime);
   const useContentPart2 = useContentPartStore2(runtime);
-  const [context] = useState6(() => {
+  const [context] = useState7(() => {
     return { useContentPartRuntime: useContentPartRuntime2, useContentPart: useContentPart2 };
   });
   return /* @__PURE__ */ jsx19(ContentPartContext.Provider, { value: context, children });
@@ -1470,7 +1498,7 @@ import {
 } from "react";
 
 // src/utils/smooth/useSmooth.tsx
-import { useEffect as useEffect10, useMemo as useMemo5, useRef as useRef2, useState as useState8 } from "react";
+import { useEffect as useEffect11, useMemo as useMemo5, useRef as useRef2, useState as useState9 } from "react";
 import { useCallbackRef } from "@radix-ui/react-use-callback-ref";
 
 // src/utils/smooth/SmoothContext.tsx
@@ -1478,19 +1506,19 @@ import {
   createContext as createContext6,
   forwardRef as forwardRef13,
   useContext as useContext3,
-  useState as useState7
+  useState as useState8
 } from "react";
-import { create as create7 } from "zustand";
+import { create as create8 } from "zustand";
 import { jsx as jsx20 } from "react/jsx-runtime";
 var SmoothContext = createContext6(null);
 var makeSmoothContext = (initialState) => {
-  const useSmoothStatus2 = create7(() => initialState);
+  const useSmoothStatus2 = create8(() => initialState);
   return { useSmoothStatus: useSmoothStatus2 };
 };
 var SmoothContextProvider = ({ children }) => {
   const outer = useSmoothContext({ optional: true });
   const contentPartStore = useContentPartStore();
-  const [context] = useState7(
+  const [context] = useState8(
     () => makeSmoothContext(contentPartStore.getState().status)
   );
   if (outer) return children;
@@ -1571,7 +1599,7 @@ var useSmooth = (state, smooth = false) => {
     selector: (m) => m.id
   });
   const idRef = useRef2(id);
-  const [displayedText, setDisplayedText] = useState8(text);
+  const [displayedText, setDisplayedText] = useState9(text);
   const smoothStatusStore = useSmoothStatusStore({ optional: true });
   const setText = useCallbackRef((text2) => {
     setDisplayedText(text2);
@@ -1581,17 +1609,17 @@ var useSmooth = (state, smooth = false) => {
       );
     }
   });
-  useEffect10(() => {
+  useEffect11(() => {
     if (smoothStatusStore) {
       writableStore(smoothStatusStore).setState(
         text !== state.text ? SMOOTH_STATUS : state.status
       );
     }
   }, [smoothStatusStore, text, displayedText, state.status, state.text]);
-  const [animatorRef] = useState8(
+  const [animatorRef] = useState9(
     new TextStreamAnimator(text, setText)
   );
-  useEffect10(() => {
+  useEffect11(() => {
     if (!smooth) {
       animatorRef.stop();
       return;
@@ -1607,7 +1635,7 @@ var useSmooth = (state, smooth = false) => {
     animatorRef.targetText = text;
     animatorRef.start();
   }, [setText, animatorRef, id, smooth, text]);
-  useEffect10(() => {
+  useEffect11(() => {
     return () => {
       animatorRef.stop();
     };
@@ -2374,22 +2402,22 @@ import { memo as memo3, useMemo as useMemo8 } from "react";
 
 // src/context/providers/AttachmentRuntimeProvider.tsx
 import {
-  useEffect as useEffect11,
+  useEffect as useEffect12,
   useMemo as useMemo7,
-  useState as useState9
+  useState as useState10
 } from "react";
-import { create as create8 } from "zustand";
+import { create as create9 } from "zustand";
 import { jsx as jsx24 } from "react/jsx-runtime";
 var useAttachmentRuntimeStore = (runtime) => {
-  const [store] = useState9(() => create8(() => runtime));
-  useEffect11(() => {
+  const [store] = useState10(() => create9(() => runtime));
+  useEffect12(() => {
     writableStore(store).setState(runtime, true);
   }, [runtime, store]);
   return store;
 };
 var useAttachmentStore = (runtime) => {
-  const [store] = useState9(() => create8(() => runtime.getState()));
-  useEffect11(() => {
+  const [store] = useState10(() => create9(() => runtime.getState()));
+  useEffect12(() => {
     const updateState = () => writableStore(store).setState(runtime.getState(), true);
     updateState();
     return runtime.subscribe(updateState);
@@ -2514,8 +2542,8 @@ import { useComposedRefs as useComposedRefs2 } from "@radix-ui/react-compose-ref
 import { Slot } from "@radix-ui/react-slot";
 import {
   forwardRef as forwardRef18,
-  useCallback as useCallback20,
-  useEffect as useEffect13,
+  useCallback as useCallback21,
+  useEffect as useEffect14,
   useRef as useRef3
 } from "react";
 import TextareaAutosize from "react-textarea-autosize";
@@ -2523,11 +2551,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 useEffect12 } from "react";
+import { useEffect as useEffect13 } from "react";
 var useOnScrollToBottom = (callback) => {
   const callbackRef = useCallbackRef2(callback);
   const onScrollToBottom = useThreadViewport((vp) => vp.onScrollToBottom);
-  useEffect12(() => {
+  useEffect13(() => {
     return onScrollToBottom(callbackRef);
   }, [onScrollToBottom, callbackRef]);
 };
@@ -2577,7 +2605,7 @@ var ComposerPrimitiveInput = forwardRef18(
       }
     };
     const autoFocusEnabled = autoFocus && !isDisabled;
-    const focus2 = useCallback20(() => {
+    const focus2 = useCallback21(() => {
       const textarea = textareaRef.current;
       if (!textarea || !autoFocusEnabled) return;
       textarea.focus({ preventScroll: true });
@@ -2586,18 +2614,18 @@ var ComposerPrimitiveInput = forwardRef18(
         textareaRef.current.value.length
       );
     }, [autoFocusEnabled]);
-    useEffect13(() => focus2(), [focus2]);
+    useEffect14(() => focus2(), [focus2]);
     useOnScrollToBottom(() => {
       if (composerRuntime.type === "thread" && unstable_focusOnScrollToBottom) {
         focus2();
       }
     });
-    useEffect13(() => {
+    useEffect14(() => {
       if (composerRuntime.type !== "thread" || !unstable_focusOnRunStart)
         return void 0;
       return threadRuntime.unstable_on("run-start", focus2);
     }, [unstable_focusOnRunStart]);
-    useEffect13(() => {
+    useEffect14(() => {
       if (composerRuntime.type !== "thread" || !unstable_focusOnThreadSwitched)
         return void 0;
       return threadRuntime.unstable_on("switched-to", focus2);
@@ -2754,14 +2782,14 @@ 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 useEffect14, useRef as useRef4 } from "react";
+import { useEffect as useEffect15, useRef as useRef4 } from "react";
 
 // src/utils/hooks/useOnResizeContent.tsx
 import { useCallbackRef as useCallbackRef3 } from "@radix-ui/react-use-callback-ref";
-import { useCallback as useCallback21 } from "react";
+import { useCallback as useCallback22 } from "react";
 var useOnResizeContent = (callback) => {
   const callbackRef = useCallbackRef3(callback);
-  const refCallback = useCallback21(
+  const refCallback = useCallback22(
     (el) => {
       const resizeObserver = new ResizeObserver(() => {
         callbackRef();
@@ -2846,7 +2874,7 @@ var useThreadViewportAutoScroll = ({
     scrollToBottom("auto");
   });
   const threadRuntime = useThreadRuntime();
-  useEffect14(() => {
+  useEffect15(() => {
     if (!unstable_scrollToBottomOnRunStart) return void 0;
     return threadRuntime.unstable_on("run-start", focus);
   }, [unstable_scrollToBottomOnRunStart]);
@@ -2868,12 +2896,12 @@ ThreadPrimitiveViewport.displayName = "ThreadPrimitive.Viewport";
 import { memo as memo5, useMemo as useMemo10 } from "react";
 
 // src/context/providers/MessageRuntimeProvider.tsx
-import { useEffect as useEffect15, useState as useState10 } from "react";
-import { create as create10 } from "zustand";
+import { useEffect as useEffect16, useState as useState11 } from "react";
+import { create as create11 } from "zustand";
 
 // src/context/stores/MessageUtils.ts
-import { create as create9 } from "zustand";
-var makeMessageUtilsStore = () => create9((set) => {
+import { create as create10 } from "zustand";
+var makeMessageUtilsStore = () => create10((set) => {
   return {
     isCopied: false,
     setIsCopied: (value) => {
@@ -2889,15 +2917,15 @@ var makeMessageUtilsStore = () => create9((set) => {
 // src/context/providers/MessageRuntimeProvider.tsx
 import { jsx as jsx32 } from "react/jsx-runtime";
 var useMessageRuntimeStore = (runtime) => {
-  const [store] = useState10(() => create10(() => runtime));
-  useEffect15(() => {
+  const [store] = useState11(() => create11(() => runtime));
+  useEffect16(() => {
     writableStore(store).setState(runtime, true);
   }, [runtime, store]);
   return store;
 };
 var useMessageStore2 = (runtime) => {
-  const [store] = useState10(() => create10(() => runtime.getState()));
-  useEffect15(() => {
+  const [store] = useState11(() => create11(() => runtime.getState()));
+  useEffect16(() => {
     const updateState = () => writableStore(store).setState(runtime.getState(), true);
     updateState();
     return runtime.subscribe(updateState);
@@ -2905,13 +2933,13 @@ var useMessageStore2 = (runtime) => {
   return store;
 };
 var useMessageUtilsStore2 = () => {
-  const [store] = useState10(() => makeMessageUtilsStore());
+  const [store] = useState11(() => makeMessageUtilsStore());
   return store;
 };
 var useEditComposerStore2 = (useMessageRuntime2) => {
   const runtime = useMessageRuntime2.getState().composer;
-  const [store] = useState10(() => create10(() => runtime.getState()));
-  useEffect15(() => {
+  const [store] = useState11(() => create11(() => runtime.getState()));
+  useEffect16(() => {
     const updateState = () => writableStore(store).setState(runtime.getState());
     updateState();
     return runtime.subscribe(updateState);
@@ -2926,7 +2954,7 @@ var MessageRuntimeProvider = ({
   const useMessage2 = useMessageStore2(runtime);
   const useMessageUtils2 = useMessageUtilsStore2();
   const useEditComposer2 = useEditComposerStore2(useMessageRuntime2);
-  const [context] = useState10(() => {
+  const [context] = useState11(() => {
     return { useMessageRuntime: useMessageRuntime2, useMessage: useMessage2, useMessageUtils: useMessageUtils2, useEditComposer: useEditComposer2 };
   });
   return /* @__PURE__ */ jsx32(MessageContext.Provider, { value: context, children });
@@ -3018,13 +3046,13 @@ var subscribeToMainThread = (runtime, callback) => {
   let cleanup;
   const inner = () => {
     cleanup?.();
-    cleanup = runtime.thread.subscribe(callback);
+    cleanup = runtime.threadManager.mainThread.subscribe(callback);
     if (!first) {
       callback();
     }
     first = false;
   };
-  const unsubscribe = runtime.subscribe(inner);
+  const unsubscribe = runtime.threadManager.mainThread.subscribe(inner);
   inner();
   return () => {
     unsubscribe();
@@ -3033,29 +3061,44 @@ var subscribeToMainThread = (runtime, callback) => {
 };
 
 // src/runtimes/local/useLocalRuntime.tsx
-import { useInsertionEffect, useMemo as useMemo11, useState as useState12 } from "react";
+import { useEffect as useEffect17, useMemo as useMemo11, useState as useState13 } from "react";
 
-// src/runtimes/core/BaseAssistantRuntimeCore.tsx
-var BaseAssistantRuntimeCore = class {
-  constructor(_thread) {
-    this._thread = _thread;
-    this._thread = _thread;
+// src/utils/ProxyConfigProvider.ts
+var ProxyConfigProvider = class {
+  _providers = /* @__PURE__ */ new Set();
+  getModelConfig() {
+    return mergeModelConfigs(this._providers);
   }
-  get thread() {
-    return this._thread;
+  registerModelConfigProvider(provider) {
+    this._providers.add(provider);
+    const unsubscribe = provider.subscribe?.(() => {
+      this.notifySubscribers();
+    });
+    this.notifySubscribers();
+    return () => {
+      this._providers.delete(provider);
+      unsubscribe?.();
+      this.notifySubscribers();
+    };
   }
-  set thread(thread) {
-    this._thread = thread;
-    this.subscriptionHandler();
+  _subscribers = /* @__PURE__ */ new Set();
+  notifySubscribers() {
+    for (const callback of this._subscribers) callback();
   }
-  _subscriptions = /* @__PURE__ */ new Set();
   subscribe(callback) {
-    this._subscriptions.add(callback);
-    return () => this._subscriptions.delete(callback);
+    this._subscribers.add(callback);
+    return () => this._subscribers.delete(callback);
+  }
+};
+
+// src/runtimes/core/BaseAssistantRuntimeCore.tsx
+var BaseAssistantRuntimeCore = class {
+  _proxyConfigProvider = new ProxyConfigProvider();
+  constructor() {
+  }
+  registerModelConfigProvider(provider) {
+    return this._proxyConfigProvider.registerModelConfigProvider(provider);
   }
-  subscriptionHandler = () => {
-    for (const callback of this._subscriptions) callback();
-  };
 };
 
 // src/internal.ts
@@ -3191,34 +3234,6 @@ var DefaultThreadComposerRuntimeCore = class extends BaseComposerRuntimeCore {
   }
 };
 
-// src/utils/ProxyConfigProvider.ts
-var ProxyConfigProvider = class {
-  _providers = /* @__PURE__ */ new Set();
-  getModelConfig() {
-    return mergeModelConfigs(this._providers);
-  }
-  registerModelConfigProvider(provider) {
-    this._providers.add(provider);
-    const unsubscribe = provider.subscribe?.(() => {
-      this.notifySubscribers();
-    });
-    this.notifySubscribers();
-    return () => {
-      this._providers.delete(provider);
-      unsubscribe?.();
-      this.notifySubscribers();
-    };
-  }
-  _subscribers = /* @__PURE__ */ new Set();
-  notifySubscribers() {
-    for (const callback of this._subscribers) callback();
-  }
-  subscribe(callback) {
-    this._subscribers.add(callback);
-    return () => this._subscribers.delete(callback);
-  }
-};
-
 // src/utils/idUtils.tsx
 import { customAlphabet } from "nanoid/non-secure";
 var generateId = customAlphabet(
@@ -3828,20 +3843,67 @@ var ThreadRuntimeImpl = class {
   }
 };
 
+// src/api/ThreadManagerRuntime.ts
+var getThreadManagerState = (threadManager) => {
+  return {
+    threads: threadManager.threads,
+    archivedThreads: threadManager.archivedThreads
+  };
+};
+var THREAD_MANAGER_PATH = {
+  ref: "threadManager"
+};
+var ThreadManagerRuntimeImpl = class {
+  constructor(_core) {
+    this._core = _core;
+    const stateBinding = new LazyMemoizeSubject({
+      path: THREAD_MANAGER_PATH,
+      getState: () => getThreadManagerState(_core),
+      subscribe: (callback) => _core.subscribe(callback)
+    });
+    this._getState = stateBinding.getState.bind(stateBinding);
+  }
+  get path() {
+    return THREAD_MANAGER_PATH;
+  }
+  _getState;
+  getState() {
+    return this._getState();
+  }
+  rename(threadId, newTitle) {
+    return this._core.rename(threadId, newTitle);
+  }
+  archive(threadId) {
+    return this._core.archive(threadId);
+  }
+  unarchive(threadId) {
+    return this._core.unarchive(threadId);
+  }
+  delete(threadId) {
+    return this._core.delete(threadId);
+  }
+  subscribe(callback) {
+    return this._core.subscribe(callback);
+  }
+};
+
 // src/api/AssistantRuntime.ts
 var AssistantRuntimeImpl = class _AssistantRuntimeImpl {
   constructor(_core, _thread) {
     this._core = _core;
     this._thread = _thread;
+    this.threadManager = new ThreadManagerRuntimeImpl(_core.threadManager);
   }
+  threadManager;
   get thread() {
     return this._thread;
   }
   switchToNewThread() {
-    return this._core.switchToNewThread();
+    return this._core.threadManager.switchToNewThread();
   }
   switchToThread(threadId) {
-    return this._core.switchToThread(threadId);
+    if (threadId === null) return this.switchToNewThread();
+    return this._core.threadManager.switchToThread(threadId);
   }
   registerModelConfigProvider(provider) {
     return this._core.registerModelConfigProvider(provider);
@@ -3849,8 +3911,9 @@ var AssistantRuntimeImpl = class _AssistantRuntimeImpl {
   /**
    * @deprecated Thread is now static and never gets updated. This will be removed in 0.6.0.
    */
-  subscribe(callback) {
-    return this._core.subscribe(callback);
+  subscribe() {
+    return () => {
+    };
   }
   static createMainThreadRuntime(_core, CustomThreadRuntime = ThreadRuntimeImpl) {
     return new CustomThreadRuntime(
@@ -3859,8 +3922,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)
       })
     );
   }
@@ -4039,7 +4102,7 @@ var streamUtils = {
 };
 
 // src/runtimes/edge/useEdgeRuntime.ts
-import { useState as useState11 } from "react";
+import { useState as useState12 } from "react";
 
 // src/runtimes/edge/streams/assistantDecoderStream.ts
 function assistantDecoderStream() {
@@ -4220,7 +4283,7 @@ var splitLocalRuntimeOptions = (options) => {
 // src/runtimes/edge/useEdgeRuntime.ts
 var useEdgeRuntime = (options) => {
   const { localRuntimeOptions, otherOptions } = splitLocalRuntimeOptions(options);
-  const [adapter] = useState11(() => new EdgeChatAdapter(otherOptions));
+  const [adapter] = useState12(() => new EdgeChatAdapter(otherOptions));
   return useLocalRuntime(adapter, localRuntimeOptions);
 };
 
@@ -4272,9 +4335,6 @@ var DefaultEditComposerRuntimeCore = class extends BaseComposerRuntimeCore {
 var BaseThreadRuntimeCore = class {
   constructor(configProvider) {
     this.configProvider = configProvider;
-    this.configProvider.subscribe?.(() => {
-      this._notifyEventSubscribers("model-config-update");
-    });
   }
   _subscriptions = /* @__PURE__ */ new Set();
   repository = new MessageRepository();
@@ -4376,6 +4436,10 @@ var BaseThreadRuntimeCore = class {
   }
   _eventSubscribers = /* @__PURE__ */ new Map();
   unstable_on(event, callback) {
+    if (event === "model-config-update") {
+      return this.configProvider.subscribe?.(callback) ?? (() => {
+      });
+    }
     const subscribers = this._eventSubscribers.get(event);
     if (!subscribers) {
       this._eventSubscribers.set(event, /* @__PURE__ */ new Set([callback]));
@@ -4391,19 +4455,10 @@ var BaseThreadRuntimeCore = class {
 
 // src/runtimes/local/LocalThreadRuntimeCore.tsx
 var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
-  constructor(configProvider, adapter, { initialMessages, ...options }) {
+  constructor(configProvider, threadId, options) {
     super(configProvider);
-    this.adapter = adapter;
-    this.threadId = generateId();
-    this.options = options;
-    if (initialMessages) {
-      let parentId = null;
-      const messages2 = fromCoreMessages(initialMessages);
-      for (const message of messages2) {
-        this.repository.addOrUpdateMessage(parentId, message);
-        parentId = message.id;
-      }
-    }
+    this.threadId = threadId;
+    this._options = options;
   }
   capabilities = {
     switchToBranch: true,
@@ -4416,20 +4471,17 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
     feedback: false
   };
   abortController = null;
-  threadId;
   isDisabled = false;
   suggestions = [];
   get adapters() {
-    return this.options.adapters;
+    return this._options.adapters;
   }
   _options;
-  get options() {
-    return this._options;
-  }
   get extras() {
     return void 0;
   }
-  set options({ initialMessages, ...options }) {
+  setOptions(options) {
+    if (this._options === options) return;
     this._options = options;
     let hasUpdates = false;
     const canSpeak = options.adapters?.speech !== void 0;
@@ -4505,7 +4557,7 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
       this.repository.addOrUpdateMessage(parentId, message);
       this._notifySubscribers();
     };
-    const maxSteps = this.options.maxSteps ? this.options.maxSteps : (this.options.maxToolRoundtrips ?? 1) + 1;
+    const maxSteps = this._options.maxSteps ? this._options.maxSteps : (this._options.maxToolRoundtrips ?? 1) + 1;
     const steps = message.metadata?.steps?.length ?? 0;
     if (steps >= maxSteps) {
       updateMessage({
@@ -4523,7 +4575,7 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
       });
     }
     try {
-      const promiseOrGenerator = this.adapter.run({
+      const promiseOrGenerator = this.adapters.chatModel.run({
         messages: messages2,
         abortSignal: this.abortController.signal,
         config: this.getModelConfig(),
@@ -4596,44 +4648,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.switchToNewThread();
+    this._mainThread._notifyEventSubscribers("switched-away");
+    this._mainThread = newThreadCore;
+    newThreadCore._notifyEventSubscribers("switched-to");
+    this._notifySubscribers();
+  }
+  _performMoveOp(threadId, operation) {
+    const data = this._threadData.get(threadId);
+    if (!data) throw new Error("Thread not found");
+    if (operation === "archive" && data.isArchived) return;
+    if (operation === "unarchive" && !data.isArchived) return;
+    if (operation === "archive") {
+      data.isArchived = true;
+      this._archivedThreads = [...this._archivedThreads, data.metadata];
+    }
+    if (operation === "unarchive") {
+      data.isArchived = false;
+      this._threads = [...this._threads, data.metadata];
+    }
+    if (operation === "delete") {
+      this._threadData.delete(threadId);
+    }
+    if (operation === "archive" || operation === "delete" && data.isArchived) {
+      this._archivedThreads = this._archivedThreads.filter(
+        (t) => t.threadId !== threadId
+      );
+    }
+    if (operation === "unarchive" || operation === "delete" && !data.isArchived) {
+      this._threads = this._threads.filter((t) => t.threadId !== threadId);
+    }
+    this._notifySubscribers();
+  }
+  async rename(threadId, newTitle) {
+    const data = this._threadData.get(threadId);
+    if (!data) throw new Error("Thread not found");
+    data.metadata = {
+      ...data.metadata,
+      title: newTitle
+    };
+    const threadList = data.isArchived ? this.archivedThreads : this.threads;
+    const idx = threadList.findIndex((t) => t.threadId === threadId);
+    const updatedThreadList = threadList.toSpliced(idx, 1, data.metadata);
+    if (data.isArchived) {
+      this._archivedThreads = updatedThreadList;
+    } else {
+      this._threads = updatedThreadList;
+    }
+    this._notifySubscribers();
+  }
+  async archive(threadId) {
+    this._performMoveOp(threadId, "archive");
+  }
+  async unarchive(threadId) {
+    this._performMoveOp(threadId, "unarchive");
+  }
+  async delete(threadId) {
+    this._performMoveOp(threadId, "delete");
+  }
+  _subscriptions = /* @__PURE__ */ new Set();
+  subscribe(callback) {
+    this._subscriptions.add(callback);
+    return () => this._subscriptions.delete(callback);
+  }
+  _notifySubscribers() {
+    for (const callback of this._subscriptions) callback();
+  }
+};
+
+// src/runtimes/local/LocalRuntimeCore.tsx
+var getExportFromInitialMessages = (initialMessages) => {
+  const messages2 = fromCoreMessages(initialMessages);
+  return {
+    messages: messages2.map((m, idx) => ({
+      parentId: messages2[idx - 1]?.id ?? null,
+      message: m
+    }))
+  };
+};
+var LocalRuntimeCore = class extends BaseAssistantRuntimeCore {
+  threadManager;
+  _options;
+  constructor(options, initialMessages) {
+    super();
+    this._options = options;
+    this.threadManager = new LocalThreadManagerRuntimeCore((threadId, data) => {
+      const thread = new LocalThreadRuntimeCore(
+        this._proxyConfigProvider,
+        threadId,
+        this._options
+      );
+      thread.import(data);
+      return thread;
+    });
+    if (initialMessages) {
+      this.threadManager.mainThread.import(
+        getExportFromInitialMessages(initialMessages)
+      );
+    }
+  }
+  setOptions(options) {
+    this._options = options;
+    this.threadManager.mainThread.setOptions(options);
   }
   reset({
     initialMessages
   } = {}) {
-    this.switchToThread(null);
+    this.threadManager.switchToNewThread();
     if (!initialMessages) return;
-    const messages2 = fromCoreMessages(initialMessages);
-    this.thread.import({
-      messages: messages2.map((m, idx) => ({
-        parentId: messages2[idx - 1]?.id ?? null,
-        message: m
-      }))
-    });
+    this.threadManager.mainThread.import(
+      getExportFromInitialMessages(initialMessages)
+    );
   }
 };
 
@@ -4654,16 +4816,108 @@ var LocalRuntimeImpl = class _LocalRuntimeImpl extends AssistantRuntimeImpl {
   }
 };
 var useLocalRuntime = (adapter, options = {}) => {
-  const [runtime] = useState12(() => new LocalRuntimeCore(adapter, options));
-  useInsertionEffect(() => {
-    runtime.thread.adapter = adapter;
-    runtime.thread.options = options;
+  const opt = {
+    ...options,
+    adapters: {
+      ...options.adapters,
+      chatModel: adapter
+    }
+  };
+  const [runtime] = useState13(() => new LocalRuntimeCore(opt));
+  useEffect17(() => {
+    runtime.setOptions(opt);
   });
   return useMemo11(() => LocalRuntimeImpl.create(runtime), [runtime]);
 };
 
 // src/runtimes/external-store/useExternalStoreRuntime.tsx
-import { useEffect as useEffect16, useMemo as useMemo12, useState as useState13 } from "react";
+import { useEffect as useEffect18, useMemo as useMemo12, useState as useState14 } from "react";
+
+// src/runtimes/external-store/ExternalStoreThreadManagementAdapter.tsx
+var EMPTY_ARRAY2 = Object.freeze([]);
+var DEFAULT_THREAD_ID = "DEFAULT_THREAD_ID";
+var ExternalStoreThreadManagerRuntimeCore = class {
+  constructor(adapter = {}, threadFactory) {
+    this.adapter = adapter;
+    this.threadFactory = threadFactory;
+    this._mainThread = this.threadFactory(DEFAULT_THREAD_ID);
+  }
+  get threads() {
+    return this.adapter.threads ?? EMPTY_ARRAY2;
+  }
+  get archivedThreads() {
+    return this.adapter.archivedThreads ?? EMPTY_ARRAY2;
+  }
+  _mainThread;
+  get mainThread() {
+    return this._mainThread;
+  }
+  setAdapter(adapter) {
+    const previousAdapter = this.adapter;
+    this.adapter = adapter;
+    const newThreadId = adapter.threadId ?? DEFAULT_THREAD_ID;
+    const newThreads = adapter.threads ?? EMPTY_ARRAY2;
+    const newArchivedThreads = adapter.archivedThreads ?? EMPTY_ARRAY2;
+    if (previousAdapter.threadId === newThreadId && previousAdapter.threads === newThreads && previousAdapter.archivedThreads === newArchivedThreads) {
+      return;
+    }
+    if (previousAdapter.threadId !== newThreadId) {
+      this._mainThread._notifyEventSubscribers("switched-away");
+      this._mainThread = this.threadFactory(newThreadId);
+      this._mainThread._notifyEventSubscribers("switched-to");
+    }
+    this._notifySubscribers();
+  }
+  switchToThread(threadId) {
+    if (this._mainThread?.threadId === threadId) return;
+    const onSwitchToThread = this.adapter.onSwitchToThread;
+    if (!onSwitchToThread)
+      throw new Error(
+        "External store adapter does not support switching to thread"
+      );
+    onSwitchToThread(threadId);
+  }
+  switchToNewThread() {
+    const onSwitchToNewThread = this.adapter.onSwitchToNewThread;
+    if (!onSwitchToNewThread)
+      throw new Error(
+        "External store adapter does not support switching to new thread"
+      );
+    onSwitchToNewThread();
+  }
+  async rename(threadId, newTitle) {
+    const onRename = this.adapter.onRename;
+    if (!onRename)
+      throw new Error("External store adapter does not support renaming");
+    onRename(threadId, newTitle);
+  }
+  async archive(threadId) {
+    const onArchive = this.adapter.onArchive;
+    if (!onArchive)
+      throw new Error("External store adapter does not support archiving");
+    onArchive(threadId);
+  }
+  async unarchive(threadId) {
+    const onUnarchive = this.adapter.onUnarchive;
+    if (!onUnarchive)
+      throw new Error("External store adapter does not support unarchiving");
+    onUnarchive(threadId);
+  }
+  async delete(threadId) {
+    const onDelete = this.adapter.onDelete;
+    if (!onDelete)
+      throw new Error("External store adapter does not support deleting");
+    onDelete(threadId);
+  }
+  _subscriptions = /* @__PURE__ */ new Set();
+  subscribe(callback) {
+    this._subscriptions.add(callback);
+    return () => this._subscriptions.delete(callback);
+  }
+  _notifySubscribers() {
+    for (const callback of this._subscriptions) callback();
+  }
+};
 
 // src/runtimes/external-store/getExternalStoreMessage.tsx
 var symbolInnerMessage = Symbol("innerMessage");
@@ -4768,7 +5022,7 @@ var fromThreadMessageLike = (like, fallbackId, fallbackStatus) => {
 };
 
 // src/runtimes/external-store/ExternalStoreThreadRuntimeCore.tsx
-var EMPTY_ARRAY2 = Object.freeze([]);
+var EMPTY_ARRAY3 = Object.freeze([]);
 var hasUpcomingMessage = (isRunning, messages2) => {
   return isRunning && messages2[messages2.length - 1]?.role !== "assistant";
 };
@@ -4801,26 +5055,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,
@@ -4829,8 +5080,8 @@ var ExternalStoreThreadRuntimeCore = class extends BaseThreadRuntimeCore {
       speech: this._store.adapters?.speech !== void 0,
       unstable_copy: this._store.unstable_capabilities?.copy !== false,
       // default true
-      attachments: !!this.store.adapters?.attachments,
-      feedback: !!this.store.adapters?.feedback
+      attachments: !!this._store.adapters?.attachments,
+      feedback: !!this._store.adapters?.feedback
     };
     if (oldStore) {
       if (oldStore.convertMessage !== store.convertMessage) {
@@ -4934,57 +5185,41 @@ var ExternalStoreThreadRuntimeCore = class extends BaseThreadRuntimeCore {
 };
 
 // src/runtimes/external-store/ExternalStoreRuntimeCore.tsx
+var getThreadManagerAdapter = (store) => {
+  return {
+    threadId: store.threadId,
+    onSwitchToNewThread: store.onSwitchToNewThread,
+    onSwitchToThread: store.onSwitchToThread,
+    ...store.adapters?.threadManager
+  };
+};
 var ExternalStoreRuntimeCore = class extends BaseAssistantRuntimeCore {
-  _proxyConfigProvider;
+  threadManager;
+  _store;
   constructor(store) {
-    const provider = new ProxyConfigProvider();
-    super(new ExternalStoreThreadRuntimeCore(provider, store));
-    this._proxyConfigProvider = provider;
-  }
-  getModelConfig() {
-    return this._proxyConfigProvider.getModelConfig();
-  }
-  registerModelConfigProvider(provider) {
-    return this._proxyConfigProvider.registerModelConfigProvider(provider);
-  }
-  async switchToNewThread() {
-    if (!this.thread.store.onSwitchToNewThread)
-      throw new Error("Runtime does not support switching to new threads.");
-    this.thread = new ExternalStoreThreadRuntimeCore(
-      this._proxyConfigProvider,
-      {
-        ...this.thread.store,
-        messages: []
-      }
-    );
-    await this.thread.store.onSwitchToNewThread();
-    this.thread._notifyEventSubscribers("switched-to");
-  }
-  async switchToThread(threadId) {
-    if (threadId !== null) {
-      if (!this.thread.store.onSwitchToThread)
-        throw new Error("Runtime does not support switching threads.");
-      this.thread = new ExternalStoreThreadRuntimeCore(
+    super();
+    this._store = store;
+    this.threadManager = new ExternalStoreThreadManagerRuntimeCore(
+      getThreadManagerAdapter(store),
+      (threadId) => new ExternalStoreThreadRuntimeCore(
         this._proxyConfigProvider,
-        {
-          ...this.thread.store,
-          messages: []
-          // ignore messages until rerender
-        }
-      );
-      await this.thread.store.onSwitchToThread(threadId);
-      this.thread._notifyEventSubscribers("switched-to");
-    } else {
-      this.switchToNewThread();
-    }
+        threadId,
+        this._store
+      )
+    );
+  }
+  setStore(store) {
+    this._store = store;
+    this.threadManager.setAdapter(getThreadManagerAdapter(store));
+    this.threadManager.mainThread.setStore(store);
   }
 };
 
 // src/runtimes/external-store/useExternalStoreRuntime.tsx
 var useExternalStoreRuntime = (store) => {
-  const [runtime] = useState13(() => new ExternalStoreRuntimeCore(store));
-  useEffect16(() => {
-    runtime.thread.store = store;
+  const [runtime] = useState14(() => new ExternalStoreRuntimeCore(store));
+  useEffect18(() => {
+    runtime.setStore(store);
   });
   return useMemo12(
     () => AssistantRuntimeImpl.create(runtime, ThreadRuntimeImpl),
@@ -5139,7 +5374,7 @@ var shallowArrayEqual = (a, b) => {
 };
 
 // src/runtimes/dangerous-in-browser/useDangerousInBrowserRuntime.ts
-import { useState as useState14 } from "react";
+import { useState as useState15 } from "react";
 
 // src/runtimes/dangerous-in-browser/DangerousInBrowserAdapter.ts
 var DangerousInBrowserAdapter = class {
@@ -5168,7 +5403,7 @@ var DangerousInBrowserAdapter = class {
 // src/runtimes/dangerous-in-browser/useDangerousInBrowserRuntime.ts
 var useDangerousInBrowserRuntime = (options) => {
   const { localRuntimeOptions, otherOptions } = splitLocalRuntimeOptions(options);
-  const [adapter] = useState14(() => new DangerousInBrowserAdapter(otherOptions));
+  const [adapter] = useState15(() => new DangerousInBrowserAdapter(otherOptions));
   return useLocalRuntime(adapter, localRuntimeOptions);
 };
 
@@ -5754,8 +5989,8 @@ CircleStopIcon.displayName = "CircleStopIcon";
 // src/ui/attachment.tsx
 import {
   forwardRef as forwardRef28,
-  useEffect as useEffect17,
-  useState as useState15
+  useEffect as useEffect19,
+  useState as useState16
 } from "react";
 import { CircleXIcon, FileIcon } from "lucide-react";
 
@@ -5798,8 +6033,8 @@ var AttachmentRoot = withDefaults(attachment_exports.Root, {
 });
 AttachmentRoot.displayName = "AttachmentRoot";
 var useFileSrc = (file) => {
-  const [src, setSrc] = useState15(void 0);
-  useEffect17(() => {
+  const [src, setSrc] = useState16(void 0);
+  useEffect19(() => {
     if (!file) {
       setSrc(void 0);
       return;
@@ -5823,7 +6058,7 @@ var useAttachmentSrc = () => {
   return useFileSrc(file) ?? src;
 };
 var AttachmentPreview = ({ src }) => {
-  const [isLoaded, setIsLoaded] = useState15(false);
+  const [isLoaded, setIsLoaded] = useState16(false);
   return (
     // eslint-disable-next-line @next/next/no-img-element
     /* @__PURE__ */ jsx46(
@@ -6069,8 +6304,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", {
@@ -6504,6 +6744,7 @@ export {
   useEditComposerStore,
   useExternalMessageConverter,
   useExternalStoreRuntime,
+  useInlineRender,
   useLocalRuntime,
   useMessage,
   useMessageContext,
@@ -6522,6 +6763,7 @@ export {
   useThreadContext,
   useThreadEmpty,
   useThreadIf,
+  useThreadManager,
   useThreadMessages,
   useThreadMessagesStore,
   useThreadModelConfig,