@assistant-ui/react 0.5.53 → 0.5.56

package/dist/index.mjs

@@ -10,7 +10,7 @@ import {
   toLanguageModelMessages,
   toLanguageModelTools,
   toolResultStream
-} from "./chunk-ZQNZLTZL.mjs";
+} from "./chunk-33TPUWEZ.mjs";
 import {
   __export
 } from "./chunk-BJPOCE4O.mjs";
@@ -22,52 +22,72 @@ import { memo } from "react";
 import { useEffect as useEffect4, useInsertionEffect as useInsertionEffect3, useRef as useRef2, useState as useState8 } from "react";
 
 // src/context/react/AssistantContext.ts
-import { createContext, useContext } from "react";
-var AssistantContext = createContext(
-  null
-);
-function useAssistantContext(options) {
-  const context = useContext(AssistantContext);
-  if (!options?.optional && !context)
-    throw new Error(
-      "This component must be used within an AssistantRuntimeProvider."
-    );
-  return context;
+import { createContext } from "react";
+
+// src/context/react/utils/createContextHook.ts
+import { useContext } from "react";
+function createContextHook(context, providerName) {
+  function useContextHook(options) {
+    const contextValue = useContext(context);
+    if (!options?.optional && !contextValue) {
+      throw new Error(`This component must be used within ${providerName}.`);
+    }
+    return contextValue;
+  }
+  return useContextHook;
 }
 
-// src/context/stores/AssistantModelConfig.ts
-import { create } from "zustand";
-
-// src/utils/ProxyConfigProvider.ts
-var ProxyConfigProvider = class {
-  _providers = /* @__PURE__ */ new Set();
-  getModelConfig() {
-    return mergeModelConfigs(this._providers);
+// src/context/react/utils/createContextStoreHook.ts
+function createContextStoreHook(contextHook, contextKey) {
+  function useStoreStoreHook(options) {
+    const context = contextHook(options);
+    if (!context) {
+      if (!options?.optional) {
+        throw new Error(`This component must be used within a ${contextKey}.`);
+      }
+      return null;
+    }
+    return context[contextKey];
   }
-  registerModelConfigProvider(provider) {
-    this._providers.add(provider);
-    return () => {
-      this._providers.delete(provider);
-    };
+  function useStoreHook(param) {
+    let optional = false;
+    let selector;
+    if (typeof param === "function") {
+      selector = param;
+    } else if (param && typeof param === "object") {
+      optional = !!param.optional;
+      selector = param.selector;
+    }
+    const store = useStoreStoreHook({
+      optional
+    });
+    if (!store) return null;
+    return selector ? store(selector) : store();
   }
-};
+  return {
+    [contextKey]: useStoreHook,
+    [`${contextKey}Store`]: useStoreStoreHook
+  };
+}
 
-// src/context/stores/AssistantModelConfig.ts
-var makeAssistantModelConfigStore = () => create(() => {
-  const proxy = new ProxyConfigProvider();
-  return Object.freeze({
-    getModelConfig: () => {
-      return proxy.getModelConfig();
-    },
-    registerModelConfigProvider: (provider) => {
-      return proxy.registerModelConfigProvider(provider);
-    }
-  });
-});
+// src/context/react/AssistantContext.ts
+var AssistantContext = createContext(
+  null
+);
+var useAssistantContext = createContextHook(
+  AssistantContext,
+  "AssistantRuntimeProvider"
+);
+var { useAssistantRuntime, useAssistantRuntimeStore } = createContextStoreHook(useAssistantContext, "useAssistantRuntime");
+var { useToolUIs, useToolUIsStore } = createContextStoreHook(
+  useAssistantContext,
+  "useToolUIs"
+);
+var { useAssistantActions, useAssistantActionsStore } = createContextStoreHook(useAssistantContext, "useAssistantActions");
 
 // src/context/stores/AssistantToolUIs.ts
-import { create as create2 } from "zustand";
-var makeAssistantToolUIsStore = () => create2((set) => {
+import { create } from "zustand";
+var makeAssistantToolUIsStore = () => create((set) => {
   const renderers = /* @__PURE__ */ new Map();
   return Object.freeze({
     getToolUI: (name) => {
@@ -101,53 +121,66 @@ var makeAssistantToolUIsStore = () => create2((set) => {
 import { useEffect as useEffect3, useInsertionEffect as useInsertionEffect2, useState as useState7 } from "react";
 
 // src/context/react/ThreadContext.ts
-import { createContext as createContext2, useContext as useContext2 } from "react";
+import { createContext as createContext2 } from "react";
 var ThreadContext = createContext2(null);
-function useThreadContext(options) {
-  const context = useContext2(ThreadContext);
-  if (!options?.optional && !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";
-var makeComposerStore = (useThreadRuntime) => {
+var useThreadContext = createContextHook(
+  ThreadContext,
+  "AssistantRuntimeProvider"
+);
+var { useThreadRuntime, useThreadRuntimeStore } = createContextStoreHook(useThreadContext, "useThreadRuntime");
+var { useThread, useThreadStore } = createContextStoreHook(
+  useThreadContext,
+  "useThread"
+);
+var { useThreadMessages, useThreadMessagesStore } = createContextStoreHook(useThreadContext, "useThreadMessages");
+var { useThreadActions, useThreadActionsStore } = createContextStoreHook(useThreadContext, "useThreadActions");
+var {
+  useComposer: useThreadComposer,
+  useComposerStore: useThreadComposerStore
+} = createContextStoreHook(useThreadContext, "useComposer");
+var {
+  useViewport: useThreadViewport,
+  useViewportStore: useThreadViewportStore
+} = createContextStoreHook(useThreadContext, "useViewport");
+
+// src/context/stores/ThreadComposer.ts
+import { create as create2 } from "zustand";
+var makeThreadComposerStore = (useThreadRuntime2) => {
   const focusListeners = /* @__PURE__ */ new Set();
-  return create3()((_, get) => {
-    const runtime = useThreadRuntime.getState();
+  return create2()((_, get) => {
+    const runtime = useThreadRuntime2.getState();
     return {
+      type: "thread",
       get value() {
         return get().text;
       },
       setValue(value) {
         get().setText(value);
       },
+      attachmentAccept: runtime.composer.attachmentAccept,
       attachments: runtime.composer.attachments,
       addAttachment: (file) => {
-        useThreadRuntime.getState().composer.addAttachment(file);
+        useThreadRuntime2.getState().composer.addAttachment(file);
       },
       removeAttachment: (attachmentId) => {
-        useThreadRuntime.getState().composer.removeAttachment(attachmentId);
+        useThreadRuntime2.getState().composer.removeAttachment(attachmentId);
       },
       reset: () => {
-        useThreadRuntime.getState().composer.reset();
+        useThreadRuntime2.getState().composer.reset();
       },
       text: runtime.composer.text,
       setText: (text) => {
-        useThreadRuntime.getState().composer.setText(text);
+        useThreadRuntime2.getState().composer.setText(text);
       },
       canCancel: runtime.capabilities.cancel,
       isEditing: true,
       isEmpty: runtime.composer.isEmpty,
       send: () => {
-        const runtime2 = useThreadRuntime.getState();
+        const runtime2 = useThreadRuntime2.getState();
         runtime2.composer.send();
       },
       cancel: () => {
-        useThreadRuntime.getState().cancelRun();
+        useThreadRuntime2.getState().cancelRun();
       },
       focus: () => {
         for (const listener of focusListeners) {
@@ -165,7 +198,7 @@ var makeComposerStore = (useThreadRuntime) => {
 };
 
 // src/context/stores/Thread.ts
-import { create as create4 } from "zustand";
+import { create as create3 } from "zustand";
 var getThreadStateFromRuntime = (runtime) => {
   const lastMessage = runtime.messages.at(-1);
   return Object.freeze({
@@ -177,14 +210,14 @@ var getThreadStateFromRuntime = (runtime) => {
 };
 var makeThreadStore = (runtimeRef) => {
   const runtime = runtimeRef.getState();
-  return create4(() => getThreadStateFromRuntime(runtime));
+  return create3(() => getThreadStateFromRuntime(runtime));
 };
 
 // src/context/stores/ThreadViewport.tsx
-import { create as create5 } from "zustand";
+import { create as create4 } from "zustand";
 var makeThreadViewportStore = () => {
   const scrollToBottomListeners = /* @__PURE__ */ new Set();
-  return create5(() => ({
+  return create4(() => ({
     isAtBottom: true,
     scrollToBottom: () => {
       for (const listener of scrollToBottomListeners) {
@@ -201,9 +234,9 @@ var makeThreadViewportStore = () => {
 };
 
 // src/context/stores/ThreadActions.ts
-import { create as create6 } from "zustand";
+import { create as create5 } from "zustand";
 var makeThreadActionStore = (runtimeStore) => {
-  return create6(
+  return create5(
     () => Object.freeze({
       getBranches: (messageId) => runtimeStore.getState().getBranches(messageId),
       switchToBranch: (branchId) => runtimeStore.getState().switchToBranch(branchId),
@@ -217,15 +250,15 @@ var makeThreadActionStore = (runtimeStore) => {
 };
 
 // src/context/stores/ThreadMessages.ts
-import { create as create7 } from "zustand";
+import { create as create6 } from "zustand";
 var makeThreadMessagesStore = (runtimeRef) => {
-  return create7(() => runtimeRef.getState().messages);
+  return create6(() => runtimeRef.getState().messages);
 };
 
 // src/context/stores/ThreadRuntime.tsx
-import { create as create8 } from "zustand";
+import { create as create7 } from "zustand";
 var makeThreadRuntimeStore = (runtime) => {
-  return create8(() => runtime);
+  return create7(() => runtime);
 };
 
 // src/runtimes/core/subscribeToMainThread.ts
@@ -358,6 +391,20 @@ var ThreadRuntimeComposer = class {
   }
 };
 
+// src/utils/ProxyConfigProvider.ts
+var ProxyConfigProvider = class {
+  _providers = /* @__PURE__ */ new Set();
+  getModelConfig() {
+    return mergeModelConfigs(this._providers);
+  }
+  registerModelConfigProvider(provider) {
+    this._providers.add(provider);
+    return () => {
+      this._providers.delete(provider);
+    };
+  }
+};
+
 // src/utils/idUtils.tsx
 import { customAlphabet } from "nanoid/non-secure";
 var generateId = customAlphabet(
@@ -609,26 +656,43 @@ var MessageRepository = class {
 
 // src/utils/smooth/useSmooth.tsx
 import { useEffect, useMemo, useRef, useState as useState2 } from "react";
+import { useCallbackRef } from "@radix-ui/react-use-callback-ref";
 
 // src/utils/smooth/SmoothContext.tsx
 import {
-  createContext as createContext3,
+  createContext as createContext4,
   forwardRef,
-  useContext as useContext3,
+  useContext as useContext2,
   useState
 } from "react";
-import { create as create9 } from "zustand";
+import { create as create8 } from "zustand";
+
+// src/context/react/ContentPartContext.ts
+import { createContext as createContext3 } from "react";
+var ContentPartContext = createContext3(
+  null
+);
+var useContentPartContext = createContextHook(
+  ContentPartContext,
+  "a component passed to <MessagePrimitive.Content components={...}>"
+);
+var { useContentPart, useContentPartStore } = createContextStoreHook(
+  useContentPartContext,
+  "useContentPart"
+);
+
+// src/utils/smooth/SmoothContext.tsx
 import { jsx } from "react/jsx-runtime";
-var SmoothContext = createContext3(null);
+var SmoothContext = createContext4(null);
 var makeSmoothContext = (initialState) => {
-  const useSmoothStatus2 = create9(() => initialState);
+  const useSmoothStatus2 = create8(() => initialState);
   return { useSmoothStatus: useSmoothStatus2 };
 };
 var SmoothContextProvider = ({ children }) => {
   const outer = useSmoothContext({ optional: true });
-  const { useContentPart } = useContentPartContext();
+  const contentPartStore = useContentPartStore();
   const [context] = useState(
-    () => makeSmoothContext(useContentPart.getState().status)
+    () => makeSmoothContext(contentPartStore.getState().status)
   );
   if (outer) return children;
   return /* @__PURE__ */ jsx(SmoothContext.Provider, { value: context, children });
@@ -641,20 +705,24 @@ var withSmoothContextProvider = (Component) => {
   return Wrapped;
 };
 function useSmoothContext(options) {
-  const context = useContext3(SmoothContext);
+  const context = useContext2(SmoothContext);
   if (!options?.optional && !context)
     throw new Error(
       "This component must be used within a SmoothContextProvider."
     );
   return context;
 }
-var useSmoothStatus = () => {
-  const { useSmoothStatus: useSmoothStatus2 } = useSmoothContext();
-  return useSmoothStatus2();
+var { useSmoothStatus, useSmoothStatusStore } = createContextStoreHook(
+  useSmoothContext,
+  "useSmoothStatus"
+);
+
+// src/context/ReadonlyStore.ts
+var writableStore = (store) => {
+  return store;
 };
 
 // src/utils/smooth/useSmooth.tsx
-import { useCallbackRef } from "@radix-ui/react-use-callback-ref";
 var TextStreamAnimator = class {
   constructor(currentText, setText) {
     this.currentText = currentText;
@@ -703,21 +771,28 @@ var SMOOTH_STATUS = Object.freeze({
   type: "running"
 });
 var useSmooth = (state, smooth = false) => {
-  const { useSmoothStatus: useSmoothStatus2 } = useSmoothContext({ optional: true }) ?? {};
   const {
     part: { text }
   } = state;
-  const { useMessage } = useMessageContext();
   const id = useMessage((m) => m.message.id);
   const idRef = useRef(id);
   const [displayedText, setDisplayedText] = useState2(text);
+  const smoothStatusStore = useSmoothStatusStore({ optional: true });
   const setText = useCallbackRef((text2) => {
     setDisplayedText(text2);
-    useSmoothStatus2?.setState(text2 !== state.part.text ? SMOOTH_STATUS : state.status);
+    if (smoothStatusStore) {
+      writableStore(smoothStatusStore).setState(
+        text2 !== state.part.text ? SMOOTH_STATUS : state.status
+      );
+    }
   });
   useEffect(() => {
-    useSmoothStatus2?.setState(text !== displayedText ? SMOOTH_STATUS : state.status);
-  }, [useSmoothStatus2, text, displayedText, state.status]);
+    if (smoothStatusStore) {
+      writableStore(smoothStatusStore).setState(
+        text !== state.part.text ? SMOOTH_STATUS : state.status
+      );
+    }
+  }, [smoothStatusStore, text, displayedText, state.status, state.part.text]);
   const [animatorRef] = useState2(
     new TextStreamAnimator(text, setText)
   );
@@ -1350,7 +1425,9 @@ var LocalThreadRuntime = class {
     toolCallId,
     result
   }) {
-    let { parentId, message } = this.repository.getMessage(messageId);
+    const messageData = this.repository.getMessage(messageId);
+    const { parentId } = messageData;
+    let { message } = messageData;
     if (message.role !== "assistant")
       throw new Error("Tried to add tool result to non-assistant message");
     let added = false;
@@ -1421,10 +1498,7 @@ var LocalRuntime = class extends BaseAssistantRuntime {
   registerModelConfigProvider(provider) {
     return this._proxyConfigProvider.registerModelConfigProvider(provider);
   }
-  switchToThread(threadId) {
-    if (threadId) {
-      throw new Error("LocalRuntime does not yet support switching threads");
-    }
+  switchToNewThread() {
     const { initialMessages, ...options } = this.thread.options;
     return this.thread = new LocalThreadRuntime(
       this._proxyConfigProvider,
@@ -1432,6 +1506,12 @@ var LocalRuntime = class extends BaseAssistantRuntime {
       options
     );
   }
+  switchToThread(threadId) {
+    if (threadId !== null) {
+      throw new Error("LocalRuntime does not yet support switching threads");
+    }
+    this.switchToNewThread();
+  }
   reset({
     initialMessages
   } = {}) {
@@ -1755,23 +1835,26 @@ var ExternalStoreRuntime = class extends BaseAssistantRuntime {
   registerModelConfigProvider(provider) {
     return this._proxyConfigProvider.registerModelConfigProvider(provider);
   }
+  async switchToNewThread() {
+    if (!this.store.onSwitchToNewThread)
+      throw new Error("Runtime does not support switching to new threads.");
+    this.thread = new ExternalStoreThreadRuntime({
+      messages: [],
+      onNew: this.store.onNew
+    });
+    await this.store.onSwitchToNewThread();
+  }
   async switchToThread(threadId) {
-    if (threadId) {
-      if (!this.store.onSwitchThread)
+    if (threadId !== null) {
+      if (!this.store.onSwitchToThread)
         throw new Error("Runtime does not support switching threads.");
       this.thread = new ExternalStoreThreadRuntime({
         messages: [],
         onNew: this.store.onNew
       });
-      this.store.onSwitchThread(threadId);
+      this.store.onSwitchToThread(threadId);
     } else {
-      if (!this.store.onNewThread)
-        throw new Error("Runtime does not support switching to new threads.");
-      this.thread = new ExternalStoreThreadRuntime({
-        messages: [],
-        onNew: this.store.onNew
-      });
-      await this.store.onNewThread();
+      this.switchToNewThread();
     }
   }
 };
@@ -2146,11 +2229,6 @@ var CompositeAttachmentAdapter = class {
   }
 };
 
-// src/context/ReadonlyStore.ts
-var writableStore = (store) => {
-  return store;
-};
-
 // src/context/providers/ThreadProvider.tsx
 import { jsx as jsx6, jsxs as jsxs2 } from "react/jsx-runtime";
 var ThreadProvider = ({
@@ -2158,18 +2236,18 @@ var ThreadProvider = ({
   provider
 }) => {
   const [context] = useState7(() => {
-    const useThreadRuntime = makeThreadRuntimeStore(provider.thread);
-    const useThread = makeThreadStore(useThreadRuntime);
-    const useThreadMessages = makeThreadMessagesStore(useThreadRuntime);
-    const useThreadActions = makeThreadActionStore(useThreadRuntime);
+    const useThreadRuntime2 = makeThreadRuntimeStore(provider.thread);
+    const useThread2 = makeThreadStore(useThreadRuntime2);
+    const useThreadMessages2 = makeThreadMessagesStore(useThreadRuntime2);
+    const useThreadActions2 = makeThreadActionStore(useThreadRuntime2);
     const useViewport = makeThreadViewportStore();
-    const useComposer = makeComposerStore(useThreadRuntime);
+    const useComposer2 = makeThreadComposerStore(useThreadRuntime2);
     return {
-      useThread,
-      useThreadRuntime,
-      useThreadMessages,
-      useThreadActions,
-      useComposer,
+      useThread: useThread2,
+      useThreadRuntime: useThreadRuntime2,
+      useThreadMessages: useThreadMessages2,
+      useThreadActions: useThreadActions2,
+      useComposer: useComposer2,
       useViewport
     };
   });
@@ -2189,10 +2267,11 @@ var ThreadProvider = ({
         );
       }
       const composerState = context.useComposer.getState();
-      if (thread.composer.isEmpty !== composerState.isEmpty || thread.composer.text !== composerState.text || thread.composer.attachments !== composerState.attachments || state.capabilities.cancel !== composerState.canCancel) {
+      if (thread.composer.isEmpty !== composerState.isEmpty || thread.composer.text !== composerState.text || thread.composer.attachmentAccept !== composerState.attachmentAccept || thread.composer.attachments !== composerState.attachments || state.capabilities.cancel !== composerState.canCancel) {
         writableStore(context.useComposer).setState({
           isEmpty: thread.composer.isEmpty,
           text: thread.composer.text,
+          attachmentAccept: thread.composer.attachmentAccept,
           attachments: thread.composer.attachments,
           canCancel: state.capabilities.cancel
         });
@@ -2217,18 +2296,20 @@ var ThreadProvider = ({
 };
 
 // src/context/stores/AssistantActions.tsx
-import { create as create10 } from "zustand";
-var makeAssistantActionsStore = (runtimeRef) => create10(
+import { create as create9 } from "zustand";
+var makeAssistantActionsStore = (runtimeRef) => create9(
   () => Object.freeze({
     switchToThread: () => runtimeRef.current.switchToThread(null),
+    switchToNewThread: () => runtimeRef.current.switchToNewThread(),
+    registerModelConfigProvider: (provider) => runtimeRef.current.registerModelConfigProvider(provider),
     getRuntime: () => runtimeRef.current
   })
 );
 
 // src/context/stores/AssistantRuntime.tsx
-import { create as create11 } from "zustand";
+import { create as create10 } from "zustand";
 var makeAssistantRuntimeStore = (runtime) => {
-  return create11(() => runtime);
+  return create10(() => runtime);
 };
 
 // src/context/providers/AssistantProvider.tsx
@@ -2239,21 +2320,15 @@ var AssistantProvider = ({ children, runtime }) => {
     runtimeRef.current = runtime;
   });
   const [context] = useState8(() => {
-    const useAssistantRuntime = makeAssistantRuntimeStore(runtime);
-    const useModelConfig = makeAssistantModelConfigStore();
-    const useToolUIs = makeAssistantToolUIsStore();
-    const useAssistantActions = makeAssistantActionsStore(runtimeRef);
+    const useAssistantRuntime2 = makeAssistantRuntimeStore(runtime);
+    const useToolUIs2 = makeAssistantToolUIsStore();
+    const useAssistantActions2 = makeAssistantActionsStore(runtimeRef);
     return {
-      useModelConfig,
-      useToolUIs,
-      useAssistantRuntime,
-      useAssistantActions
+      useToolUIs: useToolUIs2,
+      useAssistantRuntime: useAssistantRuntime2,
+      useAssistantActions: useAssistantActions2
     };
   });
-  const getModelConfig = context.useModelConfig();
-  useEffect4(() => {
-    return runtime.registerModelConfigProvider(getModelConfig);
-  }, [runtime, getModelConfig]);
   useEffect4(
     () => writableStore(context.useAssistantRuntime).setState(runtime, true),
     [runtime, context]
@@ -2270,93 +2345,95 @@ var AssistantRuntimeProvider = memo(AssistantRuntimeProviderImpl);
 
 // src/context/providers/TextContentPartProvider.tsx
 import { useState as useState9 } from "react";
-import { create as create12 } from "zustand";
-
-// src/context/react/ContentPartContext.ts
-import { createContext as createContext4, useContext as useContext4 } from "react";
-var ContentPartContext = createContext4(
-  null
-);
-function useContentPartContext(options) {
-  const context = useContext4(ContentPartContext);
-  if (!options?.optional && !context)
-    throw new Error(
-      "This component can only be used inside a component passed to <MessagePrimitive.Content components={...} >."
-    );
-  return context;
-}
-
-// src/context/providers/TextContentPartProvider.tsx
+import { create as create11 } from "zustand";
 import { jsx as jsx9 } from "react/jsx-runtime";
 var TextContentPartProvider = ({ children, text }) => {
   const [context] = useState9(() => {
-    const useContentPart = create12(() => ({
+    const useContentPart2 = create11(() => ({
       status: { type: "complete" },
       part: { type: "text", text }
     }));
     return {
-      useContentPart
+      useContentPart: useContentPart2
     };
   });
   return /* @__PURE__ */ jsx9(ContentPartContext.Provider, { value: context, children });
 };
 
-// src/context/react/ComposerContext.ts
-import { useMemo as useMemo3 } from "react";
-
 // src/context/react/MessageContext.ts
-import { createContext as createContext5, useContext as useContext5 } from "react";
+import { createContext as createContext5 } from "react";
 var MessageContext = createContext5(null);
-function useMessageContext(options) {
-  const context = useContext5(MessageContext);
-  if (!options?.optional && !context)
-    throw new Error(
-      "This component can only be used inside a component passed to <ThreadPrimitive.Messages components={...} />."
-    );
-  return context;
-}
+var useMessageContext = createContextHook(
+  MessageContext,
+  "a component passed to <ThreadPrimitive.Messages components={...} />"
+);
+var { useMessage, useMessageStore } = createContextStoreHook(
+  useMessageContext,
+  "useMessage"
+);
+var { useMessageUtils, useMessageUtilsStore } = createContextStoreHook(
+  useMessageContext,
+  "useMessageUtils"
+);
+var { useEditComposer, useEditComposerStore } = createContextStoreHook(
+  useMessageContext,
+  "useEditComposer"
+);
 
 // src/context/react/ComposerContext.ts
+import { useMemo as useMemo3 } from "react";
 var useComposerContext = () => {
-  const { useComposer } = useThreadContext();
-  const { useEditComposer } = useMessageContext({ optional: true }) ?? {};
+  const { useComposer: useComposer2 } = useThreadContext();
+  const { useEditComposer: useEditComposer2 } = useMessageContext({ optional: true }) ?? {};
   return useMemo3(
     () => ({
-      useComposer: useEditComposer ?? useComposer,
-      type: useEditComposer ? "edit" : "new"
+      useComposer: useEditComposer2 ?? useComposer2,
+      type: useEditComposer2 ? "edit" : "new"
     }),
-    [useEditComposer, useComposer]
+    [useEditComposer2, useComposer2]
   );
 };
+var { useComposer, useComposerStore } = createContextStoreHook(
+  useComposerContext,
+  "useComposer"
+);
 
 // src/hooks/useAppendMessage.tsx
 import { useCallback } from "react";
-var toAppendMessage = (useThreadMessages, message) => {
+var toAppendMessage = (useThreadMessages2, message) => {
   if (typeof message === "string") {
     return {
-      parentId: useThreadMessages.getState().at(-1)?.id ?? null,
+      parentId: useThreadMessages2.getState().at(-1)?.id ?? null,
       role: "user",
       content: [{ type: "text", text: message }],
       attachments: []
     };
   }
   return {
-    parentId: message.parentId ?? useThreadMessages.getState().at(-1)?.id ?? null,
+    parentId: message.parentId ?? useThreadMessages2.getState().at(-1)?.id ?? null,
     role: message.role ?? "user",
     content: message.content,
     attachments: message.attachments ?? []
   };
 };
 var useAppendMessage = () => {
-  const { useThreadMessages, useThreadActions, useViewport, useComposer } = useThreadContext();
+  const threadMessagesStore = useThreadMessagesStore();
+  const threadActionsStore = useThreadActionsStore();
+  const threadViewportStore = useThreadViewportStore();
+  const threadComposerStore = useThreadComposerStore();
   const append = useCallback(
     (message) => {
-      const appendMessage = toAppendMessage(useThreadMessages, message);
-      useThreadActions.getState().append(appendMessage);
-      useViewport.getState().scrollToBottom();
-      useComposer.getState().focus();
+      const appendMessage = toAppendMessage(threadMessagesStore, message);
+      threadActionsStore.getState().append(appendMessage);
+      threadViewportStore.getState().scrollToBottom();
+      threadComposerStore.getState().focus();
     },
-    [useThreadMessages, useThreadActions, useViewport, useComposer]
+    [
+      threadMessagesStore,
+      threadActionsStore,
+      threadViewportStore,
+      threadComposerStore
+    ]
   );
   return append;
 };
@@ -2364,23 +2441,20 @@ var useAppendMessage = () => {
 // src/hooks/useSwitchToNewThread.tsx
 import { useCallback as useCallback2 } from "react";
 var useSwitchToNewThread = () => {
-  const { useAssistantActions } = useAssistantContext();
-  const { useComposer } = useThreadContext();
+  const assistantActionsStore = useAssistantActionsStore();
+  const threadComposerStore = useThreadComposerStore();
   const switchToNewThread = useCallback2(() => {
-    useAssistantActions.getState().switchToThread(null);
-    useComposer.getState().focus();
-  }, [useAssistantActions, useComposer]);
+    assistantActionsStore.getState().switchToNewThread();
+    threadComposerStore.getState().focus();
+  }, [assistantActionsStore, threadComposerStore]);
   return switchToNewThread;
 };
 
 // src/model-config/useAssistantTool.tsx
 import { useEffect as useEffect5 } from "react";
 var useAssistantTool = (tool) => {
-  const { useModelConfig, useToolUIs } = useAssistantContext();
-  const registerModelConfigProvider = useModelConfig(
-    (s) => s.registerModelConfigProvider
-  );
-  const setToolUI = useToolUIs((s) => s.setToolUI);
+  const assistantActionsStore = useAssistantActionsStore();
+  const toolUIsStore = useToolUIsStore();
   useEffect5(() => {
     const { toolName, render, ...rest } = tool;
     const config = {
@@ -2388,15 +2462,15 @@ var useAssistantTool = (tool) => {
         [tool.toolName]: rest
       }
     };
-    const unsub1 = registerModelConfigProvider({
+    const unsub1 = assistantActionsStore.getState().registerModelConfigProvider({
       getModelConfig: () => config
     });
-    const unsub2 = render ? setToolUI(toolName, render) : void 0;
+    const unsub2 = render ? toolUIsStore.getState().setToolUI(toolName, render) : void 0;
     return () => {
       unsub1();
       unsub2?.();
     };
-  }, [registerModelConfigProvider, setToolUI, tool]);
+  }, [assistantActionsStore, toolUIsStore, tool]);
 };
 
 // src/model-config/makeAssistantTool.tsx
@@ -2412,13 +2486,12 @@ var makeAssistantTool = (tool) => {
 // src/model-config/useAssistantToolUI.tsx
 import { useEffect as useEffect6 } from "react";
 var useAssistantToolUI = (tool) => {
-  const { useToolUIs } = useAssistantContext();
-  const setToolUI = useToolUIs((s) => s.setToolUI);
+  const toolUIsStore = useToolUIsStore();
   useEffect6(() => {
     if (!tool) return;
     const { toolName, render } = tool;
-    return setToolUI(toolName, render);
-  }, [setToolUI, tool]);
+    return toolUIsStore.getState().setToolUI(toolName, render);
+  }, [toolUIsStore, tool]);
 };
 
 // src/model-config/makeAssistantToolUI.tsx
@@ -2434,16 +2507,13 @@ var makeAssistantToolUI = (tool) => {
 // src/model-config/useAssistantInstructions.tsx
 import { useEffect as useEffect7 } from "react";
 var useAssistantInstructions = (instruction) => {
-  const { useModelConfig } = useAssistantContext();
-  const registerModelConfigProvider = useModelConfig(
-    (s) => s.registerModelConfigProvider
-  );
+  const actionsStore = useAssistantActionsStore();
   useEffect7(() => {
     const config = {
       system: instruction
     };
-    return registerModelConfigProvider({ getModelConfig: () => config });
-  }, [registerModelConfigProvider, instruction]);
+    return actionsStore.getState().registerModelConfigProvider({ getModelConfig: () => config });
+  }, [actionsStore, instruction]);
 };
 
 // src/primitive-hooks/actionBar/useActionBarCopy.tsx
@@ -2479,23 +2549,25 @@ var useCombinedStore = (stores, selector) => {
 var useActionBarCopy = ({
   copiedDuration = 3e3
 } = {}) => {
-  const { useMessage, useMessageUtils, useEditComposer } = useMessageContext();
+  const messageStore = useMessageStore();
+  const messageUtilsStore = useMessageUtilsStore();
+  const editComposerStore = useEditComposerStore();
   const hasCopyableContent = useCombinedStore(
-    [useMessage, useEditComposer],
+    [messageStore, editComposerStore],
     ({ message }, c) => {
       return !c.isEditing && (message.role !== "assistant" || message.status.type !== "running") && message.content.some((c2) => c2.type === "text" && c2.text.length > 0);
     }
   );
   const callback = useCallback3(() => {
-    const { message } = useMessage.getState();
-    const { setIsCopied } = useMessageUtils.getState();
-    const { isEditing, text: composerValue } = useEditComposer.getState();
+    const { message } = messageStore.getState();
+    const { setIsCopied } = messageUtilsStore.getState();
+    const { isEditing, text: composerValue } = editComposerStore.getState();
     const valueToCopy = isEditing ? composerValue : getThreadMessageText(message);
     navigator.clipboard.writeText(valueToCopy).then(() => {
       setIsCopied(true);
       setTimeout(() => setIsCopied(false), copiedDuration);
     });
-  }, [useMessage, useMessageUtils, useEditComposer, copiedDuration]);
+  }, [messageStore, messageUtilsStore, editComposerStore, copiedDuration]);
   if (!hasCopyableContent) return null;
   return callback;
 };
@@ -2503,12 +2575,12 @@ var useActionBarCopy = ({
 // src/primitive-hooks/actionBar/useActionBarEdit.tsx
 import { useCallback as useCallback4 } from "react";
 var useActionBarEdit = () => {
-  const { useEditComposer } = useMessageContext();
+  const editComposerStore = useEditComposerStore();
   const disabled = useEditComposer((c) => c.isEditing);
   const callback = useCallback4(() => {
-    const { edit } = useEditComposer.getState();
+    const { edit } = editComposerStore.getState();
     edit();
-  }, [useEditComposer]);
+  }, [editComposerStore]);
   if (disabled) return null;
   return callback;
 };
@@ -2516,18 +2588,26 @@ var useActionBarEdit = () => {
 // src/primitive-hooks/actionBar/useActionBarReload.tsx
 import { useCallback as useCallback5 } from "react";
 var useActionBarReload = () => {
-  const { useThread, useThreadActions, useComposer, useViewport } = useThreadContext();
-  const { useMessage } = useMessageContext();
+  const messageStore = useMessageStore();
+  const threadStore = useThreadStore();
+  const threadActionsStore = useThreadActionsStore();
+  const threadComposerStore = useThreadComposerStore();
+  const threadViewportStore = useThreadViewportStore();
   const disabled = useCombinedStore(
-    [useThread, useMessage],
+    [threadStore, messageStore],
     (t, m) => t.isRunning || t.isDisabled || m.message.role !== "assistant"
   );
   const callback = useCallback5(() => {
-    const { parentId } = useMessage.getState();
-    useThreadActions.getState().startRun(parentId);
-    useViewport.getState().scrollToBottom();
-    useComposer.getState().focus();
-  }, [useThreadActions, useComposer, useViewport, useMessage]);
+    const { parentId } = messageStore.getState();
+    threadActionsStore.getState().startRun(parentId);
+    threadViewportStore.getState().scrollToBottom();
+    threadComposerStore.getState().focus();
+  }, [
+    threadActionsStore,
+    threadComposerStore,
+    threadViewportStore,
+    messageStore
+  ]);
   if (disabled) return null;
   return callback;
 };
@@ -2535,19 +2615,21 @@ var useActionBarReload = () => {
 // src/primitive-hooks/actionBar/useActionBarSpeak.tsx
 import { useCallback as useCallback6 } from "react";
 var useActionBarSpeak = () => {
-  const { useThreadActions } = useThreadContext();
-  const { useMessage, useEditComposer, useMessageUtils } = useMessageContext();
+  const messageStore = useMessageStore();
+  const editComposerStore = useEditComposerStore();
+  const threadActionsStore = useThreadActionsStore();
+  const messageUtilsStore = useMessageUtilsStore();
   const hasSpeakableContent = useCombinedStore(
-    [useMessage, useEditComposer],
+    [messageStore, editComposerStore],
     ({ message }, c) => {
       return !c.isEditing && (message.role !== "assistant" || message.status.type !== "running") && message.content.some((c2) => c2.type === "text" && c2.text.length > 0);
     }
   );
   const callback = useCallback6(async () => {
-    const { message } = useMessage.getState();
-    const utt = useThreadActions.getState().speak(message.id);
-    useMessageUtils.getState().addUtterance(utt);
-  }, [useThreadActions, useMessage, useMessageUtils]);
+    const { message } = messageStore.getState();
+    const utt = threadActionsStore.getState().speak(message.id);
+    messageUtilsStore.getState().addUtterance(utt);
+  }, [threadActionsStore, messageStore, messageUtilsStore]);
   if (!hasSpeakableContent) return null;
   return callback;
 };
@@ -2555,18 +2637,17 @@ var useActionBarSpeak = () => {
 // src/primitive-hooks/actionBar/useActionBarStopSpeaking.tsx
 import { useCallback as useCallback7 } from "react";
 var useActionBarStopSpeaking = () => {
-  const { useMessageUtils } = useMessageContext();
+  const messageUtilsStore = useMessageUtilsStore();
   const isSpeaking = useMessageUtils((u) => u.isSpeaking);
   const callback = useCallback7(async () => {
-    useMessageUtils.getState().stopSpeaking();
-  }, [useMessageUtils]);
+    messageUtilsStore.getState().stopSpeaking();
+  }, [messageUtilsStore]);
   if (!isSpeaking) return null;
   return callback;
 };
 
 // src/primitive-hooks/branchPicker/useBranchPickerCount.tsx
 var useBranchPickerCount = () => {
-  const { useMessage } = useMessageContext();
   const branchCount = useMessage((s) => s.branches.length);
   return branchCount;
 };
@@ -2574,23 +2655,23 @@ var useBranchPickerCount = () => {
 // src/primitive-hooks/branchPicker/useBranchPickerNext.tsx
 import { useCallback as useCallback8 } from "react";
 var useBranchPickerNext = () => {
-  const { useThreadActions } = useThreadContext();
-  const { useMessage, useEditComposer } = useMessageContext();
+  const messageStore = useMessageStore();
+  const editComposerStore = useEditComposerStore();
+  const threadActionsStore = useThreadActionsStore();
   const disabled = useCombinedStore(
-    [useMessage, useEditComposer],
+    [messageStore, editComposerStore],
     (m, c) => c.isEditing || m.branches.indexOf(m.message.id) + 1 >= m.branches.length
   );
   const callback = useCallback8(() => {
-    const { message, branches } = useMessage.getState();
-    useThreadActions.getState().switchToBranch(branches[branches.indexOf(message.id) + 1]);
-  }, [useThreadActions, useMessage]);
+    const { message, branches } = messageStore.getState();
+    threadActionsStore.getState().switchToBranch(branches[branches.indexOf(message.id) + 1]);
+  }, [threadActionsStore, messageStore]);
   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;
 };
@@ -2598,16 +2679,17 @@ var useBranchPickerNumber = () => {
 // src/primitive-hooks/branchPicker/useBranchPickerPrevious.tsx
 import { useCallback as useCallback9 } from "react";
 var useBranchPickerPrevious = () => {
-  const { useThreadActions } = useThreadContext();
-  const { useMessage, useEditComposer } = useMessageContext();
+  const messageStore = useMessageStore();
+  const editComposerStore = useEditComposerStore();
+  const threadActionsStore = useThreadActionsStore();
   const disabled = useCombinedStore(
-    [useMessage, useEditComposer],
+    [messageStore, editComposerStore],
     (m, c) => c.isEditing || m.branches.indexOf(m.message.id) <= 0
   );
   const callback = useCallback9(() => {
-    const { message, branches } = useMessage.getState();
-    useThreadActions.getState().switchToBranch(branches[branches.indexOf(message.id) - 1]);
-  }, [useThreadActions, useMessage]);
+    const { message, branches } = messageStore.getState();
+    threadActionsStore.getState().switchToBranch(branches[branches.indexOf(message.id) - 1]);
+  }, [threadActionsStore, messageStore]);
   if (disabled) return null;
   return callback;
 };
@@ -2615,19 +2697,18 @@ var useBranchPickerPrevious = () => {
 // src/primitive-hooks/composer/useComposerCancel.tsx
 import { useCallback as useCallback10 } from "react";
 var useComposerCancel = () => {
-  const { useComposer } = useComposerContext();
+  const composerStore = useComposerStore();
   const disabled = useComposer((c) => !c.canCancel);
   const callback = useCallback10(() => {
-    const { cancel } = useComposer.getState();
+    const { cancel } = composerStore.getState();
     cancel();
-  }, [useComposer]);
+  }, [composerStore]);
   if (disabled) return null;
   return callback;
 };
 
 // src/primitive-hooks/composer/useComposerIf.tsx
 var useComposerIf = (props) => {
-  const { useComposer } = useComposerContext();
   return useComposer((composer) => {
     if (props.editing === true && !composer.isEditing) return false;
     if (props.editing === false && composer.isEditing) return false;
@@ -2638,23 +2719,21 @@ var useComposerIf = (props) => {
 // src/primitive-hooks/composer/useComposerSend.tsx
 import { useCallback as useCallback11 } from "react";
 var useComposerSend = () => {
-  const {
-    useThread,
-    useViewport,
-    useComposer: useNewComposer
-  } = useThreadContext();
-  const { useComposer } = useComposerContext();
+  const threadStore = useThreadStore();
+  const threadViewportStore = useThreadViewportStore();
+  const composerStore = useComposerStore();
+  const threadComposerStore = useThreadComposerStore();
   const disabled = useCombinedStore(
-    [useThread, useComposer],
+    [threadStore, composerStore],
     (t, c) => t.isRunning || !c.isEditing || c.isEmpty
   );
   const callback = useCallback11(() => {
-    const composerState = useComposer.getState();
+    const composerState = composerStore.getState();
     if (!composerState.isEditing) return;
     composerState.send();
-    useViewport.getState().scrollToBottom();
-    useNewComposer.getState().focus();
-  }, [useNewComposer, useComposer, useViewport]);
+    threadViewportStore.getState().scrollToBottom();
+    threadComposerStore.getState().focus();
+  }, [threadComposerStore, composerStore, threadViewportStore]);
   if (disabled) return null;
   return callback;
 };
@@ -2662,11 +2741,12 @@ var useComposerSend = () => {
 // src/primitive-hooks/composer/useComposerAddAttachment.tsx
 import { useCallback as useCallback12 } from "react";
 var useComposerAddAttachment = () => {
-  const { useComposer, useThreadRuntime } = useThreadContext();
   const disabled = useComposer((c) => !c.isEditing);
+  const threadComposerStore = useThreadComposerStore();
+  const threadRuntimeStore = useThreadComposerStore();
   const callback = useCallback12(() => {
-    const { addAttachment } = useComposer.getState();
-    const { attachmentAccept } = useThreadRuntime.getState().composer;
+    const { addAttachment } = threadComposerStore.getState();
+    const { attachmentAccept } = threadRuntimeStore.getState();
     const input = document.createElement("input");
     input.type = "file";
     if (attachmentAccept !== "*") {
@@ -2678,14 +2758,13 @@ var useComposerAddAttachment = () => {
       addAttachment(file);
     };
     input.click();
-  }, [useComposer, useThreadRuntime]);
+  }, [threadComposerStore, threadRuntimeStore]);
   if (disabled) return null;
   return callback;
 };
 
 // src/primitive-hooks/contentPart/useContentPartDisplay.tsx
 var useContentPartDisplay = () => {
-  const { useContentPart } = useContentPartContext();
   const display = useContentPart((c) => {
     if (c.part.type !== "ui")
       throw new Error(
@@ -2698,7 +2777,6 @@ var useContentPartDisplay = () => {
 
 // src/primitive-hooks/contentPart/useContentPartImage.tsx
 var useContentPartImage = () => {
-  const { useContentPart } = useContentPartContext();
   const image = useContentPart((c) => {
     if (c.part.type !== "image")
       throw new Error(
@@ -2711,7 +2789,6 @@ var useContentPartImage = () => {
 
 // src/primitive-hooks/contentPart/useContentPartText.tsx
 var useContentPartText = () => {
-  const { useContentPart } = useContentPartContext();
   const text = useContentPart((c) => {
     if (c.part.type !== "text")
       throw new Error(
@@ -2724,9 +2801,10 @@ var useContentPartText = () => {
 
 // src/primitive-hooks/message/useMessageIf.tsx
 var useMessageIf = (props) => {
-  const { useMessage, useMessageUtils } = useMessageContext();
+  const messageStore = useMessageStore();
+  const messageUtilsStore = useMessageUtilsStore();
   return useCombinedStore(
-    [useMessage, useMessageUtils],
+    [messageStore, messageUtilsStore],
     ({ message, branches, isLast }, { isCopied, isHovering, isSpeaking }) => {
       if (props.hasBranches === true && branches.length < 2) return false;
       if (props.user && message.role !== "user") return false;
@@ -2748,9 +2826,10 @@ var useMessageIf = (props) => {
 
 // src/primitive-hooks/thread/useThreadIf.tsx
 var useThreadIf = (props) => {
-  const { useThread, useThreadMessages } = useThreadContext();
+  const threadStore = useThreadStore();
+  const threadMessagesStore = useThreadMessagesStore();
   return useCombinedStore(
-    [useThread, useThreadMessages],
+    [threadStore, threadMessagesStore],
     (thread, messages) => {
       if (props.empty === true && messages.length !== 0) return false;
       if (props.empty === false && messages.length === 0) return false;
@@ -2771,12 +2850,13 @@ var useThreadEmpty = () => {
 // src/primitive-hooks/thread/useThreadScrollToBottom.tsx
 import { useCallback as useCallback13 } from "react";
 var useThreadScrollToBottom = () => {
-  const { useComposer, useViewport } = useThreadContext();
-  const isAtBottom = useViewport((s) => s.isAtBottom);
+  const isAtBottom = useThreadViewport((s) => s.isAtBottom);
+  const threadViewportStore = useThreadViewportStore();
+  const threadComposerStore = useThreadComposerStore();
   const handleScrollToBottom = useCallback13(() => {
-    useViewport.getState().scrollToBottom();
-    useComposer.getState().focus();
-  }, [useViewport, useComposer]);
+    threadViewportStore.getState().scrollToBottom();
+    threadComposerStore.getState().focus();
+  }, [threadViewportStore, threadComposerStore]);
   if (isAtBottom) return null;
   return handleScrollToBottom;
 };
@@ -2787,19 +2867,20 @@ var useThreadSuggestion = ({
   prompt,
   autoSend
 }) => {
-  const { useThread, useComposer } = useThreadContext();
+  const threadStore = useThreadStore();
+  const composerStore = useThreadComposerStore();
   const append = useAppendMessage();
   const disabled = useThread((t) => t.isDisabled);
   const callback = useCallback14(() => {
-    const thread = useThread.getState();
-    const composer = useComposer.getState();
+    const thread = threadStore.getState();
+    const composer = composerStore.getState();
     if (autoSend && !thread.isRunning) {
       append(prompt);
       composer.setText("");
     } else {
       composer.setText(prompt);
     }
-  }, [useThread, useComposer, autoSend, append, prompt]);
+  }, [threadStore, composerStore, autoSend, append, prompt]);
   if (disabled) return null;
   return callback;
 };
@@ -2825,10 +2906,11 @@ var useActionBarFloatStatus = ({
   autohide,
   autohideFloat
 }) => {
-  const { useThread } = useThreadContext();
-  const { useMessage, useMessageUtils } = useMessageContext();
+  const threadStore = useThreadStore();
+  const messageStore = useMessageStore();
+  const messageUtilsStore = useMessageUtilsStore();
   return useCombinedStore(
-    [useThread, useMessage, useMessageUtils],
+    [threadStore, messageStore, messageUtilsStore],
     (t, m, mu) => {
       if (hideWhenRunning && t.isRunning) return "hidden" /* Hidden */;
       const autohideEnabled = autohide === "always" || autohide === "not-last" && !m.isLast;
@@ -2947,6 +3029,7 @@ var ActionBarPrimitiveStopSpeaking = forwardRef7((props, ref) => {
     }
   );
 });
+ActionBarPrimitiveStopSpeaking.displayName = "ActionBarPrimitive.StopSpeaking";
 
 // src/primitives/assistantModal/index.ts
 var assistantModal_exports = {};
@@ -2967,12 +3050,12 @@ import { useCallbackRef as useCallbackRef2 } from "@radix-ui/react-use-callback-
 import { useEffect as useEffect8 } from "react";
 var useOnComposerFocus = (callback) => {
   const callbackRef = useCallbackRef2(callback);
-  const { useComposer } = useThreadContext();
+  const threadComposerStore = useThreadComposerStore();
   useEffect8(() => {
-    return useComposer.getState().onFocus(() => {
+    return threadComposerStore.getState().onFocus(() => {
       callbackRef();
     });
-  }, [useComposer, callbackRef]);
+  }, [threadComposerStore, callbackRef]);
 };
 
 // src/primitives/assistantModal/scope.tsx
@@ -3154,10 +3237,10 @@ var useManagedRef = (callback) => {
 import { useComposedRefs } from "@radix-ui/react-compose-refs";
 import { jsx as jsx19 } from "react/jsx-runtime";
 var useIsHoveringRef = () => {
-  const { useMessageUtils } = useMessageContext();
+  const messageUtilsStore = useMessageUtilsStore();
   const callbackRef = useCallback16(
     (el) => {
-      const setIsHovering = useMessageUtils.getState().setIsHovering;
+      const setIsHovering = messageUtilsStore.getState().setIsHovering;
       const handleMouseEnter = () => {
         setIsHovering(true);
       };
@@ -3172,14 +3255,14 @@ var useIsHoveringRef = () => {
         setIsHovering(false);
       };
     },
-    [useMessageUtils]
+    [messageUtilsStore]
   );
   return useManagedRef(callbackRef);
 };
-var MessagePrimitiveRoot = forwardRef11(({ onMouseEnter, onMouseLeave, ...rest }, forwardRef30) => {
+var MessagePrimitiveRoot = forwardRef11((props, forwardRef30) => {
   const isHoveringRef = useIsHoveringRef();
   const ref = useComposedRefs(forwardRef30, isHoveringRef);
-  return /* @__PURE__ */ jsx19(Primitive5.div, { ...rest, ref });
+  return /* @__PURE__ */ jsx19(Primitive5.div, { ...props, ref });
 });
 MessagePrimitiveRoot.displayName = "MessagePrimitive.Root";
 
@@ -3198,7 +3281,7 @@ import { memo as memo2 } from "react";
 
 // src/context/providers/ContentPartProvider.tsx
 import { useEffect as useEffect9, useState as useState11 } from "react";
-import { create as create13 } from "zustand";
+import { create as create12 } from "zustand";
 import { jsx as jsx20 } from "react/jsx-runtime";
 var COMPLETE_STATUS = {
   type: "complete"
@@ -3219,7 +3302,7 @@ var toContentPartStatus = (message, partIndex, part) => {
   return message.status;
 };
 var EMPTY_CONTENT = Object.freeze({ type: "text", text: "" });
-var getContentPartState = ({ message }, useContentPart, partIndex) => {
+var getContentPartState = ({ message }, useContentPart2, partIndex) => {
   let part = message.content[partIndex];
   if (!part) {
     if (message.content.length === 0 && partIndex === 0) {
@@ -3231,18 +3314,18 @@ var getContentPartState = ({ message }, useContentPart, partIndex) => {
     part = EMPTY_CONTENT;
   }
   const status = toContentPartStatus(message, partIndex, part);
-  const currentState = useContentPart?.getState();
+  const currentState = useContentPart2?.getState();
   if (currentState && currentState.part === part && currentState.status === status)
     return null;
   return Object.freeze({ part, status });
 };
 var useContentPartContext2 = (partIndex) => {
-  const { useMessage } = useMessageContext();
+  const messageStore = useMessageStore();
   const [context] = useState11(() => {
-    const useContentPart = create13(
-      () => getContentPartState(useMessage.getState(), void 0, partIndex)
+    const useContentPart2 = create12(
+      () => getContentPartState(messageStore.getState(), void 0, partIndex)
     );
-    return { useContentPart };
+    return { useContentPart: useContentPart2 };
   });
   useEffect9(() => {
     const syncContentPart = (message) => {
@@ -3254,9 +3337,9 @@ var useContentPartContext2 = (partIndex) => {
       if (!newState) return;
       writableStore(context.useContentPart).setState(newState, true);
     };
-    syncContentPart(useMessage.getState());
-    return useMessage.subscribe(syncContentPart);
-  }, [context, useMessage, partIndex]);
+    syncContentPart(messageStore.getState());
+    return messageStore.subscribe(syncContentPart);
+  }, [context, messageStore, partIndex]);
   return context;
 };
 var ContentPartProvider = ({
@@ -3304,7 +3387,6 @@ ContentPartPrimitiveDisplay.displayName = "ContentPartPrimitive.Display";
 
 // src/primitives/contentPart/ContentPartInProgress.tsx
 var ContentPartPrimitiveInProgress = ({ children }) => {
-  const { useContentPart } = useContentPartContext();
   const isInProgress = useContentPart((c) => c.status.type === "running");
   return isInProgress ? children : null;
 };
@@ -3316,7 +3398,6 @@ var ToolUIDisplay = ({
   UI,
   ...props
 }) => {
-  const { useToolUIs } = useAssistantContext();
   const Render = useToolUIs((s) => s.getToolUI(props.part.toolName)) ?? UI;
   if (!Render) return null;
   return /* @__PURE__ */ jsx23(Render, { ...props });
@@ -3338,10 +3419,8 @@ var MessageContentPartComponent = ({
     tools: { by_name = {}, Fallback: Fallback2 = void 0 } = {}
   } = {}
 }) => {
-  const { useThreadActions } = useThreadContext();
-  const { useMessage } = useMessageContext();
-  const addToolResult = useThreadActions((t) => t.addToolResult);
-  const { useContentPart } = useContentPartContext();
+  const messageStore = useMessageStore();
+  const threadActionsStore = useThreadActionsStore();
   const { part, status } = useContentPart();
   const type = part.type;
   switch (type) {
@@ -3362,8 +3441,8 @@ var MessageContentPartComponent = ({
       return /* @__PURE__ */ jsx23(UI, { part, status });
     case "tool-call": {
       const Tool = by_name[part.toolName] || Fallback2;
-      const addResult = (result) => addToolResult({
-        messageId: useMessage.getState().message.id,
+      const addResult = (result) => threadActionsStore.getState().addToolResult({
+        messageId: messageStore.getState().message.id,
         toolName: part.toolName,
         toolCallId: part.toolCallId,
         result
@@ -3396,7 +3475,6 @@ var MessageContentPart = memo2(
 var MessagePrimitiveContent = ({
   components
 }) => {
-  const { useMessage } = useMessageContext();
   const contentLength = useMessage((s) => s.message.content.length) || 1;
   return Array.from({ length: contentLength }, (_, index) => /* @__PURE__ */ jsx23(MessageContentPart, { partIndex: index, components }, index));
 };
@@ -3412,48 +3490,70 @@ MessagePrimitiveInProgress.displayName = "MessagePrimitive.InProgress";
 import { memo as memo3 } from "react";
 
 // src/context/react/AttachmentContext.ts
-import { createContext as createContext6, useContext as useContext6 } from "react";
+import { createContext as createContext6, useContext as useContext3 } from "react";
 var AttachmentContext = createContext6(
   null
 );
 function useAttachmentContext(options) {
-  const context = useContext6(AttachmentContext);
-  if (options?.type === "composer" && context?.type !== "composer")
+  const context = useContext3(AttachmentContext);
+  if (!options?.optional && !context)
     throw new Error(
-      "This component must be used within a ComposerPrimitive.Attachments component."
+      "This component must be used within a ComposerPrimitive.Attachments or MessagePrimitive.Attachments component."
     );
-  if (options?.type === "message" && context?.type !== "message")
+  return context;
+}
+function useComposerAttachmentContext(options) {
+  const context = useAttachmentContext(options);
+  if (!context) return null;
+  if (context.type !== "composer")
     throw new Error(
-      "This component must be used within a MessagePrimitive.Attachments component."
+      "This component must be used within a ComposerPrimitive.Attachments component."
     );
-  if (!options?.optional && !context)
+  return context;
+}
+function useMessageAttachmentContext(options) {
+  const context = useAttachmentContext(options);
+  if (!context) return null;
+  if (context.type !== "message")
     throw new Error(
-      "This component must be used within a ComposerPrimitive.Attachments or MessagePrimitive.Attachments component."
+      "This component must be used within a MessagePrimitive.Attachments component."
     );
   return context;
 }
+var { useAttachment, useAttachmentStore } = createContextStoreHook(
+  useAttachmentContext,
+  "useAttachment"
+);
+var {
+  useAttachment: useComposerAttachment,
+  useAttachmentStore: useComposerAttachmentStore
+} = createContextStoreHook(useComposerAttachmentContext, "useAttachment");
+var {
+  useAttachment: useMessageAttachment,
+  useAttachmentStore: useMessageAttachmentStore
+} = createContextStoreHook(useMessageAttachmentContext, "useAttachment");
 
 // src/context/providers/MessageAttachmentProvider.tsx
 import { useEffect as useEffect10, useState as useState12 } from "react";
-import { create as create14 } from "zustand";
+import { create as create13 } from "zustand";
 import { jsx as jsx24 } from "react/jsx-runtime";
-var getAttachment = ({ message }, useAttachment, partIndex) => {
+var getAttachment = ({ message }, useAttachment2, partIndex) => {
   if (message.role !== "user") return null;
   const attachments = message.attachments;
-  let attachment = attachments[partIndex];
+  const attachment = attachments[partIndex];
   if (!attachment) return null;
-  const currentState = useAttachment?.getState();
+  const currentState = useAttachment2?.getState();
   if (currentState && currentState.attachment === attachment) return null;
   return Object.freeze({ attachment });
 };
-var useMessageAttachmentContext = (partIndex) => {
-  const { useMessage } = useMessageContext();
+var useMessageAttachmentContext2 = (partIndex) => {
+  const messageStore = useMessageStore();
   const [context] = useState12(
     () => {
-      const useAttachment = create14(
-        () => getAttachment(useMessage.getState(), void 0, partIndex)
+      const useAttachment2 = create13(
+        () => getAttachment(messageStore.getState(), void 0, partIndex)
       );
-      return { type: "message", useAttachment };
+      return { type: "message", useAttachment: useAttachment2 };
     }
   );
   useEffect10(() => {
@@ -3466,16 +3566,16 @@ var useMessageAttachmentContext = (partIndex) => {
       if (!newState) return;
       writableStore(context.useAttachment).setState(newState, true);
     };
-    syncAttachment(useMessage.getState());
-    return useMessage.subscribe(syncAttachment);
-  }, [context, useMessage, partIndex]);
+    syncAttachment(messageStore.getState());
+    return messageStore.subscribe(syncAttachment);
+  }, [context, messageStore, partIndex]);
   return context;
 };
 var MessageAttachmentProvider = ({
   attachmentIndex: partIndex,
   children
 }) => {
-  const context = useMessageAttachmentContext(partIndex);
+  const context = useMessageAttachmentContext2(partIndex);
   return /* @__PURE__ */ jsx24(AttachmentContext.Provider, { value: context, children });
 };
 
@@ -3496,8 +3596,7 @@ var getComponent = (components, attachment) => {
   }
 };
 var AttachmentComponent = ({ components }) => {
-  const { useAttachment } = useAttachmentContext({ type: "message" });
-  const Component = useAttachment(
+  const Component = useMessageAttachment(
     (a) => getComponent(components, a.attachment)
   );
   if (!Component) return null;
@@ -3511,7 +3610,6 @@ var MessageAttachment = memo3(
   (prev, next) => prev.attachmentIndex === next.attachmentIndex && prev.components?.Image === next.components?.Image && prev.components?.Document === next.components?.Document && prev.components?.File === next.components?.File && prev.components?.Attachment === next.components?.Attachment
 );
 var MessagePrimitiveAttachments = ({ components }) => {
-  const { useMessage } = useMessageContext();
   const attachmentsCount = useMessage(({ message }) => {
     if (message.role !== "user") return 0;
     return message.attachments.length;
@@ -3593,8 +3691,8 @@ var ComposerPrimitiveInput = forwardRef16(
     onKeyDown,
     ...rest
   }, forwardedRef) => {
-    const { useThread } = useThreadContext();
-    const { useComposer, type } = useComposerContext();
+    const threadStore = useThreadStore();
+    const composerStore = useComposerStore();
     const value = useComposer((c) => {
       if (!c.isEditing) return "";
       return c.text;
@@ -3604,7 +3702,7 @@ var ComposerPrimitiveInput = forwardRef16(
     const textareaRef = useRef4(null);
     const ref = useComposedRefs2(forwardedRef, textareaRef);
     useEscapeKeydown2((e) => {
-      const composer = useComposer.getState();
+      const composer = composerStore.getState();
       if (composer.canCancel) {
         composer.cancel();
         e.preventDefault();
@@ -3614,7 +3712,7 @@ var ComposerPrimitiveInput = forwardRef16(
       if (isDisabled) return;
       if (e.nativeEvent.isComposing) return;
       if (e.key === "Enter" && e.shiftKey === false) {
-        const { isRunning } = useThread.getState();
+        const { isRunning } = threadStore.getState();
         if (!isRunning) {
           e.preventDefault();
           textareaRef.current?.closest("form")?.requestSubmit();
@@ -3633,7 +3731,7 @@ var ComposerPrimitiveInput = forwardRef16(
     }, [autoFocusEnabled]);
     useEffect11(() => focus(), [focus]);
     useOnComposerFocus(() => {
-      if (type === "new") {
+      if (composerStore.getState().type === "thread") {
         focus();
       }
     });
@@ -3646,7 +3744,7 @@ var ComposerPrimitiveInput = forwardRef16(
         ref,
         disabled: isDisabled,
         onChange: composeEventHandlers6(onChange, (e) => {
-          const composerState = useComposer.getState();
+          const composerState = composerStore.getState();
           if (!composerState.isEditing) return;
           return composerState.setText(e.target.value);
         }),
@@ -3680,23 +3778,23 @@ import { memo as memo4 } from "react";
 
 // src/context/providers/ComposerAttachmentProvider.tsx
 import { useEffect as useEffect12, useState as useState13 } from "react";
-import { create as create15 } from "zustand";
+import { create as create14 } from "zustand";
 import { jsx as jsx29 } from "react/jsx-runtime";
-var getAttachment2 = ({ attachments }, useAttachment, partIndex) => {
-  let attachment = attachments[partIndex];
+var getAttachment2 = ({ attachments }, useAttachment2, partIndex) => {
+  const attachment = attachments[partIndex];
   if (!attachment) return null;
-  const currentState = useAttachment?.getState();
+  const currentState = useAttachment2?.getState();
   if (currentState && currentState.attachment === attachment) return null;
   return Object.freeze({ attachment });
 };
-var useComposerAttachmentContext = (partIndex) => {
-  const { useComposer } = useThreadContext();
+var useComposerAttachmentContext2 = (partIndex) => {
+  const threadComposerStore = useThreadComposerStore();
   const [context] = useState13(
     () => {
-      const useAttachment = create15(
-        () => getAttachment2(useComposer.getState(), void 0, partIndex)
+      const useAttachment2 = create14(
+        () => getAttachment2(threadComposerStore.getState(), void 0, partIndex)
       );
-      return { type: "composer", useAttachment };
+      return { type: "composer", useAttachment: useAttachment2 };
     }
   );
   useEffect12(() => {
@@ -3709,13 +3807,13 @@ var useComposerAttachmentContext = (partIndex) => {
       if (!newState) return;
       writableStore(context.useAttachment).setState(newState, true);
     };
-    syncAttachment(useComposer.getState());
-    return useComposer.subscribe(syncAttachment);
-  }, [context, useComposer, partIndex]);
+    syncAttachment(threadComposerStore.getState());
+    return threadComposerStore.subscribe(syncAttachment);
+  }, [context, threadComposerStore, partIndex]);
   return context;
 };
 var ComposerAttachmentProvider = ({ attachmentIndex: partIndex, children }) => {
-  const context = useComposerAttachmentContext(partIndex);
+  const context = useComposerAttachmentContext2(partIndex);
   return /* @__PURE__ */ jsx29(AttachmentContext.Provider, { value: context, children });
 };
 
@@ -3736,8 +3834,7 @@ var getComponent2 = (components, attachment) => {
   }
 };
 var AttachmentComponent2 = ({ components }) => {
-  const { useAttachment } = useAttachmentContext({ type: "composer" });
-  const Component = useAttachment(
+  const Component = useComposerAttachment(
     (a) => getComponent2(components, a.attachment)
   );
   if (!Component) return null;
@@ -3751,8 +3848,7 @@ var ComposerAttachment = memo4(
   (prev, next) => prev.attachmentIndex === next.attachmentIndex && prev.components?.Image === next.components?.Image && prev.components?.Document === next.components?.Document && prev.components?.File === next.components?.File && prev.components?.Attachment === next.components?.Attachment
 );
 var ComposerPrimitiveAttachments = ({ components }) => {
-  const { useComposer } = useThreadContext();
-  const attachmentsCount = useComposer((s) => s.attachments.length);
+  const attachmentsCount = useThreadComposer((s) => s.attachments.length);
   return Array.from({ length: attachmentsCount }, (_, index) => /* @__PURE__ */ jsx30(
     ComposerAttachment,
     {
@@ -3877,12 +3973,12 @@ import { useCallbackRef as useCallbackRef4 } from "@radix-ui/react-use-callback-
 import { useEffect as useEffect13 } from "react";
 var useOnScrollToBottom = (callback) => {
   const callbackRef = useCallbackRef4(callback);
-  const { useViewport } = useThreadContext();
+  const threadViewportStore = useThreadViewportStore();
   useEffect13(() => {
-    return useViewport.getState().onScrollToBottom(() => {
+    return threadViewportStore.getState().onScrollToBottom(() => {
       callbackRef();
     });
-  }, [useViewport, callbackRef]);
+  }, [threadViewportStore, callbackRef]);
 };
 
 // src/primitive-hooks/thread/useThreadViewportAutoScroll.tsx
@@ -3890,7 +3986,7 @@ var useThreadViewportAutoScroll = ({
   autoScroll = true
 }) => {
   const divRef = useRef5(null);
-  const { useViewport } = useThreadContext();
+  const threadViewportStore = useThreadViewportStore();
   const lastScrollTop = useRef5(0);
   const isScrollingToBottomRef = useRef5(false);
   const scrollToBottom = (behavior) => {
@@ -3902,7 +3998,7 @@ var useThreadViewportAutoScroll = ({
   const handleScroll = () => {
     const div = divRef.current;
     if (!div) return;
-    const isAtBottom = useViewport.getState().isAtBottom;
+    const isAtBottom = threadViewportStore.getState().isAtBottom;
     const newIsAtBottom = div.scrollHeight - div.scrollTop <= div.clientHeight + 1;
     if (!newIsAtBottom && lastScrollTop.current < div.scrollTop) {
     } else {
@@ -3910,13 +4006,15 @@ var useThreadViewportAutoScroll = ({
         isScrollingToBottomRef.current = false;
       }
       if (newIsAtBottom !== isAtBottom) {
-        writableStore(useViewport).setState({ isAtBottom: newIsAtBottom });
+        writableStore(threadViewportStore).setState({
+          isAtBottom: newIsAtBottom
+        });
       }
     }
     lastScrollTop.current = div.scrollTop;
   };
   const resizeRef = useOnResizeContent(() => {
-    if (isScrollingToBottomRef.current || useViewport.getState().isAtBottom) {
+    if (isScrollingToBottomRef.current || threadViewportStore.getState().isAtBottom) {
       scrollToBottom("instant");
     }
     handleScroll();
@@ -3936,7 +4034,7 @@ var useThreadViewportAutoScroll = ({
 
 // src/primitives/thread/ThreadViewport.tsx
 import { jsx as jsx32 } from "react/jsx-runtime";
-var ThreadPrimitiveViewport = forwardRef18(({ autoScroll, onScroll, children, ...rest }, forwardedRef) => {
+var ThreadPrimitiveViewport = forwardRef18(({ autoScroll, children, ...rest }, forwardedRef) => {
   const autoScrollRef = useThreadViewportAutoScroll({
     autoScroll
   });
@@ -3950,14 +4048,15 @@ import { memo as memo5 } from "react";
 
 // src/context/providers/MessageProvider.tsx
 import { useEffect as useEffect14, useState as useState14 } from "react";
-import { create as create18 } from "zustand";
+import { create as create17 } from "zustand";
 
 // src/context/stores/EditComposer.ts
-import { create as create16 } from "zustand";
+import { create as create15 } from "zustand";
 var makeEditComposerStore = ({
   onEdit,
   onSend
-}) => create16()((set, get) => ({
+}) => create15()((set, get) => ({
+  type: "edit",
   get value() {
     return get().text;
   },
@@ -3991,8 +4090,8 @@ var makeEditComposerStore = ({
 }));
 
 // src/context/stores/MessageUtils.ts
-import { create as create17 } from "zustand";
-var makeMessageUtilsStore = () => create17((set) => {
+import { create as create16 } from "zustand";
+var makeMessageUtilsStore = () => create16((set) => {
   let utterance = null;
   return {
     isCopied: false,
@@ -4022,13 +4121,13 @@ import { jsx as jsx33 } from "react/jsx-runtime";
 var getIsLast = (messages, message) => {
   return messages[messages.length - 1]?.id === message.id;
 };
-var getMessageState = (messages, getBranches, useMessage, messageIndex) => {
+var getMessageState = (messages, getBranches, useMessage2, messageIndex) => {
   const parentId = messages[messageIndex - 1]?.id ?? null;
   const message = messages[messageIndex];
   if (!message) return null;
   const isLast = getIsLast(messages, message);
   const branches = getBranches(message.id);
-  const currentState = useMessage?.getState();
+  const currentState = useMessage2?.getState();
   if (currentState && currentState.message === message && currentState.parentId === parentId && currentState.branches === branches && currentState.isLast === isLast)
     return null;
   return Object.freeze({
@@ -4039,31 +4138,32 @@ var getMessageState = (messages, getBranches, useMessage, messageIndex) => {
   });
 };
 var useMessageContext2 = (messageIndex) => {
-  const { useThreadMessages, useThreadActions } = useThreadContext();
+  const threadMessagesStore = useThreadMessagesStore();
+  const threadActionsStore = useThreadActionsStore();
   const [context] = useState14(() => {
-    const useMessage = create18(
+    const useMessage2 = create17(
       () => getMessageState(
-        useThreadMessages.getState(),
-        useThreadActions.getState().getBranches,
+        threadMessagesStore.getState(),
+        threadActionsStore.getState().getBranches,
         void 0,
         messageIndex
       )
     );
-    const useMessageUtils = makeMessageUtilsStore();
-    const useEditComposer = makeEditComposerStore({
+    const useMessageUtils2 = makeMessageUtilsStore();
+    const useEditComposer2 = makeEditComposerStore({
       onEdit: () => {
-        const message = useMessage.getState().message;
+        const message = useMessage2.getState().message;
         const text = getThreadMessageText(message);
         return text;
       },
       onSend: (text) => {
-        const { message, parentId } = useMessage.getState();
+        const { message, parentId } = useMessage2.getState();
         const previousText = getThreadMessageText(message);
         if (previousText === text) return;
         const nonTextParts = message.content.filter(
           (part) => part.type !== "text" && part.type !== "ui"
         );
-        useThreadActions.getState().append({
+        threadActionsStore.getState().append({
           parentId,
           role: message.role,
           content: [{ type: "text", text }, ...nonTextParts],
@@ -4071,22 +4171,22 @@ var useMessageContext2 = (messageIndex) => {
         });
       }
     });
-    return { useMessage, useMessageUtils, useEditComposer };
+    return { useMessage: useMessage2, useMessageUtils: useMessageUtils2, useEditComposer: useEditComposer2 };
   });
   useEffect14(() => {
     const syncMessage = (thread) => {
       const newState = getMessageState(
         thread,
-        useThreadActions.getState().getBranches,
+        threadActionsStore.getState().getBranches,
         context.useMessage,
         messageIndex
       );
       if (!newState) return;
       writableStore(context.useMessage).setState(newState, true);
     };
-    syncMessage(useThreadMessages.getState());
-    return useThreadMessages.subscribe(syncMessage);
-  }, [useThreadMessages, useThreadActions, context, messageIndex]);
+    syncMessage(threadMessagesStore.getState());
+    return threadMessagesStore.subscribe(syncMessage);
+  }, [threadMessagesStore, threadActionsStore, context, messageIndex]);
   return context;
 };
 var MessageProvider = ({
@@ -4131,7 +4231,6 @@ var getComponent3 = (components, role, isEditing) => {
 var ThreadMessageComponent = ({
   components
 }) => {
-  const { useMessage, useEditComposer } = useMessageContext();
   const role = useMessage((m) => m.message.role);
   const isEditing = useEditComposer((c) => c.isEditing);
   const Component = getComponent3(components, role, isEditing);
@@ -4150,7 +4249,6 @@ var ThreadMessage = memo5(
 var ThreadPrimitiveMessagesImpl = ({
   components
 }) => {
-  const { useThreadMessages } = useThreadContext();
   const messagesLength = useThreadMessages((t) => t.length);
   if (messagesLength === 0) return null;
   return Array.from({ length: messagesLength }, (_, index) => /* @__PURE__ */ jsx34(ThreadMessage, { messageIndex: index, components }, index));
@@ -4177,21 +4275,21 @@ var ThreadPrimitiveSuggestion = createActionButton(
 // src/ui/thread-config.tsx
 import {
   createContext as createContext7,
-  useContext as useContext7
+  useContext as useContext4
 } from "react";
 import { Fragment as Fragment3, jsx as jsx35 } from "react/jsx-runtime";
 var ThreadConfigContext = createContext7({});
 var useThreadConfig = () => {
-  return useContext7(ThreadConfigContext);
+  return useContext4(ThreadConfigContext);
 };
 var ThreadConfigProvider = ({
   children,
   config
 }) => {
-  const assistant = useAssistantContext({ optional: true });
+  const hasAssistant = !!useAssistantRuntimeStore({ optional: true });
   const configProvider = config && Object.keys(config ?? {}).length > 0 ? /* @__PURE__ */ jsx35(ThreadConfigContext.Provider, { value: config, children }) : /* @__PURE__ */ jsx35(Fragment3, { children });
   if (!config?.runtime) return configProvider;
-  if (assistant) {
+  if (hasAssistant) {
     throw new Error(
       "You provided a runtime to <Thread> while simulataneously using <AssistantRuntimeProvider>. This is not allowed."
     );
@@ -4212,19 +4310,16 @@ import {
 import { Fragment as Fragment4, jsx as jsx36, jsxs as jsxs4 } from "react/jsx-runtime";
 var useAllowCopy = (ensureCapability = false) => {
   const { assistantMessage: { allowCopy = true } = {} } = useThreadConfig();
-  const { useThread } = useThreadContext();
   const copySupported = useThread((t) => t.capabilities.unstable_copy);
   return allowCopy && (!ensureCapability || copySupported);
 };
 var useAllowSpeak = (ensureCapability = false) => {
   const { assistantMessage: { allowSpeak = true } = {} } = useThreadConfig();
-  const { useThread } = useThreadContext();
   const speakSupported = useThread((t) => t.capabilities.speak);
   return allowSpeak && (!ensureCapability || speakSupported);
 };
 var useAllowReload = (ensureCapability = false) => {
   const { assistantMessage: { allowReload = true } = {} } = useThreadConfig();
-  const { useThread } = useThreadContext();
   const reloadSupported = useThread((t) => t.capabilities.reload);
   return allowReload && (!ensureCapability || reloadSupported);
 };
@@ -4324,7 +4419,6 @@ import { ChevronLeftIcon, ChevronRightIcon } from "lucide-react";
 import { jsx as jsx37, jsxs as jsxs5 } from "react/jsx-runtime";
 var useAllowBranchPicker = (ensureCapability = false) => {
   const { branchPicker: { allowBranchPicker = true } = {} } = useThreadConfig();
-  const { useThread } = useThreadContext();
   const branchPickerSupported = useThread((t) => t.capabilities.edit);
   return allowBranchPicker && (!ensureCapability || branchPickerSupported);
 };
@@ -4518,8 +4612,7 @@ var ComposerAttachmentRoot = withDefaults("div", {
 });
 ComposerAttachmentRoot.displayName = "ComposerAttachmentRoot";
 var ComposerAttachment2 = () => {
-  const { useAttachment } = useAttachmentContext({ type: "composer" });
-  const attachment = useAttachment((a) => a.attachment);
+  const attachment = useComposerAttachment((a) => a.attachment);
   return /* @__PURE__ */ jsxs8(ComposerAttachmentRoot, { children: [
     ".",
     attachment.name.split(".").pop(),
@@ -4533,10 +4626,10 @@ var ComposerAttachmentRemove = forwardRef22((props, ref) => {
       composer: { removeAttachment: { tooltip = "Remove file" } = {} } = {}
     } = {}
   } = useThreadConfig();
-  const { useComposer } = useThreadContext();
-  const { useAttachment } = useAttachmentContext();
+  const composerStore = useThreadComposerStore();
+  const attachmentStore = useAttachmentStore();
   const handleRemoveAttachment = () => {
-    useComposer.getState().removeAttachment(useAttachment.getState().attachment.id);
+    composerStore.getState().removeAttachment(attachmentStore.getState().attachment.id);
   };
   return /* @__PURE__ */ jsx42(
     TooltipIconButton,
@@ -4565,7 +4658,6 @@ var composer_attachment_default = Object.assign(
 import { Fragment as Fragment5, jsx as jsx43, jsxs as jsxs9 } from "react/jsx-runtime";
 var useAllowAttachments = (ensureCapability = false) => {
   const { composer: { allowAttachments = true } = {} } = useThreadConfig();
-  const { useThread } = useThreadContext();
   const attachmentsSupported = useThread((t) => t.capabilities.attachments);
   return allowAttachments && (!ensureCapability || attachmentsSupported);
 };
@@ -4637,7 +4729,6 @@ var ComposerAddAttachment = forwardRef23((props, ref) => {
 });
 ComposerAddAttachment.displayName = "ComposerAddAttachment";
 var useAllowCancel = () => {
-  const { useThread } = useThreadContext();
   const cancelSupported = useThread((t) => t.capabilities.cancel);
   return cancelSupported;
 };
@@ -4766,7 +4857,6 @@ import { PencilIcon } from "lucide-react";
 import { jsx as jsx45 } from "react/jsx-runtime";
 var useAllowEdit = (ensureCapability = false) => {
   const { userMessage: { allowEdit = true } = {} } = useThreadConfig();
-  const { useThread } = useThreadContext();
   const editSupported = useThread((t) => t.capabilities.edit);
   return allowEdit && (!ensureCapability || editSupported);
 };
@@ -4801,7 +4891,6 @@ var UserMessageAttachmentRoot = withDefaults("div", {
 });
 UserMessageAttachmentRoot.displayName = "UserMessageAttachmentRoot";
 var UserMessageAttachment = () => {
-  const { useAttachment } = useAttachmentContext();
   const attachment = useAttachment((a) => a.attachment);
   return /* @__PURE__ */ jsxs11(UserMessageAttachmentRoot, { children: [
     ".",
@@ -5123,36 +5212,64 @@ export {
   useActionBarSpeak,
   useActionBarStopSpeaking,
   useAppendMessage,
+  useAssistantActions,
+  useAssistantActionsStore,
   useAssistantContext,
   useAssistantInstructions,
+  useAssistantRuntime,
+  useAssistantRuntimeStore,
   useAssistantTool,
   useAssistantToolUI,
   useBranchPickerCount,
   useBranchPickerNext,
   useBranchPickerNumber,
   useBranchPickerPrevious,
+  useComposer,
   useComposerAddAttachment,
   useComposerCancel,
   useComposerContext,
   useComposerIf,
   useComposerSend,
+  useComposerStore,
+  useContentPart,
   useContentPartContext,
   useContentPartDisplay,
   useContentPartImage,
+  useContentPartStore,
   useContentPartText,
   useDangerousInBrowserRuntime,
   useEdgeRuntime,
+  useEditComposer,
+  useEditComposerStore,
   useExternalMessageConverter,
   useExternalStoreRuntime,
   useLocalRuntime,
+  useMessage,
   useMessageContext,
   useMessageIf,
+  useMessageStore,
+  useMessageUtils,
+  useMessageUtilsStore,
   useSwitchToNewThread,
+  useThread,
+  useThreadActions,
+  useThreadActionsStore,
+  useThreadComposer,
+  useThreadComposerStore,
   useThreadConfig,
   useThreadContext,
   useThreadEmpty,
   useThreadIf,
+  useThreadMessages,
+  useThreadMessagesStore,
+  useThreadRuntime,
+  useThreadRuntimeStore,
   useThreadScrollToBottom,
-  useThreadSuggestion
+  useThreadStore,
+  useThreadSuggestion,
+  useThreadViewport,
+  useThreadViewportStore,
+  useToolUIs,
+  useToolUIsStore
 };
 //# sourceMappingURL=index.mjs.map