@assistant-ui/react 0.2.0 → 0.2.3

package/dist/index.mjs

@@ -4,179 +4,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/primitive-hooks/actionBar/useActionBarCopy.tsx
-import { useCallback } from "react";
-
-// src/context/react/MessageContext.ts
-import { createContext, useContext } from "react";
-var MessageContext = createContext(null);
-var useMessageContext = () => {
-  const context = useContext(MessageContext);
-  if (!context)
-    throw new Error(
-      "This component can only be used inside a component passed to <ThreadPrimitive.Messages components={...} />."
-    );
-  return context;
-};
-
-// src/utils/combined/useCombinedStore.ts
-import { useMemo } 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 = useMemo(() => createCombinedStore(stores), stores);
-  return useCombined(selector);
-};
-
-// src/utils/getMessageText.tsx
-var getMessageText = (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 { useMessage, useMessageUtils, useEditComposer } = useMessageContext();
-  const hasCopyableContent = useCombinedStore(
-    [useMessage, useEditComposer],
-    (m, c) => {
-      return !c.isEditing && m.message.content.some((c2) => c2.type === "text");
-    }
-  );
-  const callback = useCallback(() => {
-    const { message } = useMessage.getState();
-    const { setIsCopied } = useMessageUtils.getState();
-    const { isEditing, value: composerValue } = useEditComposer.getState();
-    const valueToCopy = isEditing ? composerValue : getMessageText(message);
-    navigator.clipboard.writeText(valueToCopy);
-    setIsCopied(true);
-    setTimeout(() => setIsCopied(false), copiedDuration);
-  }, [useMessage, useMessageUtils, useEditComposer, copiedDuration]);
-  if (!hasCopyableContent) return null;
-  return callback;
-};
-
-// src/primitive-hooks/actionBar/useActionBarEdit.tsx
-import { useCallback as useCallback2 } from "react";
-var useActionBarEdit = () => {
-  const { useMessage, useEditComposer } = useMessageContext();
-  const disabled = useCombinedStore(
-    [useMessage, useEditComposer],
-    (m, c) => m.message.role !== "user" || c.isEditing
-  );
-  const callback = useCallback2(() => {
-    const { edit } = useEditComposer.getState();
-    edit();
-  }, [useEditComposer]);
-  if (disabled) return null;
-  return callback;
-};
-
-// src/primitive-hooks/actionBar/useActionBarReload.tsx
-import { useCallback as useCallback3 } from "react";
-
-// src/context/react/ThreadContext.ts
-import { createContext as createContext2, useContext as useContext2 } from "react";
-var ThreadContext = createContext2(null);
-var useThreadContext = () => {
-  const context = useContext2(ThreadContext);
-  if (!context)
-    throw new Error(
-      "This component must be used within an AssistantRuntimeProvider."
-    );
-  return context;
-};
-
-// src/primitive-hooks/actionBar/useActionBarReload.tsx
-var useActionBarReload = () => {
-  const { useThread, useThreadActions, useComposer, useViewport } = useThreadContext();
-  const { useMessage } = useMessageContext();
-  const disabled = useCombinedStore(
-    [useThread, useMessage],
-    (t, m) => t.isRunning || m.message.role !== "assistant"
-  );
-  const callback = useCallback3(() => {
-    const { parentId } = useMessage.getState();
-    useThreadActions.getState().startRun(parentId);
-    useViewport.getState().scrollToBottom();
-    useComposer.getState().focus();
-  }, [useThreadActions, useComposer, useViewport, useMessage]);
-  if (disabled) return null;
-  return callback;
-};
-
-// src/primitive-hooks/branchPicker/useBranchPickerCount.tsx
-var useBranchPickerCount = () => {
-  const { useMessage } = useMessageContext();
-  const branchCount = useMessage((s) => s.branches.length);
-  return branchCount;
-};
-
-// src/primitive-hooks/branchPicker/useBranchPickerNext.tsx
-import { useCallback as useCallback4 } from "react";
-var useBranchPickerNext = () => {
-  const { useThreadActions } = useThreadContext();
-  const { useMessage, useEditComposer } = useMessageContext();
-  const disabled = useCombinedStore(
-    [useMessage, useEditComposer],
-    (m, c) => c.isEditing || m.branches.indexOf(m.message.id) + 1 >= m.branches.length
-  );
-  const callback = useCallback4(() => {
-    const { message, branches } = useMessage.getState();
-    useThreadActions.getState().switchToBranch(branches[branches.indexOf(message.id) + 1]);
-  }, [useThreadActions, useMessage]);
-  if (disabled) return null;
-  return callback;
-};
-
-// src/primitive-hooks/branchPicker/useBranchPickerNumber.tsx
-var useBranchPickerNumber = () => {
-  const { useMessage } = useMessageContext();
-  const branchIdx = useMessage((s) => s.branches.indexOf(s.message.id));
-  return branchIdx + 1;
-};
-
-// src/primitive-hooks/branchPicker/useBranchPickerPrevious.tsx
-import { useCallback as useCallback5 } from "react";
-var useBranchPickerPrevious = () => {
-  const { useThreadActions } = useThreadContext();
-  const { useMessage, useEditComposer } = useMessageContext();
-  const disabled = useCombinedStore(
-    [useMessage, useEditComposer],
-    (m, c) => c.isEditing || m.branches.indexOf(m.message.id) <= 0
-  );
-  const callback = useCallback5(() => {
-    const { message, branches } = useMessage.getState();
-    useThreadActions.getState().switchToBranch(branches[branches.indexOf(message.id) - 1]);
-  }, [useThreadActions, useMessage]);
-  if (disabled) return null;
-  return callback;
-};
-
-// src/primitive-hooks/composer/useComposerCancel.tsx
-import { useCallback as useCallback6 } from "react";
-
 // src/context/providers/AssistantRuntimeProvider.tsx
 import { memo } from "react";
 
@@ -184,12 +11,12 @@ import { memo } from "react";
 import { useEffect as useEffect2, useInsertionEffect as useInsertionEffect2, useRef as useRef2, useState as useState2 } from "react";
 
 // src/context/react/AssistantContext.ts
