@assistant-ui/react 0.5.53 → 0.5.56

package/dist/index.js

@@ -10,7 +10,7 @@
 
 
 
-var _chunk4LR4BB23js = require('./chunk-4LR4BB23.js');
+var _chunkCWAZOKEWjs = require('./chunk-CWAZOKEW.js');
 
 
 var _chunkDCHYNTHIjs = require('./chunk-DCHYNTHI.js');
@@ -23,56 +23,76 @@ var _react = require('react');
 
 // src/context/react/AssistantContext.ts
 
-var AssistantContext = _react.createContext.call(void 0, 
-  null
-);
-function useAssistantContext(options) {
-  const context = _react.useContext.call(void 0, AssistantContext);
-  if (!_optionalChain([options, 'optionalAccess', _2 => _2.optional]) && !context)
-    throw new Error(
-      "This component must be used within an AssistantRuntimeProvider."
-    );
-  return context;
-}
 
-// src/context/stores/AssistantModelConfig.ts
-var _zustand = require('zustand');
+// src/context/react/utils/createContextHook.ts
 
-// src/utils/ProxyConfigProvider.ts
-var ProxyConfigProvider = (_class = class {constructor() { _class.prototype.__init.call(this); }
-  __init() {this._providers = /* @__PURE__ */ new Set()}
-  getModelConfig() {
-    return _chunk4LR4BB23js.mergeModelConfigs.call(void 0, this._providers);
-  }
-  registerModelConfigProvider(provider) {
-    this._providers.add(provider);
-    return () => {
-      this._providers.delete(provider);
-    };
+function createContextHook(context, providerName) {
+  function useContextHook(options) {
+    const contextValue = _react.useContext.call(void 0, context);
+    if (!_optionalChain([options, 'optionalAccess', _2 => _2.optional]) && !contextValue) {
+      throw new Error(`This component must be used within ${providerName}.`);
+    }
+    return contextValue;
   }
-}, _class);
+  return useContextHook;
+}
 
-// src/context/stores/AssistantModelConfig.ts
-var makeAssistantModelConfigStore = () => _zustand.create.call(void 0, () => {
-  const proxy = new ProxyConfigProvider();
-  return Object.freeze({
-    getModelConfig: () => {
-      return proxy.getModelConfig();
-    },
-    registerModelConfigProvider: (provider) => {
-      return proxy.registerModelConfigProvider(provider);
+// src/context/react/utils/createContextStoreHook.ts
+function createContextStoreHook(contextHook, contextKey) {
+  function useStoreStoreHook(options) {
+    const context = contextHook(options);
+    if (!context) {
+      if (!_optionalChain([options, 'optionalAccess', _3 => _3.optional])) {
+        throw new Error(`This component must be used within a ${contextKey}.`);
+      }
+      return null;
     }
-  });
-});
+    return context[contextKey];
+  }
+  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/AssistantToolUIs.ts
+// src/context/react/AssistantContext.ts
+var AssistantContext = _react.createContext.call(void 0, 
+  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
+var _zustand = require('zustand');
 var makeAssistantToolUIsStore = () => _zustand.create.call(void 0, (set) => {
   const renderers = /* @__PURE__ */ new Map();
   return Object.freeze({
     getToolUI: (name) => {
       const arr = renderers.get(name);
-      const last = _optionalChain([arr, 'optionalAccess', _3 => _3.at, 'call', _4 => _4(-1)]);
+      const last = _optionalChain([arr, 'optionalAccess', _4 => _4.at, 'call', _5 => _5(-1)]);
       if (last) return last;
       return null;
     },
@@ -103,51 +123,64 @@ var makeAssistantToolUIsStore = () => _zustand.create.call(void 0, (set) => {
 // src/context/react/ThreadContext.ts
 
 var ThreadContext = _react.createContext.call(void 0, null);
-function useThreadContext(options) {
-  const context = _react.useContext.call(void 0, ThreadContext);
-  if (!_optionalChain([options, 'optionalAccess', _5 => _5.optional]) && !context)
-    throw new Error(
-      "This component must be used within an AssistantRuntimeProvider."
-    );
-  return context;
-}
-
-// src/context/stores/Composer.ts
-
-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
+
+var makeThreadComposerStore = (useThreadRuntime2) => {
   const focusListeners = /* @__PURE__ */ new Set();
   return _zustand.create.call(void 0, )((_, get) => {
-    const runtime = useThreadRuntime.getState();
+    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) {
@@ -252,8 +285,8 @@ var subscribeToMainThread = (runtime, callback) => {
 
 
 // src/runtimes/core/BaseAssistantRuntime.tsx
-var BaseAssistantRuntime = (_class2 = class {
-  constructor(_thread) {;_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);
+var BaseAssistantRuntime = (_class = class {
+  constructor(_thread) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
     this._thread = _thread;
     this._thread = _thread;
   }
@@ -264,15 +297,15 @@ var BaseAssistantRuntime = (_class2 = class {
     this._thread = thread;
     this.subscriptionHandler();
   }
-  __init2() {this._subscriptions = /* @__PURE__ */ new Set()}
+  __init() {this._subscriptions = /* @__PURE__ */ new Set()}
   subscribe(callback) {
     this._subscriptions.add(callback);
     return () => this._subscriptions.delete(callback);
   }
-  __init3() {this.subscriptionHandler = () => {
+  __init2() {this.subscriptionHandler = () => {
     for (const callback of this._subscriptions) callback();
   }}
-}, _class2);
+}, _class);
 
 // src/internal.ts
 var internal_exports = {};
@@ -289,13 +322,13 @@ _chunkDCHYNTHIjs.__export.call(void 0, internal_exports, {
 });
 
 // src/runtimes/utils/ThreadRuntimeComposer.tsx
-var ThreadRuntimeComposer = (_class3 = class {
-  constructor(runtime, notifySubscribers) {;_class3.prototype.__init4.call(this);_class3.prototype.__init5.call(this);_class3.prototype.__init6.call(this);
+var ThreadRuntimeComposer = (_class2 = class {
+  constructor(runtime, notifySubscribers) {;_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);
     this.runtime = runtime;
     this.notifySubscribers = notifySubscribers;
   }
   
-  __init4() {this.attachmentAccept = "*"}
+  __init3() {this.attachmentAccept = "*"}
   get isEmpty() {
     return !this.text.trim() && !this.attachments.length;
   }
@@ -308,7 +341,7 @@ var ThreadRuntimeComposer = (_class3 = class {
     }
     return false;
   }
-  __init5() {this._attachments = []}
+  __init4() {this._attachments = []}
   get attachments() {
     return this._attachments;
   }
@@ -329,7 +362,7 @@ var ThreadRuntimeComposer = (_class3 = class {
     this._attachments = this._attachments.toSpliced(index, 1);
     this.notifySubscribers();
   }
-  __init6() {this._text = ""}
+  __init5() {this._text = ""}
   get text() {
     return this._text;
   }
@@ -356,6 +389,20 @@ var ThreadRuntimeComposer = (_class3 = class {
     });
     this.reset();
   }
+}, _class2);
+
+// src/utils/ProxyConfigProvider.ts
+var ProxyConfigProvider = (_class3 = class {constructor() { _class3.prototype.__init6.call(this); }
+  __init6() {this._providers = /* @__PURE__ */ new Set()}
+  getModelConfig() {
+    return _chunkCWAZOKEWjs.mergeModelConfigs.call(void 0, this._providers);
+  }
+  registerModelConfigProvider(provider) {
+    this._providers.add(provider);
+    return () => {
+      this._providers.delete(provider);
+    };
+  }
 }, _class3);
 
 // src/utils/idUtils.tsx
@@ -609,6 +656,7 @@ var MessageRepository = (_class4 = class {constructor() { _class4.prototype.__in
 
 // src/utils/smooth/useSmooth.tsx
 
+var _reactusecallbackref = require('@radix-ui/react-use-callback-ref');
 
 // src/utils/smooth/SmoothContext.tsx
 
@@ -618,6 +666,22 @@ var MessageRepository = (_class4 = class {constructor() { _class4.prototype.__in
 
 
 
+
+// src/context/react/ContentPartContext.ts
+
+var ContentPartContext = _react.createContext.call(void 0, 
+  null
+);
+var useContentPartContext = createContextHook(
+  ContentPartContext,
+  "a component passed to <MessagePrimitive.Content components={...}>"
+);
+var { useContentPart, useContentPartStore } = createContextStoreHook(
+  useContentPartContext,
+  "useContentPart"
+);
+
+// src/utils/smooth/SmoothContext.tsx
 var _jsxruntime = require('react/jsx-runtime');
 var SmoothContext = _react.createContext.call(void 0, null);
 var makeSmoothContext = (initialState) => {
@@ -626,9 +690,9 @@ var makeSmoothContext = (initialState) => {
 };
 var SmoothContextProvider = ({ children }) => {
   const outer = useSmoothContext({ optional: true });
-  const { useContentPart } = useContentPartContext();
+  const contentPartStore = useContentPartStore();
   const [context] = _react.useState.call(void 0, 
-    () => makeSmoothContext(useContentPart.getState().status)
+    () => makeSmoothContext(contentPartStore.getState().status)
   );
   if (outer) return children;
   return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, SmoothContext.Provider, { value: context, children });
@@ -648,13 +712,17 @@ function useSmoothContext(options) {
     );
   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
-var _reactusecallbackref = require('@radix-ui/react-use-callback-ref');
 var TextStreamAnimator = (_class5 = class {
   constructor(currentText, setText) {;_class5.prototype.__init10.call(this);_class5.prototype.__init11.call(this);_class5.prototype.__init12.call(this);_class5.prototype.__init13.call(this);
     this.currentText = currentText;
@@ -703,21 +771,28 @@ var SMOOTH_STATUS = Object.freeze({
   type: "running"
 });
 var useSmooth = (state, smooth = false) => {
-  const { useSmoothStatus: useSmoothStatus2 } = _nullishCoalesce(useSmoothContext({ optional: true }), () => ( {}));
   const {
     part: { text }
   } = state;
-  const { useMessage } = useMessageContext();
   const id = useMessage((m) => m.message.id);
   const idRef = _react.useRef.call(void 0, id);
   const [displayedText, setDisplayedText] = _react.useState.call(void 0, text);
+  const smoothStatusStore = useSmoothStatusStore({ optional: true });
   const setText = _reactusecallbackref.useCallbackRef.call(void 0, (text2) => {
     setDisplayedText(text2);
-    _optionalChain([useSmoothStatus2, 'optionalAccess', _31 => _31.setState, 'call', _32 => _32(text2 !== state.part.text ? SMOOTH_STATUS : state.status)]);
+    if (smoothStatusStore) {
+      writableStore(smoothStatusStore).setState(
+        text2 !== state.part.text ? SMOOTH_STATUS : state.status
+      );
+    }
   });
   _react.useEffect.call(void 0, () => {
-    _optionalChain([useSmoothStatus2, 'optionalAccess', _33 => _33.setState, 'call', _34 => _34(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] = _react.useState.call(void 0, 
     new TextStreamAnimator(text, setText)
   );
@@ -910,7 +985,7 @@ var fromLanguageModelMessages = (lm, { mergeRoundtrips }) => {
         });
         if (mergeRoundtrips) {
           const previousMessage = messages[messages.length - 1];
-          if (_optionalChain([previousMessage, 'optionalAccess', _35 => _35.role]) === "assistant") {
+          if (_optionalChain([previousMessage, 'optionalAccess', _31 => _31.role]) === "assistant") {
             previousMessage.content.push(...newContent);
             break;
           }
@@ -923,7 +998,7 @@ var fromLanguageModelMessages = (lm, { mergeRoundtrips }) => {
       }
       case "tool": {
         const previousMessage = messages[messages.length - 1];
-        if (_optionalChain([previousMessage, 'optionalAccess', _36 => _36.role]) !== "assistant")
+        if (_optionalChain([previousMessage, 'optionalAccess', _32 => _32.role]) !== "assistant")
           throw new Error(
             "A tool message must be preceded by an assistant message."
           );
@@ -999,14 +1074,14 @@ function streamPartDecoderStream() {
       controller.enqueue(decodeStreamPart(chunk));
     }
   });
-  return new (0, _chunk4LR4BB23js.PipeableTransformStream)((readable) => {
+  return new (0, _chunkCWAZOKEWjs.PipeableTransformStream)((readable) => {
     return readable.pipeThrough(new TextDecoderStream()).pipeThrough(chunkByLineStream()).pipeThrough(decodeStream);
   });
 }
 
 // src/runtimes/edge/streams/utils/index.ts
 var streamUtils = {
-  streamPartEncoderStream: _chunk4LR4BB23js.streamPartEncoderStream,
+  streamPartEncoderStream: _chunkCWAZOKEWjs.streamPartEncoderStream,
   streamPartDecoderStream
 };
 
@@ -1115,8 +1190,8 @@ var EdgeChatAdapter = class {
       credentials: _nullishCoalesce(this.options.credentials, () => ( "same-origin")),
       body: JSON.stringify({
         system: config.system,
-        messages: _chunk4LR4BB23js.toCoreMessages.call(void 0, messages),
-        tools: config.tools ? _chunk4LR4BB23js.toLanguageModelTools.call(void 0, config.tools) : [],
+        messages: _chunkCWAZOKEWjs.toCoreMessages.call(void 0, messages),
+        tools: config.tools ? _chunkCWAZOKEWjs.toLanguageModelTools.call(void 0, config.tools) : [],
         ...config.callSettings,
         ...config.config,
         ...this.options.body
@@ -1126,7 +1201,7 @@ var EdgeChatAdapter = class {
     if (result.status !== 200) {
       throw new Error(`Status ${result.status}: ${await result.text()}`);
     }
-    const stream = result.body.pipeThrough(streamPartDecoderStream()).pipeThrough(assistantDecoderStream()).pipeThrough(_chunk4LR4BB23js.toolResultStream.call(void 0, config.tools, abortSignal)).pipeThrough(_chunk4LR4BB23js.runResultStream.call(void 0, ));
+    const stream = result.body.pipeThrough(streamPartDecoderStream()).pipeThrough(assistantDecoderStream()).pipeThrough(_chunkCWAZOKEWjs.toolResultStream.call(void 0, config.tools, abortSignal)).pipeThrough(_chunkCWAZOKEWjs.runResultStream.call(void 0, ));
     let update;
     for await (update of asAsyncIterable(stream)) {
       yield update;
@@ -1152,7 +1227,7 @@ var useEdgeRuntime = ({
 };
 
 // src/runtimes/local/shouldContinue.tsx
-var shouldContinue = (result) => _optionalChain([result, 'access', _37 => _37.status, 'optionalAccess', _38 => _38.type]) === "requires-action" && result.status.reason === "tool-calls" && result.content.every((c) => c.type !== "tool-call" || !!c.result);
+var shouldContinue = (result) => _optionalChain([result, 'access', _33 => _33.status, 'optionalAccess', _34 => _34.type]) === "requires-action" && result.status.reason === "tool-calls" && result.content.every((c) => c.type !== "tool-call" || !!c.result);
 
 // src/runtimes/local/LocalThreadRuntime.tsx
 var LocalThreadRuntime = (_class6 = class {
@@ -1198,13 +1273,13 @@ var LocalThreadRuntime = (_class6 = class {
   set options({ initialMessages, ...options }) {
     this._options = options;
     let hasUpdates = false;
-    const canSpeak = _optionalChain([options, 'access', _39 => _39.adapters, 'optionalAccess', _40 => _40.speech]) !== void 0;
+    const canSpeak = _optionalChain([options, 'access', _35 => _35.adapters, 'optionalAccess', _36 => _36.speech]) !== void 0;
     if (this.capabilities.speak !== canSpeak) {
       this.capabilities.speak = canSpeak;
       hasUpdates = true;
     }
-    this.composer.setAttachmentAdapter(_optionalChain([options, 'access', _41 => _41.adapters, 'optionalAccess', _42 => _42.attachments]));
-    const canAttach = _optionalChain([options, 'access', _43 => _43.adapters, 'optionalAccess', _44 => _44.attachments]) !== void 0;
+    this.composer.setAttachmentAdapter(_optionalChain([options, 'access', _37 => _37.adapters, 'optionalAccess', _38 => _38.attachments]));
+    const canAttach = _optionalChain([options, 'access', _39 => _39.adapters, 'optionalAccess', _40 => _40.attachments]) !== void 0;
     if (this.capabilities.attachments !== canAttach) {
       this.capabilities.attachments = canAttach;
       hasUpdates = true;
@@ -1246,18 +1321,18 @@ var LocalThreadRuntime = (_class6 = class {
   }
   async performRoundtrip(parentId, message) {
     const messages = this.repository.getMessages();
-    _optionalChain([this, 'access', _45 => _45.abortController, 'optionalAccess', _46 => _46.abort, 'call', _47 => _47()]);
+    _optionalChain([this, 'access', _41 => _41.abortController, 'optionalAccess', _42 => _42.abort, 'call', _43 => _43()]);
     this.abortController = new AbortController();
     const initialContent = message.content;
-    const initialRoundtrips = _optionalChain([message, 'access', _48 => _48.metadata, 'optionalAccess', _49 => _49.roundtrips]);
-    const initalCustom = _optionalChain([message, 'access', _50 => _50.metadata, 'optionalAccess', _51 => _51.custom]);
+    const initialRoundtrips = _optionalChain([message, 'access', _44 => _44.metadata, 'optionalAccess', _45 => _45.roundtrips]);
+    const initalCustom = _optionalChain([message, 'access', _46 => _46.metadata, 'optionalAccess', _47 => _47.custom]);
     const updateMessage = (m) => {
       message = {
         ...message,
         ...m.content ? { content: [...initialContent, ..._nullishCoalesce(m.content, () => ( []))] } : void 0,
         status: _nullishCoalesce(m.status, () => ( message.status)),
         // TODO deprecated, remove in v0.6
-        ..._optionalChain([m, 'access', _52 => _52.metadata, 'optionalAccess', _53 => _53.roundtrips]) ? {
+        ..._optionalChain([m, 'access', _48 => _48.metadata, 'optionalAccess', _49 => _49.roundtrips]) ? {
           roundtrips: [
             ..._nullishCoalesce(initialRoundtrips, () => ( [])),
             ...m.metadata.roundtrips
@@ -1272,7 +1347,7 @@ var LocalThreadRuntime = (_class6 = class {
                 ...m.metadata.roundtrips
               ]
             } : void 0,
-            ..._optionalChain([m, 'access', _54 => _54.metadata, 'optionalAccess', _55 => _55.custom]) ? {
+            ..._optionalChain([m, 'access', _50 => _50.metadata, 'optionalAccess', _51 => _51.custom]) ? {
               custom: { ..._nullishCoalesce(initalCustom, () => ( {})), ...m.metadata.custom }
             } : void 0
           }
@@ -1282,7 +1357,7 @@ var LocalThreadRuntime = (_class6 = class {
       this.notifySubscribers();
     };
     const maxToolRoundtrips = _nullishCoalesce(this.options.maxToolRoundtrips, () => ( 1));
-    const toolRoundtrips = _nullishCoalesce(_optionalChain([message, 'access', _56 => _56.metadata, 'optionalAccess', _57 => _57.roundtrips, 'optionalAccess', _58 => _58.length]), () => ( 0));
+    const toolRoundtrips = _nullishCoalesce(_optionalChain([message, 'access', _52 => _52.metadata, 'optionalAccess', _53 => _53.roundtrips, 'optionalAccess', _54 => _54.length]), () => ( 0));
     if (toolRoundtrips > maxToolRoundtrips) {
       updateMessage({
         status: {
@@ -1350,7 +1425,9 @@ var LocalThreadRuntime = (_class6 = 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;
@@ -1379,7 +1456,7 @@ var LocalThreadRuntime = (_class6 = class {
   // TODO lift utterance state to thread runtime
   
   speak(messageId) {
-    const adapter = _optionalChain([this, 'access', _59 => _59.options, 'access', _60 => _60.adapters, 'optionalAccess', _61 => _61.speech]);
+    const adapter = _optionalChain([this, 'access', _55 => _55.options, 'access', _56 => _56.adapters, 'optionalAccess', _57 => _57.speech]);
     if (!adapter) throw new Error("Speech adapter not configured");
     const { message } = this.repository.getMessage(messageId);
     if (this._utterance) {
@@ -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
   } = {}) {
@@ -1440,7 +1520,7 @@ var LocalRuntime = class extends BaseAssistantRuntime {
     const messages = fromCoreMessages(initialMessages);
     this.thread.import({
       messages: messages.map((m, idx) => ({
-        parentId: _nullishCoalesce(_optionalChain([messages, 'access', _62 => _62[idx - 1], 'optionalAccess', _63 => _63.id]), () => ( null)),
+        parentId: _nullishCoalesce(_optionalChain([messages, 'access', _58 => _58[idx - 1], 'optionalAccess', _59 => _59.id]), () => ( null)),
         message: m
       }))
     });
@@ -1569,7 +1649,7 @@ var getThreadMessageText = (message) => {
 
 // src/runtimes/external-store/ExternalStoreThreadRuntime.tsx
 var hasUpcomingMessage = (isRunning, messages) => {
-  return isRunning && _optionalChain([messages, 'access', _64 => _64[messages.length - 1], 'optionalAccess', _65 => _65.role]) !== "assistant";
+  return isRunning && _optionalChain([messages, 'access', _60 => _60[messages.length - 1], 'optionalAccess', _61 => _61.role]) !== "assistant";
 };
 var ExternalStoreThreadRuntime = (_class8 = class {
   __init21() {this._subscriptions = /* @__PURE__ */ new Set()}
@@ -1615,11 +1695,11 @@ var ExternalStoreThreadRuntime = (_class8 = class {
       reload: this._store.onReload !== void 0,
       cancel: this._store.onCancel !== void 0,
       speak: this._store.onSpeak !== void 0,
-      unstable_copy: _optionalChain([this, 'access', _69 => _69._store, 'access', _70 => _70.unstable_capabilities, 'optionalAccess', _71 => _71.copy]) !== false,
+      unstable_copy: _optionalChain([this, 'access', _65 => _65._store, 'access', _66 => _66.unstable_capabilities, 'optionalAccess', _67 => _67.copy]) !== false,
       // default true
-      attachments: !!_optionalChain([this, 'access', _72 => _72.store, 'access', _73 => _73.adapters, 'optionalAccess', _74 => _74.attachments])
+      attachments: !!_optionalChain([this, 'access', _68 => _68.store, 'access', _69 => _69.adapters, 'optionalAccess', _70 => _70.attachments])
     };
-    this.composer.setAttachmentAdapter(_optionalChain([this, 'access', _75 => _75._store, 'access', _76 => _76.adapters, 'optionalAccess', _77 => _77.attachments]));
+    this.composer.setAttachmentAdapter(_optionalChain([this, 'access', _71 => _71._store, 'access', _72 => _72.adapters, 'optionalAccess', _73 => _73.attachments]));
     if (oldStore) {
       if (oldStore.convertMessage !== store.convertMessage) {
         this.converter = new ThreadMessageConverter();
@@ -1645,7 +1725,7 @@ var ExternalStoreThreadRuntime = (_class8 = class {
     for (let i = 0; i < messages.length; i++) {
       const message = messages[i];
       const parent = messages[i - 1];
-      this.repository.addOrUpdateMessage(_nullishCoalesce(_optionalChain([parent, 'optionalAccess', _78 => _78.id]), () => ( null)), message);
+      this.repository.addOrUpdateMessage(_nullishCoalesce(_optionalChain([parent, 'optionalAccess', _74 => _74.id]), () => ( null)), message);
     }
     if (this.assistantOptimisticId) {
       this.repository.deleteMessage(this.assistantOptimisticId);
@@ -1653,7 +1733,7 @@ var ExternalStoreThreadRuntime = (_class8 = class {
     }
     if (hasUpcomingMessage(isRunning, messages)) {
       this.assistantOptimisticId = this.repository.appendOptimisticMessage(
-        _nullishCoalesce(_optionalChain([messages, 'access', _79 => _79.at, 'call', _80 => _80(-1), 'optionalAccess', _81 => _81.id]), () => ( null)),
+        _nullishCoalesce(_optionalChain([messages, 'access', _75 => _75.at, 'call', _76 => _76(-1), 'optionalAccess', _77 => _77.id]), () => ( null)),
         {
           role: "assistant",
           content: []
@@ -1661,7 +1741,7 @@ var ExternalStoreThreadRuntime = (_class8 = class {
       );
     }
     this.repository.resetHead(
-      _nullishCoalesce(_nullishCoalesce(this.assistantOptimisticId, () => ( _optionalChain([messages, 'access', _82 => _82.at, 'call', _83 => _83(-1), 'optionalAccess', _84 => _84.id]))), () => ( null))
+      _nullishCoalesce(_nullishCoalesce(this.assistantOptimisticId, () => ( _optionalChain([messages, 'access', _78 => _78.at, 'call', _79 => _79(-1), 'optionalAccess', _80 => _80.id]))), () => ( null))
     );
     this.messages = this.repository.getMessages();
     this.notifySubscribers();
@@ -1679,7 +1759,7 @@ var ExternalStoreThreadRuntime = (_class8 = class {
     this.updateMessages(this.repository.getMessages());
   }
   async append(message) {
-    if (message.parentId !== (_nullishCoalesce(_optionalChain([this, 'access', _85 => _85.messages, 'access', _86 => _86.at, 'call', _87 => _87(-1), 'optionalAccess', _88 => _88.id]), () => ( null)))) {
+    if (message.parentId !== (_nullishCoalesce(_optionalChain([this, 'access', _81 => _81.messages, 'access', _82 => _82.at, 'call', _83 => _83(-1), 'optionalAccess', _84 => _84.id]), () => ( null)))) {
       if (!this._store.onEdit)
         throw new Error("Runtime does not support editing messages.");
       await this._store.onEdit(message);
@@ -1702,7 +1782,7 @@ var ExternalStoreThreadRuntime = (_class8 = class {
     }
     let messages = this.repository.getMessages();
     const previousMessage = messages[messages.length - 1];
-    if (_optionalChain([previousMessage, 'optionalAccess', _89 => _89.role]) === "user" && previousMessage.id === _optionalChain([messages, 'access', _90 => _90.at, 'call', _91 => _91(-1), 'optionalAccess', _92 => _92.id])) {
+    if (_optionalChain([previousMessage, 'optionalAccess', _85 => _85.role]) === "user" && previousMessage.id === _optionalChain([messages, 'access', _86 => _86.at, 'call', _87 => _87(-1), 'optionalAccess', _88 => _88.id])) {
       this.repository.deleteMessage(previousMessage.id);
       if (!this.composer.text.trim()) {
         this.composer.setText(getThreadMessageText(previousMessage));
@@ -1731,7 +1811,7 @@ var ExternalStoreThreadRuntime = (_class8 = class {
     return () => this._subscriptions.delete(callback);
   }
   __init27() {this.updateMessages = (messages) => {
-    _optionalChain([this, 'access', _93 => _93._store, 'access', _94 => _94.setMessages, 'optionalCall', _95 => _95(
+    _optionalChain([this, 'access', _89 => _89._store, 'access', _90 => _90.setMessages, 'optionalCall', _91 => _91(
       messages.flatMap(getExternalStoreMessage).filter((m) => m != null)
     )]);
   }}
@@ -1755,23 +1835,26 @@ var ExternalStoreRuntime = (_class9 = 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();
     }
   }
 }, _class9);
@@ -1942,18 +2025,18 @@ var DangerousInBrowserAdapter = class {
     this.options = options;
   }
   async *run({ messages, abortSignal, config }) {
-    const res = await _chunk4LR4BB23js.getEdgeRuntimeStream.call(void 0, {
+    const res = await _chunkCWAZOKEWjs.getEdgeRuntimeStream.call(void 0, {
       options: this.options,
       abortSignal,
       requestData: {
         system: config.system,
-        messages: _chunk4LR4BB23js.toCoreMessages.call(void 0, messages),
-        tools: config.tools ? _chunk4LR4BB23js.toLanguageModelTools.call(void 0, config.tools) : [],
+        messages: _chunkCWAZOKEWjs.toCoreMessages.call(void 0, messages),
+        tools: config.tools ? _chunkCWAZOKEWjs.toLanguageModelTools.call(void 0, config.tools) : [],
         ...config.callSettings,
         ...config.config
       }
     });
-    const stream = res.pipeThrough(_chunk4LR4BB23js.toolResultStream.call(void 0, config.tools, abortSignal)).pipeThrough(_chunk4LR4BB23js.runResultStream.call(void 0, ));
+    const stream = res.pipeThrough(_chunkCWAZOKEWjs.toolResultStream.call(void 0, config.tools, abortSignal)).pipeThrough(_chunkCWAZOKEWjs.runResultStream.call(void 0, ));
     for await (const update of asAsyncIterable(stream)) {
       yield update;
     }
@@ -2146,11 +2229,6 @@ var CompositeAttachmentAdapter = class {
   }
 };
 
-// src/context/ReadonlyStore.ts
-var writableStore = (store) => {
-  return store;
-};
-
 // src/context/providers/ThreadProvider.tsx
 
 var ThreadProvider = ({
@@ -2158,18 +2236,18 @@ var ThreadProvider = ({
   provider
 }) => {
   const [context] = _react.useState.call(void 0, () => {
-    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
         });
@@ -2221,6 +2300,8 @@ var ThreadProvider = ({
 var makeAssistantActionsStore = (runtimeRef) => _zustand.create.call(void 0, 
   () => Object.freeze({
     switchToThread: () => runtimeRef.current.switchToThread(null),
+    switchToNewThread: () => runtimeRef.current.switchToNewThread(),
+    registerModelConfigProvider: (provider) => runtimeRef.current.registerModelConfigProvider(provider),
     getRuntime: () => runtimeRef.current
   })
 );
@@ -2239,21 +2320,15 @@ var AssistantProvider = ({ children, runtime }) => {
     runtimeRef.current = runtime;
   });
   const [context] = _react.useState.call(void 0, () => {
-    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();
-  _react.useEffect.call(void 0, () => {
-    return runtime.registerModelConfigProvider(getModelConfig);
-  }, [runtime, getModelConfig]);
   _react.useEffect.call(void 0, 
     () => writableStore(context.useAssistantRuntime).setState(runtime, true),
     [runtime, context]
@@ -2272,91 +2347,93 @@ var AssistantRuntimeProvider = _react.memo.call(void 0, AssistantRuntimeProvider
 
 
 
-// src/context/react/ContentPartContext.ts
-
-var ContentPartContext = _react.createContext.call(void 0, 
-  null
-);
-function useContentPartContext(options) {
-  const context = _react.useContext.call(void 0, ContentPartContext);
-  if (!_optionalChain([options, 'optionalAccess', _96 => _96.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
-
 var TextContentPartProvider = ({ children, text }) => {
   const [context] = _react.useState.call(void 0, () => {
-    const useContentPart = _zustand.create.call(void 0, () => ({
+    const useContentPart2 = _zustand.create.call(void 0, () => ({
       status: { type: "complete" },
       part: { type: "text", text }
     }));
     return {
-      useContentPart
+      useContentPart: useContentPart2
     };
   });
   return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ContentPartContext.Provider, { value: context, children });
 };
 
-// src/context/react/ComposerContext.ts
-
-
 // src/context/react/MessageContext.ts
 
 var MessageContext = _react.createContext.call(void 0, null);
-function useMessageContext(options) {
-  const context = _react.useContext.call(void 0, MessageContext);
-  if (!_optionalChain([options, 'optionalAccess', _97 => _97.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
+
 var useComposerContext = () => {
-  const { useComposer } = useThreadContext();
-  const { useEditComposer } = _nullishCoalesce(useMessageContext({ optional: true }), () => ( {}));
+  const { useComposer: useComposer2 } = useThreadContext();
+  const { useEditComposer: useEditComposer2 } = _nullishCoalesce(useMessageContext({ optional: true }), () => ( {}));
   return _react.useMemo.call(void 0, 
     () => ({
-      useComposer: _nullishCoalesce(useEditComposer, () => ( useComposer)),
-      type: useEditComposer ? "edit" : "new"
+      useComposer: _nullishCoalesce(useEditComposer2, () => ( useComposer2)),
+      type: useEditComposer2 ? "edit" : "new"
     }),
-    [useEditComposer, useComposer]
+    [useEditComposer2, useComposer2]
   );
 };
+var { useComposer, useComposerStore } = createContextStoreHook(
+  useComposerContext,
+  "useComposer"
+);
 
 // src/hooks/useAppendMessage.tsx
 
-var toAppendMessage = (useThreadMessages, message) => {
+var toAppendMessage = (useThreadMessages2, message) => {
   if (typeof message === "string") {
     return {
-      parentId: _nullishCoalesce(_optionalChain([useThreadMessages, 'access', _98 => _98.getState, 'call', _99 => _99(), 'access', _100 => _100.at, 'call', _101 => _101(-1), 'optionalAccess', _102 => _102.id]), () => ( null)),
+      parentId: _nullishCoalesce(_optionalChain([useThreadMessages2, 'access', _92 => _92.getState, 'call', _93 => _93(), 'access', _94 => _94.at, 'call', _95 => _95(-1), 'optionalAccess', _96 => _96.id]), () => ( null)),
       role: "user",
       content: [{ type: "text", text: message }],
       attachments: []
     };
   }
   return {
-    parentId: _nullishCoalesce(_nullishCoalesce(message.parentId, () => ( _optionalChain([useThreadMessages, 'access', _103 => _103.getState, 'call', _104 => _104(), 'access', _105 => _105.at, 'call', _106 => _106(-1), 'optionalAccess', _107 => _107.id]))), () => ( null)),
+    parentId: _nullishCoalesce(_nullishCoalesce(message.parentId, () => ( _optionalChain([useThreadMessages2, 'access', _97 => _97.getState, 'call', _98 => _98(), 'access', _99 => _99.at, 'call', _100 => _100(-1), 'optionalAccess', _101 => _101.id]))), () => ( null)),
     role: _nullishCoalesce(message.role, () => ( "user")),
     content: message.content,
     attachments: _nullishCoalesce(message.attachments, () => ( []))
   };
 };
 var useAppendMessage = () => {
-  const { useThreadMessages, useThreadActions, useViewport, useComposer } = useThreadContext();
+  const threadMessagesStore = useThreadMessagesStore();
+  const threadActionsStore = useThreadActionsStore();
+  const threadViewportStore = useThreadViewportStore();
+  const threadComposerStore = useThreadComposerStore();
   const append = _react.useCallback.call(void 0, 
     (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
 
 var useSwitchToNewThread = () => {
-  const { useAssistantActions } = useAssistantContext();
-  const { useComposer } = useThreadContext();
+  const assistantActionsStore = useAssistantActionsStore();
+  const threadComposerStore = useThreadComposerStore();
   const switchToNewThread = _react.useCallback.call(void 0, () => {
-    useAssistantActions.getState().switchToThread(null);
-    useComposer.getState().focus();
-  }, [useAssistantActions, useComposer]);
+    assistantActionsStore.getState().switchToNewThread();
+    threadComposerStore.getState().focus();
+  }, [assistantActionsStore, threadComposerStore]);
   return switchToNewThread;
 };
 
 // src/model-config/useAssistantTool.tsx
 
 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();
   _react.useEffect.call(void 0, () => {
     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();
-      _optionalChain([unsub2, 'optionalCall', _108 => _108()]);
+      _optionalChain([unsub2, 'optionalCall', _102 => _102()]);
     };
-  }, [registerModelConfigProvider, setToolUI, tool]);
+  }, [assistantActionsStore, toolUIsStore, tool]);
 };
 
 // src/model-config/makeAssistantTool.tsx
@@ -2412,13 +2486,12 @@ var makeAssistantTool = (tool) => {
 // src/model-config/useAssistantToolUI.tsx
 
 var useAssistantToolUI = (tool) => {
-  const { useToolUIs } = useAssistantContext();
-  const setToolUI = useToolUIs((s) => s.setToolUI);
+  const toolUIsStore = useToolUIsStore();
   _react.useEffect.call(void 0, () => {
     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
 
 var useAssistantInstructions = (instruction) => {
-  const { useModelConfig } = useAssistantContext();
-  const registerModelConfigProvider = useModelConfig(
-    (s) => s.registerModelConfigProvider
-  );
+  const actionsStore = useAssistantActionsStore();
   _react.useEffect.call(void 0, () => {
     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 = _react.useCallback.call(void 0, () => {
-    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
 
 var useActionBarEdit = () => {
-  const { useEditComposer } = useMessageContext();
+  const editComposerStore = useEditComposerStore();
   const disabled = useEditComposer((c) => c.isEditing);
   const callback = _react.useCallback.call(void 0, () => {
-    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
 
 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 = _react.useCallback.call(void 0, () => {
-    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
 
 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 = _react.useCallback.call(void 0, 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
 
 var useActionBarStopSpeaking = () => {
-  const { useMessageUtils } = useMessageContext();
+  const messageUtilsStore = useMessageUtilsStore();
   const isSpeaking = useMessageUtils((u) => u.isSpeaking);
   const callback = _react.useCallback.call(void 0, 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
 
 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 = _react.useCallback.call(void 0, () => {
-    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
 
 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 = _react.useCallback.call(void 0, () => {
-    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
 
 var useComposerCancel = () => {
-  const { useComposer } = useComposerContext();
+  const composerStore = useComposerStore();
   const disabled = useComposer((c) => !c.canCancel);
   const callback = _react.useCallback.call(void 0, () => {
-    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
 
 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 = _react.useCallback.call(void 0, () => {
-    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,30 +2741,30 @@ var useComposerSend = () => {
 // src/primitive-hooks/composer/useComposerAddAttachment.tsx
 
 var useComposerAddAttachment = () => {
-  const { useComposer, useThreadRuntime } = useThreadContext();
   const disabled = useComposer((c) => !c.isEditing);
+  const threadComposerStore = useThreadComposerStore();
+  const threadRuntimeStore = useThreadComposerStore();
   const callback = _react.useCallback.call(void 0, () => {
-    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 !== "*") {
       input.accept = attachmentAccept;
     }
     input.onchange = (e) => {
-      const file = _optionalChain([e, 'access', _109 => _109.target, 'access', _110 => _110.files, 'optionalAccess', _111 => _111[0]]);
+      const file = _optionalChain([e, 'access', _103 => _103.target, 'access', _104 => _104.files, 'optionalAccess', _105 => _105[0]]);
       if (!file) return;
       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
 
 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 = _react.useCallback.call(void 0, () => {
-    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 = _react.useCallback.call(void 0, () => {
-    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;
@@ -2886,7 +2968,7 @@ var createActionButton = (displayName, useActionButton, forwardProps = []) => {
         ref: forwardedRef,
         disabled: primitiveProps.disabled || !callback,
         onClick: _primitive.composeEventHandlers.call(void 0, primitiveProps.onClick, () => {
-          _optionalChain([callback, 'optionalCall', _112 => _112()]);
+          _optionalChain([callback, 'optionalCall', _106 => _106()]);
         })
       }
     );
@@ -2942,11 +3024,12 @@ var ActionBarPrimitiveStopSpeaking = _react.forwardRef.call(void 0, (props, ref)
       ...props,
       ref,
       onClick: _primitive.composeEventHandlers.call(void 0, props.onClick, () => {
-        _optionalChain([callback, 'optionalCall', _113 => _113()]);
+        _optionalChain([callback, 'optionalCall', _107 => _107()]);
       })
     }
   );
 });
+ActionBarPrimitiveStopSpeaking.displayName = "ActionBarPrimitive.StopSpeaking";
 
 // src/primitives/assistantModal/index.ts
 var assistantModal_exports = {};
@@ -2967,12 +3050,12 @@ var _reactpopover = require('@radix-ui/react-popover'); var PopoverPrimitive2 =
 
 var useOnComposerFocus = (callback) => {
   const callbackRef = _reactusecallbackref.useCallbackRef.call(void 0, callback);
-  const { useComposer } = useThreadContext();
+  const threadComposerStore = useThreadComposerStore();
   _react.useEffect.call(void 0, () => {
-    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) => {
 var _reactcomposerefs = require('@radix-ui/react-compose-refs');
 
 var useIsHoveringRef = () => {
-  const { useMessageUtils } = useMessageContext();
+  const messageUtilsStore = useMessageUtilsStore();
   const callbackRef = _react.useCallback.call(void 0, 
     (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 = _react.forwardRef.call(void 0, ({ onMouseEnter, onMouseLeave, ...rest }, forwardRef30) => {
+var MessagePrimitiveRoot = _react.forwardRef.call(void 0, (props, forwardRef30) => {
   const isHoveringRef = useIsHoveringRef();
   const ref = _reactcomposerefs.useComposedRefs.call(void 0, forwardRef30, isHoveringRef);
-  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _reactprimitive.Primitive.div, { ...rest, ref });
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _reactprimitive.Primitive.div, { ...props, ref });
 });
 MessagePrimitiveRoot.displayName = "MessagePrimitive.Root";
 
@@ -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 = _optionalChain([useContentPart, 'optionalAccess', _114 => _114.getState, 'call', _115 => _115()]);
+  const currentState = _optionalChain([useContentPart2, 'optionalAccess', _108 => _108.getState, 'call', _109 => _109()]);
   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] = _react.useState.call(void 0, () => {
-    const useContentPart = _zustand.create.call(void 0, 
-      () => getContentPartState(useMessage.getState(), void 0, partIndex)
+    const useContentPart2 = _zustand.create.call(void 0, 
+      () => getContentPartState(messageStore.getState(), void 0, partIndex)
     );
-    return { useContentPart };
+    return { useContentPart: useContentPart2 };
   });
   _react.useEffect.call(void 0, () => {
     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 = _nullishCoalesce(useToolUIs((s) => s.getToolUI(props.part.toolName)), () => ( UI));
   if (!Render) return null;
   return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 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__ */ _jsxruntime.jsx.call(void 0, 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
@@ -3391,12 +3470,11 @@ var MessageContentPartImpl = ({
 };
 var MessageContentPart = _react.memo.call(void 0, 
   MessageContentPartImpl,
-  (prev, next) => prev.partIndex === next.partIndex && _optionalChain([prev, 'access', _116 => _116.components, 'optionalAccess', _117 => _117.Text]) === _optionalChain([next, 'access', _118 => _118.components, 'optionalAccess', _119 => _119.Text]) && _optionalChain([prev, 'access', _120 => _120.components, 'optionalAccess', _121 => _121.Image]) === _optionalChain([next, 'access', _122 => _122.components, 'optionalAccess', _123 => _123.Image]) && _optionalChain([prev, 'access', _124 => _124.components, 'optionalAccess', _125 => _125.UI]) === _optionalChain([next, 'access', _126 => _126.components, 'optionalAccess', _127 => _127.UI]) && _optionalChain([prev, 'access', _128 => _128.components, 'optionalAccess', _129 => _129.tools]) === _optionalChain([next, 'access', _130 => _130.components, 'optionalAccess', _131 => _131.tools])
+  (prev, next) => prev.partIndex === next.partIndex && _optionalChain([prev, 'access', _110 => _110.components, 'optionalAccess', _111 => _111.Text]) === _optionalChain([next, 'access', _112 => _112.components, 'optionalAccess', _113 => _113.Text]) && _optionalChain([prev, 'access', _114 => _114.components, 'optionalAccess', _115 => _115.Image]) === _optionalChain([next, 'access', _116 => _116.components, 'optionalAccess', _117 => _117.Image]) && _optionalChain([prev, 'access', _118 => _118.components, 'optionalAccess', _119 => _119.UI]) === _optionalChain([next, 'access', _120 => _120.components, 'optionalAccess', _121 => _121.UI]) && _optionalChain([prev, 'access', _122 => _122.components, 'optionalAccess', _123 => _123.tools]) === _optionalChain([next, 'access', _124 => _124.components, 'optionalAccess', _125 => _125.tools])
 );
 var MessagePrimitiveContent = ({
   components
 }) => {
-  const { useMessage } = useMessageContext();
   const contentLength = useMessage((s) => s.message.content.length) || 1;
   return Array.from({ length: contentLength }, (_, index) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, MessageContentPart, { partIndex: index, components }, index));
 };
@@ -3418,42 +3496,64 @@ var AttachmentContext = _react.createContext.call(void 0,
 );
 function useAttachmentContext(options) {
   const context = _react.useContext.call(void 0, AttachmentContext);
-  if (_optionalChain([options, 'optionalAccess', _132 => _132.type]) === "composer" && _optionalChain([context, 'optionalAccess', _133 => _133.type]) !== "composer")
+  if (!_optionalChain([options, 'optionalAccess', _126 => _126.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 (_optionalChain([options, 'optionalAccess', _134 => _134.type]) === "message" && _optionalChain([context, 'optionalAccess', _135 => _135.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 (!_optionalChain([options, 'optionalAccess', _136 => _136.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
 
 
 
-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 = _optionalChain([useAttachment, 'optionalAccess', _137 => _137.getState, 'call', _138 => _138()]);
+  const currentState = _optionalChain([useAttachment2, 'optionalAccess', _127 => _127.getState, 'call', _128 => _128()]);
   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] = _react.useState.call(void 0, 
     () => {
-      const useAttachment = _zustand.create.call(void 0, 
-        () => getAttachment(useMessage.getState(), void 0, partIndex)
+      const useAttachment2 = _zustand.create.call(void 0, 
+        () => getAttachment(messageStore.getState(), void 0, partIndex)
       );
-      return { type: "message", useAttachment };
+      return { type: "message", useAttachment: useAttachment2 };
     }
   );
   _react.useEffect.call(void 0, () => {
@@ -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__ */ _jsxruntime.jsx.call(void 0, AttachmentContext.Provider, { value: context, children });
 };
 
@@ -3485,19 +3585,18 @@ var getComponent = (components, attachment) => {
   const type = attachment.type;
   switch (type) {
     case "image":
-      return _nullishCoalesce(_optionalChain([components, 'optionalAccess', _139 => _139.Image]), () => ( _optionalChain([components, 'optionalAccess', _140 => _140.Attachment])));
+      return _nullishCoalesce(_optionalChain([components, 'optionalAccess', _129 => _129.Image]), () => ( _optionalChain([components, 'optionalAccess', _130 => _130.Attachment])));
     case "document":
-      return _nullishCoalesce(_optionalChain([components, 'optionalAccess', _141 => _141.Document]), () => ( _optionalChain([components, 'optionalAccess', _142 => _142.Attachment])));
+      return _nullishCoalesce(_optionalChain([components, 'optionalAccess', _131 => _131.Document]), () => ( _optionalChain([components, 'optionalAccess', _132 => _132.Attachment])));
     case "file":
-      return _nullishCoalesce(_optionalChain([components, 'optionalAccess', _143 => _143.File]), () => ( _optionalChain([components, 'optionalAccess', _144 => _144.Attachment])));
+      return _nullishCoalesce(_optionalChain([components, 'optionalAccess', _133 => _133.File]), () => ( _optionalChain([components, 'optionalAccess', _134 => _134.Attachment])));
     default:
       const _exhaustiveCheck = type;
       throw new Error(`Unknown attachment type: ${_exhaustiveCheck}`);
   }
 };
 var AttachmentComponent = ({ components }) => {
-  const { useAttachment } = useAttachmentContext({ type: "message" });
-  const Component = useAttachment(
+  const Component = useMessageAttachment(
     (a) => getComponent(components, a.attachment)
   );
   if (!Component) return null;
@@ -3508,10 +3607,9 @@ var MessageAttachmentImpl = ({ components, attachmentIndex }) => {
 };
 var MessageAttachment = _react.memo.call(void 0, 
   MessageAttachmentImpl,
-  (prev, next) => prev.attachmentIndex === next.attachmentIndex && _optionalChain([prev, 'access', _145 => _145.components, 'optionalAccess', _146 => _146.Image]) === _optionalChain([next, 'access', _147 => _147.components, 'optionalAccess', _148 => _148.Image]) && _optionalChain([prev, 'access', _149 => _149.components, 'optionalAccess', _150 => _150.Document]) === _optionalChain([next, 'access', _151 => _151.components, 'optionalAccess', _152 => _152.Document]) && _optionalChain([prev, 'access', _153 => _153.components, 'optionalAccess', _154 => _154.File]) === _optionalChain([next, 'access', _155 => _155.components, 'optionalAccess', _156 => _156.File]) && _optionalChain([prev, 'access', _157 => _157.components, 'optionalAccess', _158 => _158.Attachment]) === _optionalChain([next, 'access', _159 => _159.components, 'optionalAccess', _160 => _160.Attachment])
+  (prev, next) => prev.attachmentIndex === next.attachmentIndex && _optionalChain([prev, 'access', _135 => _135.components, 'optionalAccess', _136 => _136.Image]) === _optionalChain([next, 'access', _137 => _137.components, 'optionalAccess', _138 => _138.Image]) && _optionalChain([prev, 'access', _139 => _139.components, 'optionalAccess', _140 => _140.Document]) === _optionalChain([next, 'access', _141 => _141.components, 'optionalAccess', _142 => _142.Document]) && _optionalChain([prev, 'access', _143 => _143.components, 'optionalAccess', _144 => _144.File]) === _optionalChain([next, 'access', _145 => _145.components, 'optionalAccess', _146 => _146.File]) && _optionalChain([prev, 'access', _147 => _147.components, 'optionalAccess', _148 => _148.Attachment]) === _optionalChain([next, 'access', _149 => _149.components, 'optionalAccess', _150 => _150.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 = _react.forwardRef.call(void 0,
     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 = _react.forwardRef.call(void 0,
     const textareaRef = _react.useRef.call(void 0, null);
     const ref = _reactcomposerefs.useComposedRefs.call(void 0, forwardedRef, textareaRef);
     _reactuseescapekeydown.useEscapeKeydown.call(void 0, (e) => {
-      const composer = useComposer.getState();
+      const composer = composerStore.getState();
       if (composer.canCancel) {
         composer.cancel();
         e.preventDefault();
@@ -3614,10 +3712,10 @@ var ComposerPrimitiveInput = _react.forwardRef.call(void 0,
       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();
-          _optionalChain([textareaRef, 'access', _161 => _161.current, 'optionalAccess', _162 => _162.closest, 'call', _163 => _163("form"), 'optionalAccess', _164 => _164.requestSubmit, 'call', _165 => _165()]);
+          _optionalChain([textareaRef, 'access', _151 => _151.current, 'optionalAccess', _152 => _152.closest, 'call', _153 => _153("form"), 'optionalAccess', _154 => _154.requestSubmit, 'call', _155 => _155()]);
         }
       }
     };
@@ -3633,7 +3731,7 @@ var ComposerPrimitiveInput = _react.forwardRef.call(void 0,
     }, [autoFocusEnabled]);
     _react.useEffect.call(void 0, () => focus(), [focus]);
     useOnComposerFocus(() => {
-      if (type === "new") {
+      if (composerStore.getState().type === "thread") {
         focus();
       }
     });
@@ -3646,7 +3744,7 @@ var ComposerPrimitiveInput = _react.forwardRef.call(void 0,
         ref,
         disabled: isDisabled,
         onChange: _primitive.composeEventHandlers.call(void 0, onChange, (e) => {
-          const composerState = useComposer.getState();
+          const composerState = composerStore.getState();
           if (!composerState.isEditing) return;
           return composerState.setText(e.target.value);
         }),
@@ -3682,21 +3780,21 @@ var ComposerPrimitiveAddAttachment = createActionButton(
 
 
 
-var getAttachment2 = ({ attachments }, useAttachment, partIndex) => {
-  let attachment = attachments[partIndex];
+var getAttachment2 = ({ attachments }, useAttachment2, partIndex) => {
+  const attachment = attachments[partIndex];
   if (!attachment) return null;
-  const currentState = _optionalChain([useAttachment, 'optionalAccess', _166 => _166.getState, 'call', _167 => _167()]);
+  const currentState = _optionalChain([useAttachment2, 'optionalAccess', _156 => _156.getState, 'call', _157 => _157()]);
   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] = _react.useState.call(void 0, 
     () => {
-      const useAttachment = _zustand.create.call(void 0, 
-        () => getAttachment2(useComposer.getState(), void 0, partIndex)
+      const useAttachment2 = _zustand.create.call(void 0, 
+        () => getAttachment2(threadComposerStore.getState(), void 0, partIndex)
       );
-      return { type: "composer", useAttachment };
+      return { type: "composer", useAttachment: useAttachment2 };
     }
   );
   _react.useEffect.call(void 0, () => {
@@ -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__ */ _jsxruntime.jsx.call(void 0, AttachmentContext.Provider, { value: context, children });
 };
 
@@ -3725,19 +3823,18 @@ var getComponent2 = (components, attachment) => {
   const type = attachment.type;
   switch (type) {
     case "image":
-      return _nullishCoalesce(_optionalChain([components, 'optionalAccess', _168 => _168.Image]), () => ( _optionalChain([components, 'optionalAccess', _169 => _169.Attachment])));
+      return _nullishCoalesce(_optionalChain([components, 'optionalAccess', _158 => _158.Image]), () => ( _optionalChain([components, 'optionalAccess', _159 => _159.Attachment])));
     case "document":
-      return _nullishCoalesce(_optionalChain([components, 'optionalAccess', _170 => _170.Document]), () => ( _optionalChain([components, 'optionalAccess', _171 => _171.Attachment])));
+      return _nullishCoalesce(_optionalChain([components, 'optionalAccess', _160 => _160.Document]), () => ( _optionalChain([components, 'optionalAccess', _161 => _161.Attachment])));
     case "file":
-      return _nullishCoalesce(_optionalChain([components, 'optionalAccess', _172 => _172.File]), () => ( _optionalChain([components, 'optionalAccess', _173 => _173.Attachment])));
+      return _nullishCoalesce(_optionalChain([components, 'optionalAccess', _162 => _162.File]), () => ( _optionalChain([components, 'optionalAccess', _163 => _163.Attachment])));
     default:
       const _exhaustiveCheck = type;
       throw new Error(`Unknown attachment type: ${_exhaustiveCheck}`);
   }
 };
 var AttachmentComponent2 = ({ components }) => {
-  const { useAttachment } = useAttachmentContext({ type: "composer" });
-  const Component = useAttachment(
+  const Component = useComposerAttachment(
     (a) => getComponent2(components, a.attachment)
   );
   if (!Component) return null;
@@ -3748,11 +3845,10 @@ var ComposerAttachmentImpl = ({ components, attachmentIndex }) => {
 };
 var ComposerAttachment = _react.memo.call(void 0, 
   ComposerAttachmentImpl,
-  (prev, next) => prev.attachmentIndex === next.attachmentIndex && _optionalChain([prev, 'access', _174 => _174.components, 'optionalAccess', _175 => _175.Image]) === _optionalChain([next, 'access', _176 => _176.components, 'optionalAccess', _177 => _177.Image]) && _optionalChain([prev, 'access', _178 => _178.components, 'optionalAccess', _179 => _179.Document]) === _optionalChain([next, 'access', _180 => _180.components, 'optionalAccess', _181 => _181.Document]) && _optionalChain([prev, 'access', _182 => _182.components, 'optionalAccess', _183 => _183.File]) === _optionalChain([next, 'access', _184 => _184.components, 'optionalAccess', _185 => _185.File]) && _optionalChain([prev, 'access', _186 => _186.components, 'optionalAccess', _187 => _187.Attachment]) === _optionalChain([next, 'access', _188 => _188.components, 'optionalAccess', _189 => _189.Attachment])
+  (prev, next) => prev.attachmentIndex === next.attachmentIndex && _optionalChain([prev, 'access', _164 => _164.components, 'optionalAccess', _165 => _165.Image]) === _optionalChain([next, 'access', _166 => _166.components, 'optionalAccess', _167 => _167.Image]) && _optionalChain([prev, 'access', _168 => _168.components, 'optionalAccess', _169 => _169.Document]) === _optionalChain([next, 'access', _170 => _170.components, 'optionalAccess', _171 => _171.Document]) && _optionalChain([prev, 'access', _172 => _172.components, 'optionalAccess', _173 => _173.File]) === _optionalChain([next, 'access', _174 => _174.components, 'optionalAccess', _175 => _175.File]) && _optionalChain([prev, 'access', _176 => _176.components, 'optionalAccess', _177 => _177.Attachment]) === _optionalChain([next, 'access', _178 => _178.components, 'optionalAccess', _179 => _179.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__ */ _jsxruntime.jsx.call(void 0, 
     ComposerAttachment,
     {
@@ -3877,12 +3973,12 @@ var useOnResizeContent = (callback) => {
 
 var useOnScrollToBottom = (callback) => {
   const callbackRef = _reactusecallbackref.useCallbackRef.call(void 0, callback);
-  const { useViewport } = useThreadContext();
+  const threadViewportStore = useThreadViewportStore();
   _react.useEffect.call(void 0, () => {
-    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 = _react.useRef.call(void 0, null);
-  const { useViewport } = useThreadContext();
+  const threadViewportStore = useThreadViewportStore();
   const lastScrollTop = _react.useRef.call(void 0, 0);
   const isScrollingToBottomRef = _react.useRef.call(void 0, 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
 
-var ThreadPrimitiveViewport = _react.forwardRef.call(void 0, ({ autoScroll, onScroll, children, ...rest }, forwardedRef) => {
+var ThreadPrimitiveViewport = _react.forwardRef.call(void 0, ({ autoScroll, children, ...rest }, forwardedRef) => {
   const autoScrollRef = useThreadViewportAutoScroll({
     autoScroll
   });
@@ -3958,6 +4056,7 @@ var makeEditComposerStore = ({
   onEdit,
   onSend
 }) => _zustand.create.call(void 0, )((set, get) => ({
+  type: "edit",
   get value() {
     return get().text;
   },
@@ -4005,7 +4104,7 @@ var makeMessageUtilsStore = () => _zustand.create.call(void 0, (set) => {
     },
     isSpeaking: false,
     stopSpeaking: () => {
-      _optionalChain([utterance, 'optionalAccess', _190 => _190.cancel, 'call', _191 => _191()]);
+      _optionalChain([utterance, 'optionalAccess', _180 => _180.cancel, 'call', _181 => _181()]);
     },
     addUtterance: (utt) => {
       utterance = utt;
@@ -4020,15 +4119,15 @@ var makeMessageUtilsStore = () => _zustand.create.call(void 0, (set) => {
 // src/context/providers/MessageProvider.tsx
 
 var getIsLast = (messages, message) => {
-  return _optionalChain([messages, 'access', _192 => _192[messages.length - 1], 'optionalAccess', _193 => _193.id]) === message.id;
+  return _optionalChain([messages, 'access', _182 => _182[messages.length - 1], 'optionalAccess', _183 => _183.id]) === message.id;
 };
-var getMessageState = (messages, getBranches, useMessage, messageIndex) => {
-  const parentId = _nullishCoalesce(_optionalChain([messages, 'access', _194 => _194[messageIndex - 1], 'optionalAccess', _195 => _195.id]), () => ( null));
+var getMessageState = (messages, getBranches, useMessage2, messageIndex) => {
+  const parentId = _nullishCoalesce(_optionalChain([messages, 'access', _184 => _184[messageIndex - 1], 'optionalAccess', _185 => _185.id]), () => ( null));
   const message = messages[messageIndex];
   if (!message) return null;
   const isLast = getIsLast(messages, message);
   const branches = getBranches(message.id);
-  const currentState = _optionalChain([useMessage, 'optionalAccess', _196 => _196.getState, 'call', _197 => _197()]);
+  const currentState = _optionalChain([useMessage2, 'optionalAccess', _186 => _186.getState, 'call', _187 => _187()]);
   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] = _react.useState.call(void 0, () => {
-    const useMessage = _zustand.create.call(void 0, 
+    const useMessage2 = _zustand.create.call(void 0, 
       () => 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 };
   });
   _react.useEffect.call(void 0, () => {
     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 = _react.memo.call(void 0,
 var ThreadPrimitiveMessagesImpl = ({
   components
 }) => {
-  const { useThreadMessages } = useThreadContext();
   const messagesLength = useThreadMessages((t) => t.length);
   if (messagesLength === 0) return null;
   return Array.from({ length: messagesLength }, (_, index) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ThreadMessage, { messageIndex: index, components }, index));
@@ -4188,10 +4286,10 @@ var ThreadConfigProvider = ({
   children,
   config
 }) => {
-  const assistant = useAssistantContext({ optional: true });
+  const hasAssistant = !!useAssistantRuntimeStore({ optional: true });
   const configProvider = config && Object.keys(_nullishCoalesce(config, () => ( {}))).length > 0 ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ThreadConfigContext.Provider, { value: config, children }) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, { children });
-  if (!_optionalChain([config, 'optionalAccess', _198 => _198.runtime])) return configProvider;
-  if (assistant) {
+  if (!_optionalChain([config, 'optionalAccess', _188 => _188.runtime])) return configProvider;
+  if (hasAssistant) {
     throw new Error(
       "You provided a runtime to <Thread> while simulataneously using <AssistantRuntimeProvider>. This is not allowed."
     );
@@ -4212,19 +4310,16 @@ var _lucidereact = require('lucide-react');
 
 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 @@ var assistant_action_bar_default = Object.assign(
 
 var useAllowBranchPicker = (ensureCapability = false) => {
   const { branchPicker: { allowBranchPicker = true } = {} } = useThreadConfig();
-  const { useThread } = useThreadContext();
   const branchPickerSupported = useThread((t) => t.capabilities.edit);
   return allowBranchPicker && (!ensureCapability || branchPickerSupported);
 };
@@ -4463,7 +4557,7 @@ var AssistantMessageContent = _react.forwardRef.call(void 0, ({ components: comp
     {
       components: {
         ...componentsProp,
-        Text: _nullishCoalesce(_nullishCoalesce(_optionalChain([componentsProp, 'optionalAccess', _199 => _199.Text]), () => ( components.Text)), () => ( content_part_default.Text)),
+        Text: _nullishCoalesce(_nullishCoalesce(_optionalChain([componentsProp, 'optionalAccess', _189 => _189.Text]), () => ( components.Text)), () => ( content_part_default.Text)),
         tools: toolsComponents
       }
     }
@@ -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__ */ _jsxruntime.jsxs.call(void 0, ComposerAttachmentRoot, { children: [
     ".",
     attachment.name.split(".").pop(),
@@ -4533,10 +4626,10 @@ var ComposerAttachmentRemove = _react.forwardRef.call(void 0, (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__ */ _jsxruntime.jsx.call(void 0, 
     TooltipIconButton,
@@ -4565,7 +4658,6 @@ var composer_attachment_default = Object.assign(
 
 var useAllowAttachments = (ensureCapability = false) => {
   const { composer: { allowAttachments = true } = {} } = useThreadConfig();
-  const { useThread } = useThreadContext();
   const attachmentsSupported = useThread((t) => t.capabilities.attachments);
   return allowAttachments && (!ensureCapability || attachmentsSupported);
 };
@@ -4608,7 +4700,7 @@ var ComposerAttachments = ({ components }) => {
     {
       components: {
         ...components,
-        Attachment: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _200 => _200.Attachment]), () => ( composer_attachment_default))
+        Attachment: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _190 => _190.Attachment]), () => ( composer_attachment_default))
       }
     }
   ) });
@@ -4637,7 +4729,6 @@ var ComposerAddAttachment = _react.forwardRef.call(void 0, (props, ref) => {
 });
 ComposerAddAttachment.displayName = "ComposerAddAttachment";
 var useAllowCancel = () => {
-  const { useThread } = useThreadContext();
   const cancelSupported = useThread((t) => t.capabilities.cancel);
   return cancelSupported;
 };
@@ -4741,7 +4832,7 @@ var ThreadWelcomeSuggestion = ({
 };
 var ThreadWelcomeSuggestions = () => {
   const { welcome: { suggestions } = {} } = useThreadConfig();
-  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ThreadWelcomeSuggestionContainer, { children: _optionalChain([suggestions, 'optionalAccess', _201 => _201.map, 'call', _202 => _202((suggestion, idx) => {
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ThreadWelcomeSuggestionContainer, { children: _optionalChain([suggestions, 'optionalAccess', _191 => _191.map, 'call', _192 => _192((suggestion, idx) => {
     const key = `${suggestion.prompt}-${idx}`;
     return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ThreadWelcomeSuggestion, { suggestion }, key);
   })]) });
@@ -4766,7 +4857,6 @@ var thread_welcome_default = Object.assign(ThreadWelcome, exports7);
 
 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__ */ _jsxruntime.jsxs.call(void 0, UserMessageAttachmentRoot, { children: [
     ".",
@@ -4842,7 +4931,7 @@ var UserMessageContent = _react.forwardRef.call(void 0,
       {
         components: {
           ...components,
-          Text: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _203 => _203.Text]), () => ( content_part_default.Text))
+          Text: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _193 => _193.Text]), () => ( content_part_default.Text))
         }
       }
     ) });
@@ -4860,7 +4949,7 @@ var UserMessageAttachments = ({
     {
       components: {
         ...components,
-        Attachment: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _204 => _204.Attachment]), () => ( user_message_attachment_default))
+        Attachment: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _194 => _194.Attachment]), () => ( user_message_attachment_default))
       }
     }
   ) }) });
@@ -4961,10 +5050,10 @@ var ThreadMessages = ({ components, ...rest }) => {
     thread_exports.Messages,
     {
       components: {
-        UserMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _205 => _205.UserMessage]), () => ( user_message_default)),
-        EditComposer: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _206 => _206.EditComposer]), () => ( edit_composer_default)),
-        AssistantMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _207 => _207.AssistantMessage]), () => ( assistant_message_default)),
-        SystemMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _208 => _208.SystemMessage]), () => ( SystemMessage))
+        UserMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _195 => _195.UserMessage]), () => ( user_message_default)),
+        EditComposer: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _196 => _196.EditComposer]), () => ( edit_composer_default)),
+        AssistantMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _197 => _197.AssistantMessage]), () => ( assistant_message_default)),
+        SystemMessage: _nullishCoalesce(_optionalChain([components, 'optionalAccess', _198 => _198.SystemMessage]), () => ( SystemMessage))
       },
       ...rest
     }
@@ -5154,5 +5243,33 @@ var assistant_modal_default = Object.assign(AssistantModal, exports13);
 
 
 
-exports.ActionBarPrimitive = actionBar_exports; exports.AssistantActionBar = assistant_action_bar_default; exports.AssistantMessage = assistant_message_default; exports.AssistantModal = assistant_modal_default; exports.AssistantModalPrimitive = assistantModal_exports; exports.AssistantRuntimeProvider = AssistantRuntimeProvider; exports.BranchPicker = branch_picker_default; exports.BranchPickerPrimitive = branchPicker_exports; exports.Composer = composer_default; exports.ComposerAttachment = composer_attachment_default; exports.ComposerPrimitive = composer_exports; exports.CompositeAttachmentAdapter = CompositeAttachmentAdapter; exports.ContentPart = content_part_default; exports.ContentPartPrimitive = contentPart_exports; exports.EdgeChatAdapter = EdgeChatAdapter; exports.EditComposer = edit_composer_default; exports.ExternalStoreRuntime = ExternalStoreRuntime; exports.INTERNAL = internal_exports; exports.MessagePrimitive = message_exports; exports.SimpleImageAttachmentAdapter = SimpleImageAttachmentAdapter; exports.SimpleTextAttachmentAdapter = SimpleTextAttachmentAdapter; exports.TextContentPartProvider = TextContentPartProvider; exports.Thread = thread_default; exports.ThreadConfigProvider = ThreadConfigProvider; exports.ThreadPrimitive = thread_exports; exports.ThreadWelcome = thread_welcome_default; exports.UserActionBar = user_action_bar_default; exports.UserMessage = user_message_default; exports.UserMessageAttachment = user_message_attachment_default; exports.WebSpeechSynthesisAdapter = WebSpeechSynthesisAdapter; exports.fromCoreMessage = fromCoreMessage; exports.fromCoreMessages = fromCoreMessages; exports.fromLanguageModelMessages = fromLanguageModelMessages; exports.fromLanguageModelTools = fromLanguageModelTools; exports.getExternalStoreMessage = getExternalStoreMessage; exports.makeAssistantTool = makeAssistantTool; exports.makeAssistantToolUI = makeAssistantToolUI; exports.streamUtils = streamUtils; exports.subscribeToMainThread = subscribeToMainThread; exports.toCoreMessage = _chunk4LR4BB23js.toCoreMessage; exports.toCoreMessages = _chunk4LR4BB23js.toCoreMessages; exports.toLanguageModelMessages = _chunk4LR4BB23js.toLanguageModelMessages; exports.toLanguageModelTools = _chunk4LR4BB23js.toLanguageModelTools; exports.useActionBarCopy = useActionBarCopy; exports.useActionBarEdit = useActionBarEdit; exports.useActionBarReload = useActionBarReload; exports.useActionBarSpeak = useActionBarSpeak; exports.useActionBarStopSpeaking = useActionBarStopSpeaking; exports.useAppendMessage = useAppendMessage; exports.useAssistantContext = useAssistantContext; exports.useAssistantInstructions = useAssistantInstructions; exports.useAssistantTool = useAssistantTool; exports.useAssistantToolUI = useAssistantToolUI; exports.useBranchPickerCount = useBranchPickerCount; exports.useBranchPickerNext = useBranchPickerNext; exports.useBranchPickerNumber = useBranchPickerNumber; exports.useBranchPickerPrevious = useBranchPickerPrevious; exports.useComposerAddAttachment = useComposerAddAttachment; exports.useComposerCancel = useComposerCancel; exports.useComposerContext = useComposerContext; exports.useComposerIf = useComposerIf; exports.useComposerSend = useComposerSend; exports.useContentPartContext = useContentPartContext; exports.useContentPartDisplay = useContentPartDisplay; exports.useContentPartImage = useContentPartImage; exports.useContentPartText = useContentPartText; exports.useDangerousInBrowserRuntime = useDangerousInBrowserRuntime; exports.useEdgeRuntime = useEdgeRuntime; exports.useExternalMessageConverter = useExternalMessageConverter; exports.useExternalStoreRuntime = useExternalStoreRuntime; exports.useLocalRuntime = useLocalRuntime; exports.useMessageContext = useMessageContext; exports.useMessageIf = useMessageIf; exports.useSwitchToNewThread = useSwitchToNewThread; exports.useThreadConfig = useThreadConfig; exports.useThreadContext = useThreadContext; exports.useThreadEmpty = useThreadEmpty; exports.useThreadIf = useThreadIf; exports.useThreadScrollToBottom = useThreadScrollToBottom; exports.useThreadSuggestion = useThreadSuggestion;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.ActionBarPrimitive = actionBar_exports; exports.AssistantActionBar = assistant_action_bar_default; exports.AssistantMessage = assistant_message_default; exports.AssistantModal = assistant_modal_default; exports.AssistantModalPrimitive = assistantModal_exports; exports.AssistantRuntimeProvider = AssistantRuntimeProvider; exports.BranchPicker = branch_picker_default; exports.BranchPickerPrimitive = branchPicker_exports; exports.Composer = composer_default; exports.ComposerAttachment = composer_attachment_default; exports.ComposerPrimitive = composer_exports; exports.CompositeAttachmentAdapter = CompositeAttachmentAdapter; exports.ContentPart = content_part_default; exports.ContentPartPrimitive = contentPart_exports; exports.EdgeChatAdapter = EdgeChatAdapter; exports.EditComposer = edit_composer_default; exports.ExternalStoreRuntime = ExternalStoreRuntime; exports.INTERNAL = internal_exports; exports.MessagePrimitive = message_exports; exports.SimpleImageAttachmentAdapter = SimpleImageAttachmentAdapter; exports.SimpleTextAttachmentAdapter = SimpleTextAttachmentAdapter; exports.TextContentPartProvider = TextContentPartProvider; exports.Thread = thread_default; exports.ThreadConfigProvider = ThreadConfigProvider; exports.ThreadPrimitive = thread_exports; exports.ThreadWelcome = thread_welcome_default; exports.UserActionBar = user_action_bar_default; exports.UserMessage = user_message_default; exports.UserMessageAttachment = user_message_attachment_default; exports.WebSpeechSynthesisAdapter = WebSpeechSynthesisAdapter; exports.fromCoreMessage = fromCoreMessage; exports.fromCoreMessages = fromCoreMessages; exports.fromLanguageModelMessages = fromLanguageModelMessages; exports.fromLanguageModelTools = fromLanguageModelTools; exports.getExternalStoreMessage = getExternalStoreMessage; exports.makeAssistantTool = makeAssistantTool; exports.makeAssistantToolUI = makeAssistantToolUI; exports.streamUtils = streamUtils; exports.subscribeToMainThread = subscribeToMainThread; exports.toCoreMessage = _chunkCWAZOKEWjs.toCoreMessage; exports.toCoreMessages = _chunkCWAZOKEWjs.toCoreMessages; exports.toLanguageModelMessages = _chunkCWAZOKEWjs.toLanguageModelMessages; exports.toLanguageModelTools = _chunkCWAZOKEWjs.toLanguageModelTools; exports.useActionBarCopy = useActionBarCopy; exports.useActionBarEdit = useActionBarEdit; exports.useActionBarReload = useActionBarReload; exports.useActionBarSpeak = useActionBarSpeak; exports.useActionBarStopSpeaking = useActionBarStopSpeaking; exports.useAppendMessage = useAppendMessage; exports.useAssistantActions = useAssistantActions; exports.useAssistantActionsStore = useAssistantActionsStore; exports.useAssistantContext = useAssistantContext; exports.useAssistantInstructions = useAssistantInstructions; exports.useAssistantRuntime = useAssistantRuntime; exports.useAssistantRuntimeStore = useAssistantRuntimeStore; exports.useAssistantTool = useAssistantTool; exports.useAssistantToolUI = useAssistantToolUI; exports.useBranchPickerCount = useBranchPickerCount; exports.useBranchPickerNext = useBranchPickerNext; exports.useBranchPickerNumber = useBranchPickerNumber; exports.useBranchPickerPrevious = useBranchPickerPrevious; exports.useComposer = useComposer; exports.useComposerAddAttachment = useComposerAddAttachment; exports.useComposerCancel = useComposerCancel; exports.useComposerContext = useComposerContext; exports.useComposerIf = useComposerIf; exports.useComposerSend = useComposerSend; exports.useComposerStore = useComposerStore; exports.useContentPart = useContentPart; exports.useContentPartContext = useContentPartContext; exports.useContentPartDisplay = useContentPartDisplay; exports.useContentPartImage = useContentPartImage; exports.useContentPartStore = useContentPartStore; exports.useContentPartText = useContentPartText; exports.useDangerousInBrowserRuntime = useDangerousInBrowserRuntime; exports.useEdgeRuntime = useEdgeRuntime; exports.useEditComposer = useEditComposer; exports.useEditComposerStore = useEditComposerStore; exports.useExternalMessageConverter = useExternalMessageConverter; exports.useExternalStoreRuntime = useExternalStoreRuntime; exports.useLocalRuntime = useLocalRuntime; exports.useMessage = useMessage; exports.useMessageContext = useMessageContext; exports.useMessageIf = useMessageIf; exports.useMessageStore = useMessageStore; exports.useMessageUtils = useMessageUtils; exports.useMessageUtilsStore = useMessageUtilsStore; exports.useSwitchToNewThread = useSwitchToNewThread; exports.useThread = useThread; exports.useThreadActions = useThreadActions; exports.useThreadActionsStore = useThreadActionsStore; exports.useThreadComposer = useThreadComposer; exports.useThreadComposerStore = useThreadComposerStore; exports.useThreadConfig = useThreadConfig; exports.useThreadContext = useThreadContext; exports.useThreadEmpty = useThreadEmpty; exports.useThreadIf = useThreadIf; exports.useThreadMessages = useThreadMessages; exports.useThreadMessagesStore = useThreadMessagesStore; exports.useThreadRuntime = useThreadRuntime; exports.useThreadRuntimeStore = useThreadRuntimeStore; exports.useThreadScrollToBottom = useThreadScrollToBottom; exports.useThreadStore = useThreadStore; exports.useThreadSuggestion = useThreadSuggestion; exports.useThreadViewport = useThreadViewport; exports.useThreadViewportStore = useThreadViewportStore; exports.useToolUIs = useToolUIs; exports.useToolUIsStore = useToolUIsStore;
 //# sourceMappingURL=index.js.map