-import { createContext as createContext3, useContext as useContext3 } from "react";
-var AssistantContext = createContext3(
+import { createContext, useContext } from "react";
+var AssistantContext = createContext(
   null
 );
 var useAssistantContext = () => {
-  const context = useContext3(AssistantContext);
+  const context = useContext(AssistantContext);
   if (!context)
     throw new Error(
       "This component must be used within an AssistantRuntimeProvider."
@@ -288,7 +115,26 @@ var makeAssistantToolUIsStore = () => create2((set) => {
 });
 
 // src/context/providers/ThreadProvider.tsx
-import { useEffect, useInsertionEffect, useRef, useState } from "react";
+import {
+  useCallback,
+  useEffect,
+  useInsertionEffect,
+  useRef,
+  useState,
+  useSyncExternalStore
+} from "react";
+
+// src/context/react/ThreadContext.ts
+import { createContext as createContext2, useContext as useContext2 } from "react";
+var ThreadContext = createContext2(null);
+var useThreadContext = () => {
+  const context = useContext2(ThreadContext);
+  if (!context)
+    throw new Error(
+      "This component must be used within an AssistantRuntimeProvider."
+    );
+  return context;
+};
 
 // src/context/stores/Composer.ts
 import { create as create3 } from "zustand";
@@ -302,7 +148,7 @@ var makeBaseComposer = (set) => ({
 });
 
 // src/context/stores/Composer.ts
-var makeComposerStore = (useThread, useThreadActions) => {
+var makeComposerStore = (useThread, useThreadMessages, useThreadActions) => {
   const focusListeners = /* @__PURE__ */ new Set();
   return create3()((set, get, store) => {
     return {
@@ -312,7 +158,7 @@ var makeComposerStore = (useThread, useThreadActions) => {
         const { setValue, value } = get();
         setValue("");
         useThreadActions.getState().append({
-          parentId: useThread.getState().messages.at(-1)?.id ?? null,
+          parentId: useThreadMessages.getState().at(-1)?.id ?? null,
           role: "user",
           content: [{ type: "text", text: value }]
         });
@@ -342,7 +188,6 @@ var makeComposerStore = (useThread, useThreadActions) => {
 import { create as create4 } from "zustand";
 var makeThreadStore = (runtimeRef) => {
   return create4(() => ({
-    messages: runtimeRef.current.messages,
     isRunning: runtimeRef.current.isRunning
   }));
 };
@@ -382,6 +227,12 @@ var makeThreadActionStore = (runtimeRef) => {
   );
 };
 
+// src/context/stores/ThreadMessages.ts
+import { create as create7 } from "zustand";
+var makeThreadMessagesStore = (runtimeRef) => {
+  return create7(() => runtimeRef.current.messages);
+};
+
 // src/context/providers/ThreadProvider.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
 var ThreadProvider = ({
@@ -394,11 +245,17 @@ var ThreadProvider = ({
   });
   const [context] = useState(() => {
     const useThread = makeThreadStore(runtimeRef);
+    const useThreadMessages = makeThreadMessagesStore(runtimeRef);
     const useThreadActions = makeThreadActionStore(runtimeRef);
     const useViewport = makeThreadViewportStore();
-    const useComposer = makeComposerStore(useThread, useThreadActions);
+    const useComposer = makeComposerStore(
+      useThread,
+      useThreadMessages,
+      useThreadActions
+    );
     return {
       useThread,
+      useThreadMessages,
       useThreadActions,
       useComposer,
       useViewport
@@ -408,22 +265,38 @@ var ThreadProvider = ({
     const onRuntimeUpdate = () => {
       context.useThread.setState(
         Object.freeze({
-          messages: runtimeRef.current.messages,
           isRunning: runtimeRef.current.isRunning
         }),
         true
       );
+      context.useThreadMessages.setState(Object.freeze(runtimeRef.current.messages), true);
     };
     onRuntimeUpdate();
     return runtime.subscribe(onRuntimeUpdate);
   }, [context, runtime]);
-  const RuntimeSynchronizer = runtime.unstable_synchronizer;
+  const subscribe = useCallback(
+    (c) => runtime.subscribe(c),
+    [runtime]
+  );
+  const RuntimeSynchronizer = useSyncExternalStore(
+    subscribe,
+    () => runtime.unstable_synchronizer,
+    () => void 0
+  );
   return /* @__PURE__ */ jsxs(ThreadContext.Provider, { value: context, children: [
     RuntimeSynchronizer && /* @__PURE__ */ jsx(RuntimeSynchronizer, {}),
     children
   ] });
 };
 
+// src/context/stores/AssistantActions.tsx
+import { create as create8 } from "zustand";
+var makeAssistantActionsStore = (runtimeRef) => create8(
+  () => Object.freeze({
+    switchToThread: () => runtimeRef.current.switchToThread(null)
+  })
+);
+
 // src/context/providers/AssistantProvider.tsx
 import { jsx as jsx2 } from "react/jsx-runtime";
 var AssistantProvider = ({ children, runtime }) => {
@@ -434,7 +307,8 @@ var AssistantProvider = ({ children, runtime }) => {
   const [context] = useState2(() => {
     const useModelConfig = makeAssistantModelConfigStore();
     const useToolUIs = makeAssistantToolUIsStore();
-    return { useModelConfig, useToolUIs };
+    const useAssistantActions = makeAssistantActionsStore(runtimeRef);
+    return { useModelConfig, useToolUIs, useAssistantActions };
   });
   const getModelCOnfig = context.useModelConfig((c) => c.getModelConfig);
   useEffect2(() => {
@@ -451,11 +325,25 @@ var AssistantRuntimeProviderImpl = ({ children, runtime }) => {
 var AssistantRuntimeProvider = memo(AssistantRuntimeProviderImpl);
 
 // src/context/react/ComposerContext.ts
-import { useContext as useContext4, useMemo as useMemo2 } from "react";
+import { useContext as useContext4, useMemo } from "react";
+
+// src/context/react/MessageContext.ts
+import { createContext as createContext3, useContext as useContext3 } from "react";
+var MessageContext = createContext3(null);
+var useMessageContext = () => {
+  const context = useContext3(MessageContext);
+  if (!context)
+    throw new Error(
+      "This component can only be used inside a component passed to <ThreadPrimitive.Messages components={...} />."
+    );
+  return context;
+};
+
+// src/context/react/ComposerContext.ts
 var useComposerContext = () => {
   const { useComposer } = useThreadContext();
   const { useEditComposer } = useContext4(MessageContext) ?? {};
-  return useMemo2(
+  return useMemo(
     () => ({
       useComposer: useEditComposer ?? useComposer,
       type: useEditComposer ? "edit" : "new"
@@ -478,11 +366,267 @@ var useContentPartContext = () => {
   return context;
 };
 
+// src/hooks/useAppendMessage.tsx
+import { useCallback as useCallback2 } from "react";
+var toAppendMessage = (useThreadMessages, message) => {
+  if (typeof message === "string") {
+    return {
+      parentId: useThreadMessages.getState().at(-1)?.id ?? null,
+      role: "user",
+      content: [{ type: "text", text: message }]
+    };
+  }
+  return {
+    parentId: message.parentId ?? useThreadMessages.getState().at(-1)?.id ?? null,
+    role: message.role ?? "user",
+    content: message.content
+  };
+};
+var useAppendMessage = () => {
+  const { useThreadMessages, useThreadActions, useViewport, useComposer } = useThreadContext();
+  const append = useCallback2(
+    (message) => {
+      const appendMessage = toAppendMessage(useThreadMessages, message);
+      useThreadActions.getState().append(appendMessage);
+      useViewport.getState().scrollToBottom();
+      useComposer.getState().focus();
+    },
+    [useThreadMessages, useThreadActions, useViewport, useComposer]
+  );
+  return append;
+};
+
+// src/hooks/useSwitchToNewThread.tsx
+import { useCallback as useCallback3 } from "react";
+var useSwitchToNewThread = () => {
+  const { useAssistantActions } = useAssistantContext();
+  const { useComposer } = useThreadContext();
+  const switchToNewThread = useCallback3(() => {
+    useAssistantActions.getState().switchToThread(null);
+    useComposer.getState().focus();
+  }, [useAssistantActions, useComposer]);
+  return switchToNewThread;
+};
+
+// src/model-config/useAssistantTool.tsx
+import { useEffect as useEffect3 } from "react";
+var useAssistantTool = (tool) => {
+  const { useModelConfig, useToolUIs } = useAssistantContext();
+  const registerModelConfigProvider = useModelConfig(
+    (s) => s.registerModelConfigProvider
+  );
+  const setToolUI = useToolUIs((s) => s.setToolUI);
+  useEffect3(() => {
+    const { toolName, render, ...rest } = tool;
+    const config = {
+      tools: {
+        [tool.toolName]: rest
+      }
+    };
+    const unsub1 = registerModelConfigProvider(() => config);
+    const unsub2 = render ? setToolUI(toolName, render) : void 0;
+    return () => {
+      unsub1();
+      unsub2?.();
+    };
+  }, [registerModelConfigProvider, setToolUI, tool]);
+};
+
+// src/model-config/makeAssistantTool.tsx
+var makeAssistantTool = (tool) => {
+  const Tool = () => {
+    useAssistantTool(tool);
+    return null;
+  };
+  return Tool;
+};
+
+// src/model-config/useAssistantToolUI.tsx
+import { useEffect as useEffect4 } from "react";
+var useAssistantToolUI = (tool) => {
+  const { useToolUIs } = useAssistantContext();
+  const setToolUI = useToolUIs((s) => s.setToolUI);
+  useEffect4(() => {
+    if (!tool) return;
+    const { toolName, render } = tool;
+    return setToolUI(toolName, render);
+  }, [setToolUI, tool]);
+};
+
+// src/model-config/makeAssistantToolUI.tsx
+var makeAssistantToolUI = (tool) => {
+  const ToolUI = () => {
+    useAssistantToolUI(tool);
+    return null;
+  };
+  return ToolUI;
+};
+
+// src/model-config/useAssistantInstructions.tsx
+import { useEffect as useEffect5 } from "react";
+var useAssistantInstructions = (instruction) => {
+  const { useModelConfig } = useAssistantContext();
+  const registerModelConfigProvider = useModelConfig(
+    (s) => s.registerModelConfigProvider
+  );
+  useEffect5(() => {
+    const config = {
+      system: instruction
+    };
+    return registerModelConfigProvider(() => config);
+  }, [registerModelConfigProvider, instruction]);
+};
+
+// src/primitive-hooks/actionBar/useActionBarCopy.tsx
+import { useCallback as useCallback4 } from "react";
+
+// src/utils/combined/useCombinedStore.ts
+import { useMemo as useMemo2 } from "react";
+
+// src/utils/combined/createCombinedStore.ts
+import { useSyncExternalStore as useSyncExternalStore2 } 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 useSyncExternalStore2(subscribe, getSnapshot, getSnapshot);
+  };
+};
+
+// src/utils/combined/useCombinedStore.ts
+var useCombinedStore = (stores, selector) => {
+  const useCombined = useMemo2(() => createCombinedStore(stores), stores);
+  return useCombined(selector);
+};
+
+// src/utils/getMessageText.tsx
+var getMessageText = (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 { useMessage, useMessageUtils, useEditComposer } = useMessageContext();
+  const hasCopyableContent = useCombinedStore(
+    [useMessage, useEditComposer],
+    (m, c) => {
+      return !c.isEditing && m.message.content.some((c2) => c2.type === "text");
+    }
+  );
+  const callback = useCallback4(() => {
+    const { message } = useMessage.getState();
+    const { setIsCopied } = useMessageUtils.getState();
+    const { isEditing, value: composerValue } = useEditComposer.getState();
+    const valueToCopy = isEditing ? composerValue : getMessageText(message);
+    navigator.clipboard.writeText(valueToCopy);
+    setIsCopied(true);
+    setTimeout(() => setIsCopied(false), copiedDuration);
+  }, [useMessage, useMessageUtils, useEditComposer, copiedDuration]);
+  if (!hasCopyableContent) return null;
+  return callback;
+};
+
+// src/primitive-hooks/actionBar/useActionBarEdit.tsx
+import { useCallback as useCallback5 } from "react";
+var useActionBarEdit = () => {
+  const { useMessage, useEditComposer } = useMessageContext();
+  const disabled = useCombinedStore(
+    [useMessage, useEditComposer],
+    (m, c) => m.message.role !== "user" || c.isEditing
+  );
+  const callback = useCallback5(() => {
+    const { edit } = useEditComposer.getState();
+    edit();
+  }, [useEditComposer]);
+  if (disabled) return null;
+  return callback;
+};
+
+// src/primitive-hooks/actionBar/useActionBarReload.tsx
+import { useCallback as useCallback6 } from "react";
+var useActionBarReload = () => {
+  const { useThread, useThreadActions, useComposer, useViewport } = useThreadContext();
+  const { useMessage } = useMessageContext();
+  const disabled = useCombinedStore(
+    [useThread, useMessage],
+    (t, m) => t.isRunning || m.message.role !== "assistant"
+  );
+  const callback = useCallback6(() => {
+    const { parentId } = useMessage.getState();
+    useThreadActions.getState().startRun(parentId);
+    useViewport.getState().scrollToBottom();
+    useComposer.getState().focus();
+  }, [useThreadActions, useComposer, useViewport, useMessage]);
+  if (disabled) return null;
+  return callback;
+};
+
+// src/primitive-hooks/branchPicker/useBranchPickerCount.tsx
+var useBranchPickerCount = () => {
+  const { useMessage } = useMessageContext();
+  const branchCount = useMessage((s) => s.branches.length);
+  return branchCount;
+};
+
+// src/primitive-hooks/branchPicker/useBranchPickerNext.tsx
+import { useCallback as useCallback7 } from "react";
+var useBranchPickerNext = () => {
+  const { useThreadActions } = useThreadContext();
+  const { useMessage, useEditComposer } = useMessageContext();
+  const disabled = useCombinedStore(
+    [useMessage, useEditComposer],
+    (m, c) => c.isEditing || m.branches.indexOf(m.message.id) + 1 >= m.branches.length
+  );
+  const callback = useCallback7(() => {
+    const { message, branches } = useMessage.getState();
+    useThreadActions.getState().switchToBranch(branches[branches.indexOf(message.id) + 1]);
+  }, [useThreadActions, useMessage]);
+  if (disabled) return null;
+  return callback;
+};
+
+// src/primitive-hooks/branchPicker/useBranchPickerNumber.tsx
+var useBranchPickerNumber = () => {
+  const { useMessage } = useMessageContext();
+  const branchIdx = useMessage((s) => s.branches.indexOf(s.message.id));
+  return branchIdx + 1;
+};
+
+// src/primitive-hooks/branchPicker/useBranchPickerPrevious.tsx
+import { useCallback as useCallback8 } from "react";
+var useBranchPickerPrevious = () => {
+  const { useThreadActions } = useThreadContext();
+  const { useMessage, useEditComposer } = useMessageContext();
+  const disabled = useCombinedStore(
+    [useMessage, useEditComposer],
+    (m, c) => c.isEditing || m.branches.indexOf(m.message.id) <= 0
+  );
+  const callback = useCallback8(() => {
+    const { message, branches } = useMessage.getState();
+    useThreadActions.getState().switchToBranch(branches[branches.indexOf(message.id) - 1]);
+  }, [useThreadActions, useMessage]);
+  if (disabled) return null;
+  return callback;
+};
+
 // src/primitive-hooks/composer/useComposerCancel.tsx
+import { useCallback as useCallback9 } from "react";
 var useComposerCancel = () => {
   const { useComposer } = useComposerContext();
   const disabled = useComposer((c) => !c.isEditing);
-  const callback = useCallback6(() => {
+  const callback = useCallback9(() => {
     const { cancel } = useComposer.getState();
     cancel();
   }, [useComposer]);
@@ -501,12 +645,12 @@ var useComposerIf = (props) => {
 };
 
 // src/primitive-hooks/composer/useComposerSend.tsx
-import { useCallback as useCallback7 } from "react";
+import { useCallback as useCallback10 } from "react";
 var useComposerSend = () => {
   const { useViewport, useComposer: useNewComposer } = useThreadContext();
   const { useComposer } = useComposerContext();
   const disabled = useComposer((c) => !c.isEditing || c.value.length === 0);
-  const callback = useCallback7(() => {
+  const callback = useCallback10(() => {
     const composerState = useComposer.getState();
     if (!composerState.isEditing) return;
     composerState.send();
@@ -543,17 +687,6 @@ var useContentPartImage = () => {
   return image;
 };
 
-// src/primitive-hooks/contentPart/useContentPartInProgressIndicator.tsx
-var useContentPartInProgressIndicator = () => {
-  const { useMessageUtils } = useMessageContext();
-  const { useContentPart } = useContentPartContext();
-  const indicator = useCombinedStore(
-    [useMessageUtils, useContentPart],
-    (m, c) => c.status === "in_progress" ? m.inProgressIndicator : null
-  );
-  return indicator;
-};
-
 // src/primitive-hooks/contentPart/useContentPartText.tsx
 var useContentPartText = () => {
   const { useContentPart } = useContentPartContext();
@@ -586,14 +719,17 @@ var useMessageIf = (props) => {
 
 // src/primitive-hooks/thread/useThreadIf.tsx
 var useThreadIf = (props) => {
-  const { useThread } = useThreadContext();
-  return useThread((thread) => {
-    if (props.empty === true && thread.messages.length !== 0) return false;
-    if (props.empty === false && thread.messages.length === 0) return false;
-    if (props.running === true && !thread.isRunning) return false;
-    if (props.running === false && thread.isRunning) return false;
-    return true;
-  });
+  const { useThread, useThreadMessages } = useThreadContext();
+  return useCombinedStore(
+    [useThread, useThreadMessages],
+    (thread, messages) => {
+      if (props.empty === true && messages.length !== 0) return false;
+      if (props.empty === false && messages.length === 0) return false;
+      if (props.running === true && !thread.isRunning) return false;
+      if (props.running === false && thread.isRunning) return false;
+      return true;
+    }
+  );
 };
 
 // src/primitive-hooks/thread/useThreadEmpty.tsx
@@ -602,11 +738,11 @@ var useThreadEmpty = () => {
 };
 
 // src/primitive-hooks/thread/useThreadScrollToBottom.tsx
-import { useCallback as useCallback8 } from "react";
+import { useCallback as useCallback11 } from "react";
 var useThreadScrollToBottom = () => {
   const { useComposer, useViewport } = useThreadContext();
   const isAtBottom = useViewport((s) => s.isAtBottom);
-  const handleScrollToBottom = useCallback8(() => {
+  const handleScrollToBottom = useCallback11(() => {
     useViewport.getState().scrollToBottom();
     useComposer.getState().focus();
   }, [useViewport, useComposer]);
@@ -615,14 +751,14 @@ var useThreadScrollToBottom = () => {
 };
 
 // src/primitive-hooks/thread/useThreadSuggestion.tsx
-import { useCallback as useCallback9 } from "react";
+import { useCallback as useCallback12 } from "react";
 var useThreadSuggestion = ({
   prompt,
   autoSend
 }) => {
   const { useThread, useComposer } = useThreadContext();
   const disabled = useThread((t) => t.isRunning);
-  const callback = useCallback9(() => {
+  const callback = useCallback12(() => {
     const thread = useThread.getState();
     const composer = useComposer.getState();
     composer.setValue(prompt);
@@ -637,16 +773,17 @@ var useThreadSuggestion = ({
 // src/primitives/actionBar/index.ts
 var actionBar_exports = {};
 __export(actionBar_exports, {
-  Copy: () => ActionBarCopy,
-  Edit: () => ActionBarEdit,
-  Reload: () => ActionBarReload,
-  Root: () => ActionBarRoot
+  Copy: () => ActionBarPrimitiveCopy,
+  Edit: () => ActionBarPrimitiveEdit,
+  Reload: () => ActionBarPrimitiveReload,
+  Root: () => ActionBarPrimitiveRoot
 });
 
 // src/primitives/actionBar/ActionBarRoot.tsx
 import { Primitive } from "@radix-ui/react-primitive";
 import { forwardRef } from "react";
-import { jsx as jsx4 } from "react/jsx-runtime";
+
+// src/primitives/actionBar/useActionBarFloatStatus.tsx
 var useActionBarFloatStatus = ({
   hideWhenRunning,
   autohide,
@@ -667,7 +804,10 @@ var useActionBarFloatStatus = ({
     }
   );
 };
-var ActionBarRoot = forwardRef(({ hideWhenRunning, autohide, autohideFloat, ...rest }, ref) => {
+
+// src/primitives/actionBar/ActionBarRoot.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var ActionBarPrimitiveRoot = forwardRef(({ hideWhenRunning, autohide, autohideFloat, ...rest }, ref) => {
   const hideAndfloatStatus = useActionBarFloatStatus({
     hideWhenRunning,
     autohide,
@@ -683,7 +823,7 @@ var ActionBarRoot = forwardRef(({ hideWhenRunning, autohide, autohideFloat, ...r
     }
   );
 });
-ActionBarRoot.displayName = "ActionBarRoot";
+ActionBarPrimitiveRoot.displayName = "ActionBarPrimitive.Root";
 
 // src/utils/createActionButton.tsx
 import { composeEventHandlers } from "@radix-ui/primitive";
@@ -711,52 +851,55 @@ var createActionButton = (displayName, useActionButton) => {
 };
 
 // src/primitives/actionBar/ActionBarCopy.tsx
-var ActionBarCopy = createActionButton(
-  "ActionBarCopy",
+var ActionBarPrimitiveCopy = createActionButton(
+  "ActionBarPrimitive.Copy",
   useActionBarCopy
 );
 
 // src/primitives/actionBar/ActionBarReload.tsx
-var ActionBarReload = createActionButton(
-  "ActionBarReload",
+var ActionBarPrimitiveReload = createActionButton(
+  "ActionBarPrimitive.Reload",
   useActionBarReload
 );
 
 // src/primitives/actionBar/ActionBarEdit.tsx
-var ActionBarEdit = createActionButton(
-  "ActionBarEdit",
+var ActionBarPrimitiveEdit = createActionButton(
+  "ActionBarPrimitive.Edit",
   useActionBarEdit
 );
 
 // src/primitives/assistantModal/index.ts
 var assistantModal_exports = {};
 __export(assistantModal_exports, {
-  Content: () => AssistantModalContent,
-  Root: () => AssistantModalRoot,
-  Trigger: () => AssistantModalTrigger
+  Content: () => AssistantModalPrimitiveContent,
+  Root: () => AssistantModalPrimitiveRoot,
+  Trigger: () => AssistantModalPrimitiveTrigger
 });
 
 // src/primitives/assistantModal/AssistantModalRoot.tsx
 import { useState as useState3 } from "react";
-import * as PopoverPrimitive from "@radix-ui/react-popover";
+import * as PopoverPrimitive2 from "@radix-ui/react-popover";
 import { composeEventHandlers as composeEventHandlers2 } from "@radix-ui/primitive";
 
 // src/utils/hooks/useOnComposerFocus.tsx
 import { useCallbackRef } from "@radix-ui/react-use-callback-ref";
-import { useEffect as useEffect3 } from "react";
+import { useEffect as useEffect6 } from "react";
 var useOnComposerFocus = (callback) => {
   const callbackRef = useCallbackRef(callback);
   const { useComposer } = useThreadContext();
-  useEffect3(() => {
+  useEffect6(() => {
     return useComposer.getState().onFocus(() => {
       callbackRef();
     });
   }, [useComposer, callbackRef]);
 };
 
+// src/primitives/assistantModal/scope.tsx
+import * as PopoverPrimitive from "@radix-ui/react-popover";
+var usePopoverScope = PopoverPrimitive.createPopoverScope();
+
 // src/primitives/assistantModal/AssistantModalRoot.tsx
 import { jsx as jsx6 } from "react/jsx-runtime";
-var usePopoverScope = PopoverPrimitive.createPopoverScope();
 var useAssistantModalOpenState = (defaultOpen = false) => {
   const state = useState3(defaultOpen);
   const [, setOpen] = state;
@@ -765,7 +908,7 @@ var useAssistantModalOpenState = (defaultOpen = false) => {
   });
   return state;
 };
-var AssistantModalRoot = ({
+var AssistantModalPrimitiveRoot = ({
   __scopeAssistantModal,
   defaultOpen,
   open,
@@ -775,7 +918,7 @@ var AssistantModalRoot = ({
   const scope = usePopoverScope(__scopeAssistantModal);
   const [modalOpen, setOpen] = useAssistantModalOpenState(defaultOpen);
   return /* @__PURE__ */ jsx6(
-    PopoverPrimitive.Root,
+    PopoverPrimitive2.Root,
     {
       ...scope,
       open: open === void 0 ? modalOpen : open,
@@ -784,26 +927,29 @@ var AssistantModalRoot = ({
     }
   );
 };
-AssistantModalRoot.displayName = "AssistantModalRoot";
+AssistantModalPrimitiveRoot.displayName = "AssistantModalPrimitive.Root";
 
 // src/primitives/assistantModal/AssistantModalTrigger.tsx
 import { forwardRef as forwardRef3 } from "react";
-import * as PopoverPrimitive2 from "@radix-ui/react-popover";
+import * as PopoverPrimitive3 from "@radix-ui/react-popover";
 import { jsx as jsx7 } from "react/jsx-runtime";
-var AssistantModalTrigger = forwardRef3(
-  ({ __scopeAssistantModal, ...rest }, ref) => {
+var AssistantModalPrimitiveTrigger = forwardRef3(
+  ({
+    __scopeAssistantModal,
+    ...rest
+  }, ref) => {
     const scope = usePopoverScope(__scopeAssistantModal);
-    return /* @__PURE__ */ jsx7(PopoverPrimitive2.Trigger, { ...scope, ...rest, ref });
+    return /* @__PURE__ */ jsx7(PopoverPrimitive3.Trigger, { ...scope, ...rest, ref });
   }
 );
-AssistantModalTrigger.displayName = "AssistantModalTrigger";
+AssistantModalPrimitiveTrigger.displayName = "AssistantModalPrimitive.Trigger";
 
 // src/primitives/assistantModal/AssistantModalContent.tsx
 import { forwardRef as forwardRef4 } from "react";
-import * as PopoverPrimitive3 from "@radix-ui/react-popover";
+import * as PopoverPrimitive4 from "@radix-ui/react-popover";
 import { composeEventHandlers as composeEventHandlers3 } from "@radix-ui/primitive";
 import { jsx as jsx8 } from "react/jsx-runtime";
-var AssistantModalContent = forwardRef4(
+var AssistantModalPrimitiveContent = forwardRef4(
   ({
     __scopeAssistantModal,
     side,
@@ -813,8 +959,8 @@ var AssistantModalContent = forwardRef4(
     ...props
   }, forwardedRef) => {
     const scope = usePopoverScope(__scopeAssistantModal);
-    return /* @__PURE__ */ jsx8(PopoverPrimitive3.Portal, { ...scope, children: /* @__PURE__ */ jsx8(
-      PopoverPrimitive3.Content,
+    return /* @__PURE__ */ jsx8(PopoverPrimitive4.Portal, { ...scope, children: /* @__PURE__ */ jsx8(
+      PopoverPrimitive4.Content,
       {
         ...scope,
         ...props,
@@ -829,43 +975,45 @@ var AssistantModalContent = forwardRef4(
     ) });
   }
 );
-AssistantModalContent.displayName = "AssistantModalContent";
+AssistantModalPrimitiveContent.displayName = "AssistantModalPrimitive.Content";
 
 // src/primitives/branchPicker/index.ts
 var branchPicker_exports = {};
 __export(branchPicker_exports, {
-  Count: () => BranchPickerCount,
-  Next: () => BranchPickerNext,
-  Number: () => BranchPickerNumber,
+  Count: () => BranchPickerPrimitiveCount,
+  Next: () => BranchPickerPrimitiveNext,
+  Number: () => BranchPickerPrimitiveNumber,
   Previous: () => BranchPickerPrevious,
-  Root: () => BranchPickerRoot
+  Root: () => BranchPickerPrimitiveRoot
 });
 
 // src/primitives/branchPicker/BranchPickerNext.tsx
-var BranchPickerNext = createActionButton(
-  "BranchPickerNext",
+var BranchPickerPrimitiveNext = createActionButton(
+  "BranchPickerPrimitive.Next",
   useBranchPickerNext
 );
 
 // src/primitives/branchPicker/BranchPickerPrevious.tsx
 var BranchPickerPrevious = createActionButton(
-  "BranchPickerPrevious",
+  "BranchPickerPrimitive.Previous",
   useBranchPickerPrevious
 );
 
 // src/primitives/branchPicker/BranchPickerCount.tsx
 import { Fragment, jsx as jsx9 } from "react/jsx-runtime";
-var BranchPickerCount = () => {
+var BranchPickerPrimitiveCount = () => {
   const branchCount = useBranchPickerCount();
   return /* @__PURE__ */ jsx9(Fragment, { children: branchCount });
 };
+BranchPickerPrimitiveCount.displayName = "BranchPickerPrimitive.Count";
 
 // src/primitives/branchPicker/BranchPickerNumber.tsx
 import { Fragment as Fragment2, jsx as jsx10 } from "react/jsx-runtime";
-var BranchPickerNumber = () => {
+var BranchPickerPrimitiveNumber = () => {
   const branchNumber = useBranchPickerNumber();
   return /* @__PURE__ */ jsx10(Fragment2, { children: branchNumber });
 };
+BranchPickerPrimitiveNumber.displayName = "BranchPickerPrimitive.Number";
 
 // src/primitives/branchPicker/BranchPickerRoot.tsx
 import { Primitive as Primitive6 } from "@radix-ui/react-primitive";
@@ -874,10 +1022,10 @@ import { forwardRef as forwardRef8 } from "react";
 // src/primitives/message/index.ts
 var message_exports = {};
 __export(message_exports, {
-  Content: () => MessageContent,
-  If: () => MessageIf,
-  InProgress: () => MessageInProgress,
-  Root: () => MessageRoot
+  Content: () => MessagePrimitiveContent,
+  If: () => MessagePrimitiveIf,
+  InProgress: () => MessagePrimitiveInProgress,
+  Root: () => MessagePrimitiveRoot
 });
 
 // src/primitives/message/MessageRoot.tsx
@@ -885,41 +1033,43 @@ import { composeEventHandlers as composeEventHandlers4 } from "@radix-ui/primiti
 import { Primitive as Primitive3 } from "@radix-ui/react-primitive";
 import { forwardRef as forwardRef5 } from "react";
 import { jsx as jsx11 } from "react/jsx-runtime";
-var MessageRoot = forwardRef5(
-  ({ onMouseEnter, onMouseLeave, ...rest }, ref) => {
-    const { useMessageUtils } = useMessageContext();
-    const setIsHovering = useMessageUtils((s) => s.setIsHovering);
-    const handleMouseEnter = () => {
-      setIsHovering(true);
-    };
-    const handleMouseLeave = () => {
-      setIsHovering(false);
-    };
-    return /* @__PURE__ */ jsx11(
-      Primitive3.div,
-      {
-        ...rest,
-        ref,
-        onMouseEnter: composeEventHandlers4(onMouseEnter, handleMouseEnter),
-        onMouseLeave: composeEventHandlers4(onMouseLeave, handleMouseLeave)
-      }
-    );
-  }
-);
-MessageRoot.displayName = "MessageRoot";
+var MessagePrimitiveRoot = forwardRef5(({ onMouseEnter, onMouseLeave, ...rest }, ref) => {
+  const { useMessageUtils } = useMessageContext();
+  const setIsHovering = useMessageUtils((s) => s.setIsHovering);
+  const handleMouseEnter = () => {
+    setIsHovering(true);
+  };
+  const handleMouseLeave = () => {
+    setIsHovering(false);
+  };
+  return /* @__PURE__ */ jsx11(
+    Primitive3.div,
+    {
+      ...rest,
+      ref,
+      onMouseEnter: composeEventHandlers4(onMouseEnter, handleMouseEnter),
+      onMouseLeave: composeEventHandlers4(onMouseLeave, handleMouseLeave)
+    }
+  );
+});
+MessagePrimitiveRoot.displayName = "MessagePrimitive.Root";
 
 // src/primitives/message/MessageIf.tsx
-var MessageIf = ({ children, ...query }) => {
+var MessagePrimitiveIf = ({
+  children,
+  ...query
+}) => {
   const result = useMessageIf(query);
   return result ? children : null;
 };
+MessagePrimitiveIf.displayName = "MessagePrimitive.If";
 
 // src/primitives/message/MessageContent.tsx
 import { memo as memo2 } from "react";
 
 // src/context/providers/ContentPartProvider.tsx
-import { useEffect as useEffect4, useState as useState4 } from "react";
-import { create as create7 } from "zustand";
+import { useEffect as useEffect7, useState as useState4 } from "react";
+import { create as create9 } from "zustand";
 import { jsx as jsx12 } from "react/jsx-runtime";
 var syncContentPart = ({ message }, useContentPart, partIndex) => {
   const part = message.content[partIndex];
@@ -938,13 +1088,13 @@ var syncContentPart = ({ message }, useContentPart, partIndex) => {
 var useContentPartContext2 = (partIndex) => {
   const { useMessage } = useMessageContext();
   const [context] = useState4(() => {
-    const useContentPart = create7(
+    const useContentPart = create9(
       () => ({})
     );
     syncContentPart(useMessage.getState(), useContentPart, partIndex);
     return { useContentPart };
   });
-  useEffect4(() => {
+  useEffect7(() => {
     syncContentPart(useMessage.getState(), context.useContentPart, partIndex);
     return useMessage.subscribe((message) => {
       syncContentPart(message, context.useContentPart, partIndex);
@@ -961,42 +1111,67 @@ var ContentPartProvider = ({
 };
 
 // src/primitives/contentPart/ContentPartDisplay.tsx
-var ContentPartDisplay = () => {
+var ContentPartPrimitiveDisplay = () => {
   const display = useContentPartDisplay();
   return display ?? null;
 };
+ContentPartPrimitiveDisplay.displayName = "ContentPartPrimitive.Display";
+
+// src/utils/OutPortal.tsx
+import { useLayoutEffect, useRef as useRef3 } from "react";
+import { jsx as jsx13 } from "react/jsx-runtime";
+var OutPortal = ({ node }) => {
+  const parentRef = useRef3(null);
+  useLayoutEffect(() => {
+    const parent = parentRef.current;
+    if (!parent || !node) return;
+    parent.appendChild(node);
+    return () => {
+      parent.removeChild(node);
+    };
+  }, [node]);
+  if (!node) return null;
+  return /* @__PURE__ */ jsx13("span", { ref: parentRef });
+};
 
 // src/primitives/contentPart/ContentPartInProgressIndicator.tsx
-var ContentPartInProgressIndicator = () => {
-  const indicator = useContentPartInProgressIndicator();
-  return indicator;
+import { jsx as jsx14 } from "react/jsx-runtime";
+var ContentPartPrimitiveInProgressIndicator = () => {
+  const { useMessageUtils } = useMessageContext();
+  const { useContentPart } = useContentPartContext();
+  const indicator = useCombinedStore(
+    [useMessageUtils, useContentPart],
+    (m, c) => c.status === "in_progress" ? m.inProgressIndicator : null
+  );
+  return /* @__PURE__ */ jsx14(OutPortal, { node: indicator });
 };
+ContentPartPrimitiveInProgressIndicator.displayName = "ContentPartPrimitive.InProgressIndicator";
 
 // src/primitives/contentPart/ContentPartText.tsx
 import { Primitive as Primitive4 } from "@radix-ui/react-primitive";
 import { forwardRef as forwardRef6 } from "react";
-import { jsx as jsx13 } from "react/jsx-runtime";
-var ContentPartText = forwardRef6((props, forwardedRef) => {
+import { jsx as jsx15 } from "react/jsx-runtime";
+var ContentPartPrimitiveText = forwardRef6((props, forwardedRef) => {
   const text = useContentPartText();
-  return /* @__PURE__ */ jsx13(Primitive4.p, { ...props, ref: forwardedRef, children: text });
+  return /* @__PURE__ */ jsx15(Primitive4.span, { ...props, ref: forwardedRef, children: text });
 });
-ContentPartText.displayName = "ContentPartText";
+ContentPartPrimitiveText.displayName = "ContentPartPrimitive.Text";
 
 // src/primitives/message/MessageContent.tsx
-import { Fragment as Fragment3, jsx as jsx14, jsxs as jsxs2 } from "react/jsx-runtime";
+import { jsx as jsx16, jsxs as jsxs2 } from "react/jsx-runtime";
 var defaultComponents = {
-  Text: () => /* @__PURE__ */ jsxs2(Fragment3, { children: [
-    /* @__PURE__ */ jsx14(ContentPartText, { style: { whiteSpace: "pre-line" } }),
-    /* @__PURE__ */ jsx14(ContentPartInProgressIndicator, {})
+  Text: () => /* @__PURE__ */ jsxs2("p", { style: { whiteSpace: "pre-line" }, children: [
+    /* @__PURE__ */ jsx16(ContentPartPrimitiveText, {}),
+    /* @__PURE__ */ jsx16(ContentPartPrimitiveInProgressIndicator, {})
   ] }),
   Image: () => null,
-  UI: () => /* @__PURE__ */ jsx14(ContentPartDisplay, {}),
+  UI: () => /* @__PURE__ */ jsx16(ContentPartPrimitiveDisplay, {}),
   tools: {
     Fallback: (props) => {
       const { useToolUIs } = useAssistantContext();
       const Render = useToolUIs((s) => s.getToolUI(props.part.toolName));
       if (!Render) return null;
-      return /* @__PURE__ */ jsx14(Render, { ...props });
+      return /* @__PURE__ */ jsx16(Render, { ...props });
     }
   }
 };
@@ -1015,15 +1190,15 @@ var MessageContentPartComponent = ({
   const type = part.type;
   switch (type) {
     case "text":
-      return /* @__PURE__ */ jsx14(Text, { part, status });
+      return /* @__PURE__ */ jsx16(Text, { part, status });
     case "image":
-      return /* @__PURE__ */ jsx14(Image, { part, status });
+      return /* @__PURE__ */ jsx16(Image, { part, status });
     case "ui":
-      return /* @__PURE__ */ jsx14(UI, { part, status });
+      return /* @__PURE__ */ jsx16(UI, { part, status });
     case "tool-call": {
       const Tool = by_name[part.toolName] || Fallback;
       const addResult = (result) => addToolResult(part.toolCallId, result);
-      return /* @__PURE__ */ jsx14(Tool, { part, status, addResult });
+      return /* @__PURE__ */ jsx16(Tool, { part, status, addResult });
     }
     default:
       throw new Error(`Unknown content part type: ${type}`);
@@ -1033,18 +1208,20 @@ var MessageContentPartImpl = ({
   partIndex,
   components
 }) => {
-  return /* @__PURE__ */ jsx14(ContentPartProvider, { partIndex, children: /* @__PURE__ */ jsx14(MessageContentPartComponent, { components }) });
+  return /* @__PURE__ */ jsx16(ContentPartProvider, { partIndex, children: /* @__PURE__ */ jsx16(MessageContentPartComponent, { components }) });
 };
 var MessageContentPart = memo2(
   MessageContentPartImpl,
   (prev, next) => prev.partIndex === next.partIndex && prev.components?.Text === next.components?.Text && prev.components?.Image === next.components?.Image && prev.components?.UI === next.components?.UI && prev.components?.tools === next.components?.tools
 );
-var MessageContent = ({ components }) => {
+var MessagePrimitiveContent = ({
+  components
+}) => {
   const { useMessage } = useMessageContext();
   const contentLength = useMessage((s) => s.message.content.length);
   return new Array(contentLength).fill(null).map((_, idx) => {
     const partIndex = idx;
-    return /* @__PURE__ */ jsx14(
+    return /* @__PURE__ */ jsx16(
       MessageContentPart,
       {
         partIndex,
@@ -1054,38 +1231,35 @@ var MessageContent = ({ components }) => {
     );
   });
 };
+MessagePrimitiveContent.displayName = "MessagePrimitive.Content";
 
 // src/primitives/message/MessageInProgress.tsx
+import { createPortal } from "react-dom";
 import { Primitive as Primitive5 } from "@radix-ui/react-primitive";
-import {
-  forwardRef as forwardRef7,
-  useMemo as useMemo3
-} from "react";
-import { jsx as jsx15 } from "react/jsx-runtime";
-var MessageInProgress = forwardRef7((props, ref) => {
+import { forwardRef as forwardRef7 } from "react";
+import { jsx as jsx17 } from "react/jsx-runtime";
+var MessagePrimitiveInProgress = forwardRef7((props, ref) => {
   const { useMessageUtils } = useMessageContext();
-  useMemo3(() => {
-    useMessageUtils.getState().setInProgressIndicator(/* @__PURE__ */ jsx15(Primitive5.span, { ...props, ref }));
-  }, [useMessageUtils, props, ref]);
-  return null;
+  const portalNode = useMessageUtils((s) => s.inProgressIndicator);
+  return createPortal(/* @__PURE__ */ jsx17(Primitive5.span, { ...props, ref }), portalNode);
 });
-MessageInProgress.displayName = "MessageInProgress";
+MessagePrimitiveInProgress.displayName = "MessagePrimitive.InProgress";
 
 // src/primitives/branchPicker/BranchPickerRoot.tsx
-import { jsx as jsx16 } from "react/jsx-runtime";
-var BranchPickerRoot = forwardRef8(({ hideWhenSingleBranch, ...rest }, ref) => {
-  return /* @__PURE__ */ jsx16(MessageIf, { hasBranches: hideWhenSingleBranch ? true : void 0, children: /* @__PURE__ */ jsx16(Primitive6.div, { ...rest, ref }) });
+import { jsx as jsx18 } from "react/jsx-runtime";
+var BranchPickerPrimitiveRoot = forwardRef8(({ hideWhenSingleBranch, ...rest }, ref) => {
+  return /* @__PURE__ */ jsx18(MessagePrimitiveIf, { hasBranches: hideWhenSingleBranch ? true : void 0, children: /* @__PURE__ */ jsx18(Primitive6.div, { ...rest, ref }) });
 });
-BranchPickerRoot.displayName = "BranchPickerRoot";
+BranchPickerPrimitiveRoot.displayName = "BranchPickerPrimitive.Root";
 
 // src/primitives/composer/index.ts
 var composer_exports = {};
 __export(composer_exports, {
-  Cancel: () => ComposerCancel,
-  If: () => ComposerIf,
-  Input: () => ComposerInput,
-  Root: () => ComposerRoot,
-  Send: () => ComposerSend
+  Cancel: () => ComposerPrimitiveCancel,
+  If: () => ComposerPrimitiveIf,
+  Input: () => ComposerPrimitiveInput,
+  Root: () => ComposerPrimitiveRoot,
+  Send: () => ComposerPrimitiveSend
 });
 
 // src/primitives/composer/ComposerRoot.tsx
@@ -1094,26 +1268,24 @@ import { Primitive as Primitive7 } from "@radix-ui/react-primitive";
 import {
   forwardRef as forwardRef9
 } from "react";
-import { jsx as jsx17 } from "react/jsx-runtime";
-var ComposerRoot = forwardRef9(
-  ({ onSubmit, ...rest }, forwardedRef) => {
-    const send = useComposerSend();
-    const handleSubmit = (e) => {
-      if (!send) return;
-      e.preventDefault();
-      send();
-    };
-    return /* @__PURE__ */ jsx17(
-      Primitive7.form,
-      {
-        ...rest,
-        ref: forwardedRef,
-        onSubmit: composeEventHandlers5(onSubmit, handleSubmit)
-      }
-    );
-  }
-);
-ComposerRoot.displayName = "ComposerRoot";
+import { jsx as jsx19 } from "react/jsx-runtime";
+var ComposerPrimitiveRoot = forwardRef9(({ onSubmit, ...rest }, forwardedRef) => {
+  const send = useComposerSend();
+  const handleSubmit = (e) => {
+    e.preventDefault();
+    if (!send) return;
+    send();
+  };
+  return /* @__PURE__ */ jsx19(
+    Primitive7.form,
+    {
+      ...rest,
+      ref: forwardedRef,
+      onSubmit: composeEventHandlers5(onSubmit, handleSubmit)
+    }
+  );
+});
+ComposerPrimitiveRoot.displayName = "ComposerPrimitive.Root";
 
 // src/primitives/composer/ComposerInput.tsx
 import { composeEventHandlers as composeEventHandlers6 } from "@radix-ui/primitive";
@@ -1121,14 +1293,14 @@ import { useComposedRefs } from "@radix-ui/react-compose-refs";
 import { Slot } from "@radix-ui/react-slot";
 import {
   forwardRef as forwardRef10,
-  useCallback as useCallback10,
-  useEffect as useEffect5,
-  useRef as useRef3
+  useCallback as useCallback13,
+  useEffect as useEffect8,
+  useRef as useRef4
 } from "react";
 import TextareaAutosize from "react-textarea-autosize";
 import { useEscapeKeydown } from "@radix-ui/react-use-escape-keydown";
-import { jsx as jsx18 } from "react/jsx-runtime";
-var ComposerInput = forwardRef10(
+import { jsx as jsx20 } from "react/jsx-runtime";
+var ComposerPrimitiveInput = forwardRef10(
   ({ autoFocus = false, asChild, disabled, onChange, onKeyDown, ...rest }, forwardedRef) => {
     const { useThread } = useThreadContext();
     const { useComposer, type } = useComposerContext();
@@ -1137,7 +1309,7 @@ var ComposerInput = forwardRef10(
       return c.value;
     });
     const Component = asChild ? Slot : TextareaAutosize;
-    const textareaRef = useRef3(null);
+    const textareaRef = useRef4(null);
     const ref = useComposedRefs(forwardedRef, textareaRef);
     useEscapeKeydown((e) => {
       const composer = useComposer.getState();
@@ -1156,7 +1328,7 @@ var ComposerInput = forwardRef10(
       }
     };
     const autoFocusEnabled = autoFocus && !disabled;
-    const focus = useCallback10(() => {
+    const focus = useCallback13(() => {
       const textarea = textareaRef.current;
       if (!textarea || !autoFocusEnabled) return;
       textarea.focus({ preventScroll: true });
@@ -1165,13 +1337,13 @@ var ComposerInput = forwardRef10(
         textareaRef.current.value.length
       );
     }, [autoFocusEnabled]);
-    useEffect5(() => focus(), [focus]);
+    useEffect8(() => focus(), [focus]);
     useOnComposerFocus(() => {
       if (type === "new") {
         focus();
       }
     });
-    return /* @__PURE__ */ jsx18(
+    return /* @__PURE__ */ jsx20(
       Component,
       {
         value,
@@ -1188,94 +1360,101 @@ var ComposerInput = forwardRef10(
     );
   }
 );
-ComposerInput.displayName = "ComposerInput";
+ComposerPrimitiveInput.displayName = "ComposerPrimitive.Input";
 
 // src/primitives/composer/ComposerSend.tsx
 import { forwardRef as forwardRef11 } from "react";
 import { Primitive as Primitive8 } from "@radix-ui/react-primitive";
-import { jsx as jsx19 } from "react/jsx-runtime";
-var ComposerSend = forwardRef11(
-  ({ disabled, ...rest }, ref) => {
-    const { useComposer } = useComposerContext();
-    const hasValue = useComposer((c) => c.isEditing && c.value.length > 0);
-    return /* @__PURE__ */ jsx19(
-      Primitive8.button,
-      {
-        type: "submit",
-        ...rest,
-        ref,
-        disabled: disabled || !hasValue
-      }
-    );
-  }
-);
-ComposerSend.displayName = "ComposerSend";
+import { jsx as jsx21 } from "react/jsx-runtime";
+var ComposerPrimitiveSend = forwardRef11(({ disabled, ...rest }, ref) => {
+  const { useComposer } = useComposerContext();
+  const hasValue = useComposer((c) => c.isEditing && c.value.length > 0);
+  return /* @__PURE__ */ jsx21(
+    Primitive8.button,
+    {
+      type: "submit",
+      ...rest,
+      ref,
+      disabled: disabled || !hasValue
+    }
+  );
+});
+ComposerPrimitiveSend.displayName = "ComposerPrimitive.Send";
 
 // src/primitives/composer/ComposerCancel.tsx
-var ComposerCancel = createActionButton(
-  "ComposerCancel",
+var ComposerPrimitiveCancel = createActionButton(
+  "ComposerPrimitive.Cancel",
   useComposerCancel
 );
 
 // src/primitives/composer/ComposerIf.tsx
-var ComposerIf = ({ children, ...query }) => {
+var ComposerPrimitiveIf = ({
+  children,
+  ...query
+}) => {
   const result = useComposerIf(query);
   return result ? children : null;
 };
+ComposerPrimitiveIf.displayName = "ComposerPrimitive.If";
 
 // src/primitives/contentPart/index.ts
 var contentPart_exports = {};
 __export(contentPart_exports, {
-  Display: () => ContentPartDisplay,
-  Image: () => ContentPartImage,
-  InProgressIndicator: () => ContentPartInProgressIndicator,
-  Text: () => ContentPartText
+  Display: () => ContentPartPrimitiveDisplay,
+  Image: () => ContentPartPrimitiveImage,
+  InProgressIndicator: () => ContentPartPrimitiveInProgressIndicator,
+  Text: () => ContentPartPrimitiveText
 });
 
 // src/primitives/contentPart/ContentPartImage.tsx
 import { Primitive as Primitive9 } from "@radix-ui/react-primitive";
 import { forwardRef as forwardRef12 } from "react";
-import { jsx as jsx20 } from "react/jsx-runtime";
-var ContentPartImage = forwardRef12((props, forwardedRef) => {
+import { jsx as jsx22 } from "react/jsx-runtime";
+var ContentPartPrimitiveImage = forwardRef12((props, forwardedRef) => {
   const image = useContentPartImage();
-  return /* @__PURE__ */ jsx20(Primitive9.img, { src: image, ...props, ref: forwardedRef });
+  return /* @__PURE__ */ jsx22(Primitive9.img, { src: image, ...props, ref: forwardedRef });
 });
-ContentPartImage.displayName = "ContentPartImage";
+ContentPartPrimitiveImage.displayName = "ContentPartPrimitive.Image";
 
 // src/primitives/thread/index.ts
 var thread_exports = {};
 __export(thread_exports, {
-  Empty: () => ThreadEmpty,
-  If: () => ThreadIf,
-  Messages: () => ThreadMessages,
-  Root: () => ThreadRoot,
-  ScrollToBottom: () => ThreadScrollToBottom,
-  Suggestion: () => ThreadSuggestion,
-  Viewport: () => ThreadViewport
+  Empty: () => ThreadPrimitiveEmpty,
+  If: () => ThreadPrimitiveIf,
+  Messages: () => ThreadPrimitiveMessages,
+  Root: () => ThreadPrimitiveRoot,
+  ScrollToBottom: () => ThreadPrimitiveScrollToBottom,
+  Suggestion: () => ThreadPrimitiveSuggestion,
+  Viewport: () => ThreadPrimitiveViewport
 });
 
 // src/primitives/thread/ThreadRoot.tsx
 import { Primitive as Primitive10 } from "@radix-ui/react-primitive";
 import { forwardRef as forwardRef13 } from "react";
-import { jsx as jsx21 } from "react/jsx-runtime";
-var ThreadRoot = forwardRef13(
-  (props, ref) => {
-    return /* @__PURE__ */ jsx21(Primitive10.div, { ...props, ref });
-  }
-);
-ThreadRoot.displayName = "ThreadRoot";
+import { jsx as jsx23 } from "react/jsx-runtime";
+var ThreadPrimitiveRoot = forwardRef13((props, ref) => {
+  return /* @__PURE__ */ jsx23(Primitive10.div, { ...props, ref });
+});
+ThreadPrimitiveRoot.displayName = "ThreadPrimitive.Root";
 
 // src/primitives/thread/ThreadEmpty.tsx
-var ThreadEmpty = ({ children }) => {
+var ThreadPrimitiveEmpty = ({
+  children
+}) => {
   const empty = useThreadEmpty();
   return empty ? children : null;
 };
+ThreadPrimitiveEmpty.displayName = "ThreadPrimitive.Empty";
 
 // src/primitives/thread/ThreadIf.tsx
-var ThreadIf = ({ children, ...query }) => {
+var ThreadPrimitiveIf = ({
+  children,
+  ...query
+}) => {
   const result = useThreadIf(query);
   return result ? children : null;
 };
+ThreadPrimitiveIf.displayName = "ThreadPrimitive.If";
 
 // src/primitives/thread/ThreadViewport.tsx
 import { useComposedRefs as useComposedRefs3 } from "@radix-ui/react-compose-refs";
@@ -1284,17 +1463,17 @@ import { forwardRef as forwardRef14 } from "react";
 
 // src/primitive-hooks/thread/useThreadViewportAutoScroll.tsx
 import { useComposedRefs as useComposedRefs2 } from "@radix-ui/react-compose-refs";
-import { useRef as useRef5 } from "react";
+import { useRef as useRef6 } from "react";
 
 // src/utils/hooks/useOnResizeContent.tsx
 import { useCallbackRef as useCallbackRef2 } from "@radix-ui/react-use-callback-ref";
-import { useCallback as useCallback12 } from "react";
+import { useCallback as useCallback15 } from "react";
 
 // src/utils/hooks/useManagedRef.ts
-import { useCallback as useCallback11, useRef as useRef4 } from "react";
+import { useCallback as useCallback14, useRef as useRef5 } from "react";
 var useManagedRef = (callback) => {
-  const cleanupRef = useRef4();
-  const ref = useCallback11(
+  const cleanupRef = useRef5();
+  const ref = useCallback14(
     (el) => {
       if (cleanupRef.current) {
         cleanupRef.current();
@@ -1311,7 +1490,7 @@ var useManagedRef = (callback) => {
 // src/utils/hooks/useOnResizeContent.tsx
 var useOnResizeContent = (callback) => {
   const callbackRef = useCallbackRef2(callback);
-  const refCallback = useCallback12(
+  const refCallback = useCallback15(
     (el) => {
       const resizeObserver = new ResizeObserver(() => {
         callbackRef();
@@ -1348,11 +1527,11 @@ var useOnResizeContent = (callback) => {
 
 // src/utils/hooks/useOnScrollToBottom.tsx
 import { useCallbackRef as useCallbackRef3 } from "@radix-ui/react-use-callback-ref";
-import { useEffect as useEffect6 } from "react";
+import { useEffect as useEffect9 } from "react";
 var useOnScrollToBottom = (callback) => {
   const callbackRef = useCallbackRef3(callback);
   const { useViewport } = useThreadContext();
-  useEffect6(() => {
+  useEffect9(() => {
     return useViewport.getState().onScrollToBottom(() => {
       callbackRef();
     });
@@ -1363,11 +1542,11 @@ var useOnScrollToBottom = (callback) => {
 var useThreadViewportAutoScroll = ({
   autoScroll = true
 }) => {
-  const divRef = useRef5(null);
+  const divRef = useRef6(null);
   const { useViewport } = useThreadContext();
-  const firstRenderRef = useRef5(true);
-  const lastScrollTop = useRef5(0);
-  const isScrollingToBottomRef = useRef5(false);
+  const firstRenderRef = useRef6(true);
+  const lastScrollTop = useRef6(0);
+  const isScrollingToBottomRef = useRef6(false);
   const scrollToBottom = () => {
     const div = divRef.current;
     if (!div || !autoScroll) return;
@@ -1413,29 +1592,29 @@ var useThreadViewportAutoScroll = ({
 };
 
 // src/primitives/thread/ThreadViewport.tsx
-import { jsx as jsx22 } from "react/jsx-runtime";
-var ThreadViewport = forwardRef14(({ autoScroll, onScroll, children, ...rest }, forwardedRef) => {
+import { jsx as jsx24 } from "react/jsx-runtime";
+var ThreadPrimitiveViewport = forwardRef14(({ autoScroll, onScroll, children, ...rest }, forwardedRef) => {
   const autoScrollRef = useThreadViewportAutoScroll({
     autoScroll
   });
   const ref = useComposedRefs3(forwardedRef, autoScrollRef);
-  return /* @__PURE__ */ jsx22(Primitive11.div, { ...rest, ref, children });
+  return /* @__PURE__ */ jsx24(Primitive11.div, { ...rest, ref, children });
 });
-ThreadViewport.displayName = "ThreadViewport";
+ThreadPrimitiveViewport.displayName = "ThreadPrimitive.Viewport";
 
 // src/primitives/thread/ThreadMessages.tsx
 import { memo as memo3 } from "react";
 
 // src/context/providers/MessageProvider.tsx
-import { useEffect as useEffect7, useState as useState5 } from "react";
-import { create as create10 } from "zustand";
+import { useEffect as useEffect10, useState as useState5 } from "react";
+import { create as create12 } from "zustand";
 
 // src/context/stores/EditComposer.ts
-import { create as create8 } from "zustand";
+import { create as create10 } from "zustand";
 var makeEditComposerStore = ({
   onEdit,
   onSend
-}) => create8()((set, get, store) => ({
+}) => create10()((set, get, store) => ({
   ...makeBaseComposer(set, get, store),
   isEditing: false,
   edit: () => {
@@ -1455,12 +1634,9 @@ var makeEditComposerStore = ({
 }));
 
 // src/context/stores/MessageUtils.ts
-import { create as create9 } from "zustand";
-var makeMessageUtilsStore = () => create9((set) => ({
-  inProgressIndicator: null,
-  setInProgressIndicator: (value) => {
-    set({ inProgressIndicator: value });
-  },
+import { create as create11 } from "zustand";
+var makeMessageUtilsStore = () => create11((set) => ({
+  inProgressIndicator: document.createElement("span"),
   isCopied: false,
   setIsCopied: (value) => {
     set({ isCopied: value });
@@ -1472,15 +1648,15 @@ var makeMessageUtilsStore = () => create9((set) => ({
 }));
 
 // src/context/providers/MessageProvider.tsx
-import { jsx as jsx23 } from "react/jsx-runtime";
-var getIsLast = (thread, message) => {
-  return thread.messages[thread.messages.length - 1]?.id === message.id;
+import { jsx as jsx25 } from "react/jsx-runtime";
+var getIsLast = (messages, message) => {
+  return messages[messages.length - 1]?.id === message.id;
 };
-var syncMessage = (thread, getBranches, useMessage, messageIndex) => {
-  const parentId = thread.messages[messageIndex - 1]?.id ?? null;
-  const message = thread.messages[messageIndex];
+var syncMessage = (messages, getBranches, useMessage, messageIndex) => {
+  const parentId = messages[messageIndex - 1]?.id ?? null;
+  const message = messages[messageIndex];
   if (!message) return;
-  const isLast = getIsLast(thread, message);
+  const isLast = getIsLast(messages, message);
   const branches = getBranches(message.id);
   const currentState = useMessage.getState();
   if (currentState.message === message && currentState.parentId === parentId && currentState.branches === branches && currentState.isLast === isLast)
@@ -1493,9 +1669,9 @@ var syncMessage = (thread, getBranches, useMessage, messageIndex) => {
   });
 };
 var useMessageContext2 = (messageIndex) => {
-  const { useThread, useThreadActions } = useThreadContext();
+  const { useThreadMessages, useThreadActions } = useThreadContext();
   const [context] = useState5(() => {
-    const useMessage = create10(() => ({}));
+    const useMessage = create12(() => ({}));
     const useMessageUtils = makeMessageUtilsStore();
     const useEditComposer = makeEditComposerStore({
       onEdit: () => {
@@ -1524,15 +1700,15 @@ var useMessageContext2 = (messageIndex) => {
       }
     });
     syncMessage(
-      useThread.getState(),
+      useThreadMessages.getState(),
       useThreadActions.getState().getBranches,
       useMessage,
       messageIndex
     );
     return { useMessage, useMessageUtils, useEditComposer };
   });
-  useEffect7(() => {
-    return useThread.subscribe((thread) => {
+  useEffect10(() => {
+    return useThreadMessages.subscribe((thread) => {
       syncMessage(
         thread,
         useThreadActions.getState().getBranches,
@@ -1540,7 +1716,7 @@ var useMessageContext2 = (messageIndex) => {
         messageIndex
       );
     });
-  }, [useThread, useThreadActions, context, messageIndex]);
+  }, [useThreadMessages, useThreadActions, context, messageIndex]);
   return context;
 };
 var MessageProvider = ({
@@ -1548,11 +1724,11 @@ var MessageProvider = ({
   children
 }) => {
   const context = useMessageContext2(messageIndex);
-  return /* @__PURE__ */ jsx23(MessageContext.Provider, { value: context, children });
+  return /* @__PURE__ */ jsx25(MessageContext.Provider, { value: context, children });
 };
 
 // src/primitives/thread/ThreadMessages.tsx
-import { jsx as jsx24, jsxs as jsxs3 } from "react/jsx-runtime";
+import { jsx as jsx26, jsxs as jsxs3 } from "react/jsx-runtime";
 var getComponents = (components) => {
   return {
     EditComposer: components.EditComposer ?? components.UserMessage ?? components.Message,
@@ -1566,24 +1742,26 @@ var ThreadMessageImpl = ({
 }) => {
   const { UserMessage, EditComposer, AssistantMessage } = getComponents(components);
   return /* @__PURE__ */ jsxs3(MessageProvider, { messageIndex, children: [
-    /* @__PURE__ */ jsxs3(MessageIf, { user: true, children: [
-      /* @__PURE__ */ jsx24(ComposerIf, { editing: false, children: /* @__PURE__ */ jsx24(UserMessage, {}) }),
-      /* @__PURE__ */ jsx24(ComposerIf, { editing: true, children: /* @__PURE__ */ jsx24(EditComposer, {}) })
+    /* @__PURE__ */ jsxs3(MessagePrimitiveIf, { user: true, children: [
+      /* @__PURE__ */ jsx26(ComposerPrimitiveIf, { editing: false, children: /* @__PURE__ */ jsx26(UserMessage, {}) }),
+      /* @__PURE__ */ jsx26(ComposerPrimitiveIf, { editing: true, children: /* @__PURE__ */ jsx26(EditComposer, {}) })
     ] }),
-    /* @__PURE__ */ jsx24(MessageIf, { assistant: true, children: /* @__PURE__ */ jsx24(AssistantMessage, {}) })
+    /* @__PURE__ */ jsx26(MessagePrimitiveIf, { assistant: true, children: /* @__PURE__ */ jsx26(AssistantMessage, {}) })
   ] });
 };
 var ThreadMessage = memo3(
   ThreadMessageImpl,
   (prev, next) => prev.messageIndex === next.messageIndex && prev.components.UserMessage === next.components.UserMessage && prev.components.EditComposer === next.components.EditComposer && prev.components.AssistantMessage === next.components.AssistantMessage
 );
-var ThreadMessages = ({ components }) => {
-  const { useThread } = useThreadContext();
-  const messagesLength = useThread((t) => t.messages.length);
+var ThreadPrimitiveMessages = ({
+  components
+}) => {
+  const { useThreadMessages } = useThreadContext();
+  const messagesLength = useThreadMessages((t) => t.length);
   if (messagesLength === 0) return null;
   return new Array(messagesLength).fill(null).map((_, idx) => {
     const messageIndex = idx;
-    return /* @__PURE__ */ jsx24(
+    return /* @__PURE__ */ jsx26(
       ThreadMessage,
       {
         messageIndex,
@@ -1593,16 +1771,17 @@ var ThreadMessages = ({ components }) => {
     );
   });
 };
+ThreadPrimitiveMessages.displayName = "ThreadPrimitive.Messages";
 
 // src/primitives/thread/ThreadScrollToBottom.tsx
-var ThreadScrollToBottom = createActionButton(
-  "ThreadScrollToBottom",
+var ThreadPrimitiveScrollToBottom = createActionButton(
+  "ThreadPrimitive.ScrollToBottom",
   useThreadScrollToBottom
 );
 
 // src/primitives/thread/ThreadSuggestion.tsx
-var ThreadSuggestion = createActionButton(
-  "ThreadSuggestion",
+var ThreadPrimitiveSuggestion = createActionButton(
+  "ThreadPrimitive.Suggestion",
   useThreadSuggestion
 );
 
@@ -1769,13 +1948,91 @@ var MessageRepository = class {
   }
 };
 
+// src/runtime/core/BaseAssistantRuntime.tsx
+var BaseAssistantRuntime = class {
+  constructor(_thread) {
+    this._thread = _thread;
+    this._thread = _thread;
+    this._unsubscribe = this._thread.subscribe(this.subscriptionHandler);
+  }
+  _unsubscribe;
+  get thread() {
+    return this._thread;
+  }
+  set thread(thread) {
+    this._unsubscribe();
+    this._thread = thread;
+    this._unsubscribe = this._thread.subscribe(this.subscriptionHandler);
+    this.subscriptionHandler();
+  }
+  get messages() {
+    return this.thread.messages;
+  }
+  get isRunning() {
+    return this.thread.isRunning;
+  }
+  getBranches(messageId) {
+    return this.thread.getBranches(messageId);
+  }
+  switchToBranch(branchId) {
+    return this.thread.switchToBranch(branchId);
+  }
+  append(message) {
+    return this.thread.append(message);
+  }
+  startRun(parentId) {
+    return this.thread.startRun(parentId);
+  }
+  cancelRun() {
+    return this.thread.cancelRun();
+  }
+  addToolResult(toolCallId, result) {
+    return this.thread.addToolResult(toolCallId, result);
+  }
+  _subscriptions = /* @__PURE__ */ new Set();
+  subscribe(callback) {
+    this._subscriptions.add(callback);
+    return () => this._subscriptions.delete(callback);
+  }
+  subscriptionHandler = () => {
+    for (const callback of this._subscriptions) callback();
+  };
+  get unstable_synchronizer() {
+    return this.thread.unstable_synchronizer;
+  }
+};
+
 // src/runtime/local/LocalRuntime.tsx
-var LocalRuntime = class {
+var LocalRuntime = class extends BaseAssistantRuntime {
+  _configProviders;
   constructor(adapter) {
+    const configProviders = /* @__PURE__ */ new Set();
+    super(new LocalThreadRuntime(configProviders, adapter));
+    this._configProviders = configProviders;
+  }
+  set adapter(adapter) {
+    this.thread.adapter = adapter;
+  }
+  registerModelConfigProvider(provider) {
+    this._configProviders.add(provider);
+    return () => this._configProviders.delete(provider);
+  }
+  switchToThread(threadId) {
+    if (threadId) {
+      throw new Error("LocalRuntime does not yet support switching threads");
+    }
+    return this.thread = new LocalThreadRuntime(
+      this._configProviders,
+      this.thread.adapter
+    );
+  }
+};
+var LocalThreadRuntime = class {
+  constructor(_configProviders, adapter) {
+    this._configProviders = _configProviders;
     this.adapter = adapter;
   }
   _subscriptions = /* @__PURE__ */ new Set();
-  _configProviders = /* @__PURE__ */ new Set();
   abortController = null;
   repository = new MessageRepository();
   get messages() {
@@ -1854,12 +2111,8 @@ var LocalRuntime = class {
     this._subscriptions.add(callback);
     return () => this._subscriptions.delete(callback);
   }
-  registerModelConfigProvider(provider) {
-    this._configProviders.add(provider);
-    return () => this._configProviders.delete(provider);
-  }
   addToolResult() {
-    throw new Error("LocalRuntime does not yet support tool results");
+    throw new Error("LocalRuntime does not yet support adding tool results");
   }
 };
 
@@ -1872,78 +2125,10 @@ var useLocalRuntime = (adapter) => {
   return runtime;
 };
 
-// src/model-config/useAssistantTool.tsx
-import { useEffect as useEffect8 } from "react";
-var useAssistantTool = (tool) => {
-  const { useModelConfig, useToolUIs } = useAssistantContext();
-  const registerModelConfigProvider = useModelConfig(
-    (s) => s.registerModelConfigProvider
-  );
-  const setToolUI = useToolUIs((s) => s.setToolUI);
-  useEffect8(() => {
-    const { toolName, render, ...rest } = tool;
-    const config = {
-      tools: {
-        [tool.toolName]: rest
-      }
-    };
-    const unsub1 = registerModelConfigProvider(() => config);
-    const unsub2 = render ? setToolUI(toolName, render) : void 0;
-    return () => {
-      unsub1();
-      unsub2?.();
-    };
-  }, [registerModelConfigProvider, setToolUI, tool]);
-};
-
-// src/model-config/makeAssistantTool.tsx
-var makeAssistantTool = (tool) => {
-  const Tool = () => {
-    useAssistantTool(tool);
-    return null;
-  };
-  return Tool;
-};
-
-// src/model-config/useAssistantToolUI.tsx
-import { useEffect as useEffect9 } from "react";
-var useAssistantToolUI = (tool) => {
-  const { useToolUIs } = useAssistantContext();
-  const setToolUI = useToolUIs((s) => s.setToolUI);
-  useEffect9(() => {
-    if (!tool) return;
-    const { toolName, render } = tool;
-    return setToolUI(toolName, render);
-  }, [setToolUI, tool]);
-};
-
-// src/model-config/makeAssistantToolUI.tsx
-var makeAssistantToolUI = (tool) => {
-  const ToolUI = () => {
-    useAssistantToolUI(tool);
-    return null;
-  };
-  return ToolUI;
-};
-
-// src/model-config/useAssistantInstructions.tsx
-import { useEffect as useEffect10 } from "react";
-var useAssistantInstructions = (instruction) => {
-  const { useModelConfig } = useAssistantContext();
-  const registerModelConfigProvider = useModelConfig(
-    (s) => s.registerModelConfigProvider
-  );
-  useEffect10(() => {
-    const config = {
-      system: instruction
-    };
-    return registerModelConfigProvider(() => config);
-  }, [registerModelConfigProvider, instruction]);
-};
-
 // src/internal.ts
 var internal_exports = {};
 __export(internal_exports, {
+  BaseAssistantRuntime: () => BaseAssistantRuntime,
   MessageRepository: () => MessageRepository,
   ProxyConfigProvider: () => ProxyConfigProvider
 });
@@ -1962,6 +2147,7 @@ export {
   useActionBarCopy,
   useActionBarEdit,
   useActionBarReload,
+  useAppendMessage,
   useAssistantContext,
   useAssistantInstructions,
   useAssistantTool,
@@ -1977,11 +2163,11 @@ export {
   useContentPartContext,
   useContentPartDisplay,
   useContentPartImage,
-  useContentPartInProgressIndicator,
   useContentPartText,
   useLocalRuntime,
   useMessageContext,
   useMessageIf,
+  useSwitchToNewThread,
   useThreadContext,
   useThreadEmpty,
   useThreadIf,