@assistant-ui/react 0.4.5 → 0.4.7

package/dist/index.js

@@ -55,9 +55,12 @@ __export(src_exports, {
   UserMessage: () => user_message_default,
   fromCoreMessages: () => fromCoreMessages,
   fromLanguageModelMessages: () => fromLanguageModelMessages,
+  fromLanguageModelTools: () => fromLanguageModelTools,
   makeAssistantTool: () => makeAssistantTool,
   makeAssistantToolUI: () => makeAssistantToolUI,
+  toCoreMessages: () => toCoreMessages,
   toLanguageModelMessages: () => toLanguageModelMessages,
+  toLanguageModelTools: () => toLanguageModelTools,
   useActionBarCopy: () => useActionBarCopy,
   useActionBarEdit: () => useActionBarEdit,
   useActionBarReload: () => useActionBarReload,
@@ -93,10 +96,10 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/context/providers/AssistantRuntimeProvider.tsx
-var import_react5 = require("react");
+var import_react6 = require("react");
 
 // src/context/providers/AssistantProvider.tsx
-var import_react4 = require("react");
+var import_react5 = require("react");
 
 // src/context/react/AssistantContext.ts
 var import_react = require("react");
@@ -116,6 +119,21 @@ function useAssistantContext(options) {
 var import_zustand = require("zustand");
 
 // src/types/ModelConfigTypes.ts
+var import_zod = require("zod");
+var LanguageModelV1CallSettingsSchema = import_zod.z.object({
+  maxTokens: import_zod.z.number().int().positive().optional(),
+  temperature: import_zod.z.number().optional(),
+  topP: import_zod.z.number().optional(),
+  presencePenalty: import_zod.z.number().optional(),
+  frequencyPenalty: import_zod.z.number().optional(),
+  seed: import_zod.z.number().int().optional(),
+  headers: import_zod.z.record(import_zod.z.string().optional()).optional()
+});
+var LanguageModelConfigSchema = import_zod.z.object({
+  apiKey: import_zod.z.string().optional(),
+  baseUrl: import_zod.z.string().optional(),
+  modelName: import_zod.z.string().optional()
+});
 var mergeModelConfigs = (configSet) => {
   const configs = Array.from(configSet).map((c) => c.getModelConfig()).sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
   return configs.reduce((acc, config) => {
@@ -139,6 +157,18 @@ ${config.system}`;
         acc.tools[name] = tool;
       }
     }
+    if (config.config) {
+      acc.config = {
+        ...acc.config,
+        ...config.config
+      };
+    }
+    if (config.callSettings) {
+      acc.callSettings = {
+        ...acc.callSettings,
+        ...config.callSettings
+      };
+    }
     return acc;
   }, {});
 };
@@ -203,7 +233,7 @@ var makeAssistantToolUIsStore = () => (0, import_zustand2.create)((set) => {
 });
 
 // src/context/providers/ThreadProvider.tsx
-var import_react3 = require("react");
+var import_react4 = require("react");
 
 // src/context/react/ThreadContext.ts
 var import_react2 = require("react");
@@ -269,7 +299,7 @@ var makeComposerStore = (useThreadMessages, useThreadActions) => {
 var import_zustand4 = require("zustand");
 var makeThreadStore = (runtimeRef) => {
   return (0, import_zustand4.create)(() => ({
-    isRunning: runtimeRef.current.isRunning
+    isRunning: runtimeRef.getState().isRunning
   }));
 };
 
@@ -295,19 +325,18 @@ var makeThreadViewportStore = () => {
 
 // src/context/stores/ThreadActions.ts
 var import_zustand6 = require("zustand");
-var makeThreadActionStore = (runtimeRef) => {
+var makeThreadActionStore = (runtimeStore) => {
   return (0, import_zustand6.create)(
     () => Object.freeze({
       get capabilities() {
-        return runtimeRef.current.capabilities;
+        return runtimeStore.getState().capabilities;
       },
-      getBranches: (messageId) => runtimeRef.current.getBranches(messageId),
-      switchToBranch: (branchId) => runtimeRef.current.switchToBranch(branchId),
-      startRun: (parentId) => runtimeRef.current.startRun(parentId),
-      append: (message) => runtimeRef.current.append(message),
-      cancelRun: () => runtimeRef.current.cancelRun(),
-      addToolResult: (options) => runtimeRef.current.addToolResult(options),
-      getRuntime: () => runtimeRef.current
+      getBranches: (messageId) => runtimeStore.getState().getBranches(messageId),
+      switchToBranch: (branchId) => runtimeStore.getState().switchToBranch(branchId),
+      startRun: (parentId) => runtimeStore.getState().startRun(parentId),
+      append: (message) => runtimeStore.getState().append(message),
+      cancelRun: () => runtimeStore.getState().cancelRun(),
+      addToolResult: (options) => runtimeStore.getState().addToolResult(options)
     })
   );
 };
@@ -315,60 +344,96 @@ var makeThreadActionStore = (runtimeRef) => {
 // src/context/stores/ThreadMessages.ts
 var import_zustand7 = require("zustand");
 var makeThreadMessagesStore = (runtimeRef) => {
-  return (0, import_zustand7.create)(() => runtimeRef.current.messages);
+  return (0, import_zustand7.create)(() => runtimeRef.getState().messages);
+};
+
+// src/context/stores/ThreadRuntime.tsx
+var import_zustand8 = require("zustand");
+var makeThreadRuntimeStore = (runtime) => {
+  return (0, import_zustand8.create)(() => runtime);
+};
+
+// src/utils/hooks/useManagedRef.ts
+var import_react3 = require("react");
+var useManagedRef = (callback) => {
+  const cleanupRef = (0, import_react3.useRef)();
+  const ref = (0, import_react3.useCallback)(
+    (el) => {
+      if (cleanupRef.current) {
+        cleanupRef.current();
+      }
+      if (el) {
+        cleanupRef.current = callback(el);
+      }
+    },
+    [callback]
+  );
+  return ref;
 };
 
 // src/context/providers/ThreadProvider.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
 var ThreadProvider = ({
   children,
-  runtime
+  provider
 }) => {
-  const runtimeRef = (0, import_react3.useRef)(runtime.thread);
-  const [context] = (0, import_react3.useState)(() => {
-    const useThread = makeThreadStore(runtimeRef);
-    const useThreadMessages = makeThreadMessagesStore(runtimeRef);
-    const useThreadActions = makeThreadActionStore(runtimeRef);
+  const [context] = (0, import_react4.useState)(() => {
+    const useThreadRuntime = makeThreadRuntimeStore(provider.thread);
+    const useThread = makeThreadStore(useThreadRuntime);
+    const useThreadMessages = makeThreadMessagesStore(useThreadRuntime);
+    const useThreadActions = makeThreadActionStore(useThreadRuntime);
     const useViewport = makeThreadViewportStore();
     const useComposer = makeComposerStore(useThreadMessages, useThreadActions);
     return {
       useThread,
+      useThreadRuntime,
       useThreadMessages,
       useThreadActions,
       useComposer,
       useViewport
     };
   });
-  const thread = (0, import_react3.useSyncExternalStore)(
-    (0, import_react3.useCallback)((c) => runtime.subscribe(c), [runtime]),
-    () => runtime.thread,
-    () => runtime.thread
+  const threadRef = useManagedRef(
+    (0, import_react4.useCallback)(
+      (thread) => {
+        const onThreadUpdate = () => {
+          context.useThread.setState(
+            Object.freeze({
+              isRunning: context.useThreadRuntime.getState().isRunning
+            }),
+            true
+          );
+          context.useThreadMessages.setState(thread.messages, true);
+        };
+        onThreadUpdate();
+        return thread.subscribe(onThreadUpdate);
+      },
+      [context]
+    )
   );
-  (0, import_react3.useInsertionEffect)(() => {
-    runtimeRef.current = thread;
-  });
-  (0, import_react3.useEffect)(() => {
-    const onThreadUpdate = () => {
-      context.useThread.setState(
-        Object.freeze({
-          isRunning: runtimeRef.current.isRunning
-        }),
-        true
-      );
-      context.useThreadMessages.setState(Object.freeze(runtimeRef.current.messages), true);
+  (0, import_react4.useInsertionEffect)(() => {
+    const unsubscribe = provider.subscribe(() => {
+      context.useThreadRuntime.setState(provider.thread, true);
+      threadRef(provider.thread);
+    });
+    threadRef(provider.thread);
+    return () => {
+      unsubscribe();
+      threadRef(null);
     };
-    onThreadUpdate();
-    return thread.subscribe(onThreadUpdate);
-  }, [context, thread]);
+  }, [provider, context]);
+  const Synchronizer = context.useThreadRuntime(
+    (t) => t.unstable_synchronizer
+  );
   return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(ThreadContext.Provider, { value: context, children: [
-    thread.unstable_synchronizer && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(thread.unstable_synchronizer, {}),
+    Synchronizer && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Synchronizer, {}),
     children
   ] });
 };
 
 // src/context/stores/AssistantActions.tsx
-var import_zustand8 = require("zustand");
-var makeAssistantActionsStore = (runtimeRef) => (0, import_zustand8.create)(
+var import_zustand9 = require("zustand");
+var makeAssistantActionsStore = (runtimeRef) => (0, import_zustand9.create)(
   () => Object.freeze({
     switchToThread: () => runtimeRef.current.switchToThread(null),
     getRuntime: () => runtimeRef.current
@@ -378,21 +443,21 @@ var makeAssistantActionsStore = (runtimeRef) => (0, import_zustand8.create)(
 // src/context/providers/AssistantProvider.tsx
 var import_jsx_runtime2 = require("react/jsx-runtime");
 var AssistantProvider = ({ children, runtime }) => {
-  const runtimeRef = (0, import_react4.useRef)(runtime);
-  (0, import_react4.useInsertionEffect)(() => {
+  const runtimeRef = (0, import_react5.useRef)(runtime);
+  (0, import_react5.useInsertionEffect)(() => {
     runtimeRef.current = runtime;
   });
-  const [context] = (0, import_react4.useState)(() => {
+  const [context] = (0, import_react5.useState)(() => {
     const useModelConfig = makeAssistantModelConfigStore();
     const useToolUIs = makeAssistantToolUIsStore();
     const useAssistantActions = makeAssistantActionsStore(runtimeRef);
     return { useModelConfig, useToolUIs, useAssistantActions };
   });
   const getModelConfig = context.useModelConfig();
-  (0, import_react4.useEffect)(() => {
+  (0, import_react5.useEffect)(() => {
     return runtime.registerModelConfigProvider(getModelConfig);
   }, [runtime, getModelConfig]);
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(AssistantContext.Provider, { value: context, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(ThreadProvider, { runtime, children }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(AssistantContext.Provider, { value: context, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(ThreadProvider, { provider: runtime, children }) });
 };
 
 // src/context/providers/AssistantRuntimeProvider.tsx
@@ -400,16 +465,16 @@ var import_jsx_runtime3 = require("react/jsx-runtime");
 var AssistantRuntimeProviderImpl = ({ children, runtime }) => {
   return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(AssistantProvider, { runtime, children });
 };
-var AssistantRuntimeProvider = (0, import_react5.memo)(AssistantRuntimeProviderImpl);
+var AssistantRuntimeProvider = (0, import_react6.memo)(AssistantRuntimeProviderImpl);
 
 // src/context/react/ComposerContext.ts
-var import_react7 = require("react");
+var import_react8 = require("react");
 
 // src/context/react/MessageContext.ts
-var import_react6 = require("react");
-var MessageContext = (0, import_react6.createContext)(null);
+var import_react7 = require("react");
+var MessageContext = (0, import_react7.createContext)(null);
 function useMessageContext(options) {
-  const context = (0, import_react6.useContext)(MessageContext);
+  const context = (0, import_react7.useContext)(MessageContext);
   if (!options?.optional && !context)
     throw new Error(
       "This component can only be used inside a component passed to <ThreadPrimitive.Messages components={...} />."
@@ -421,7 +486,7 @@ function useMessageContext(options) {
 var useComposerContext = () => {
   const { useComposer } = useThreadContext();
   const { useEditComposer } = useMessageContext({ optional: true }) ?? {};
-  return (0, import_react7.useMemo)(
+  return (0, import_react8.useMemo)(
     () => ({
       useComposer: useEditComposer ?? useComposer,
       type: useEditComposer ? "edit" : "new"
@@ -431,12 +496,12 @@ var useComposerContext = () => {
 };
 
 // src/context/react/ContentPartContext.ts
-var import_react8 = require("react");
-var ContentPartContext = (0, import_react8.createContext)(
+var import_react9 = require("react");
+var ContentPartContext = (0, import_react9.createContext)(
   null
 );
 function useContentPartContext(options) {
-  const context = (0, import_react8.useContext)(ContentPartContext);
+  const context = (0, import_react9.useContext)(ContentPartContext);
   if (!options?.optional && !context)
     throw new Error(
       "This component can only be used inside a component passed to <MessagePrimitive.Content components={...} >."
@@ -445,7 +510,7 @@ function useContentPartContext(options) {
 }
 
 // src/hooks/useAppendMessage.tsx
-var import_react9 = require("react");
+var import_react10 = require("react");
 var toAppendMessage = (useThreadMessages, message) => {
   if (typeof message === "string") {
     return {
@@ -462,7 +527,7 @@ var toAppendMessage = (useThreadMessages, message) => {
 };
 var useAppendMessage = () => {
   const { useThreadMessages, useThreadActions, useViewport, useComposer } = useThreadContext();
-  const append = (0, import_react9.useCallback)(
+  const append = (0, import_react10.useCallback)(
     (message) => {
       const appendMessage = toAppendMessage(useThreadMessages, message);
       useThreadActions.getState().append(appendMessage);
@@ -475,11 +540,11 @@ var useAppendMessage = () => {
 };
 
 // src/hooks/useSwitchToNewThread.tsx
-var import_react10 = require("react");
+var import_react11 = require("react");
 var useSwitchToNewThread = () => {
   const { useAssistantActions } = useAssistantContext();
   const { useComposer } = useThreadContext();
-  const switchToNewThread = (0, import_react10.useCallback)(() => {
+  const switchToNewThread = (0, import_react11.useCallback)(() => {
     useAssistantActions.getState().switchToThread(null);
     useComposer.getState().focus();
   }, [useAssistantActions, useComposer]);
@@ -487,14 +552,14 @@ var useSwitchToNewThread = () => {
 };
 
 // src/model-config/useAssistantTool.tsx
-var import_react11 = require("react");
+var import_react12 = require("react");
 var useAssistantTool = (tool) => {
   const { useModelConfig, useToolUIs } = useAssistantContext();
   const registerModelConfigProvider = useModelConfig(
     (s) => s.registerModelConfigProvider
   );
   const setToolUI = useToolUIs((s) => s.setToolUI);
-  (0, import_react11.useEffect)(() => {
+  (0, import_react12.useEffect)(() => {
     const { toolName, render, ...rest } = tool;
     const config = {
       tools: {
@@ -522,11 +587,11 @@ var makeAssistantTool = (tool) => {
 };
 
 // src/model-config/useAssistantToolUI.tsx
-var import_react12 = require("react");
+var import_react13 = require("react");
 var useAssistantToolUI = (tool) => {
   const { useToolUIs } = useAssistantContext();
   const setToolUI = useToolUIs((s) => s.setToolUI);
-  (0, import_react12.useEffect)(() => {
+  (0, import_react13.useEffect)(() => {
     if (!tool) return;
     const { toolName, render } = tool;
     return setToolUI(toolName, render);
@@ -543,13 +608,13 @@ var makeAssistantToolUI = (tool) => {
 };
 
 // src/model-config/useAssistantInstructions.tsx
-var import_react13 = require("react");
+var import_react14 = require("react");
 var useAssistantInstructions = (instruction) => {
   const { useModelConfig } = useAssistantContext();
   const registerModelConfigProvider = useModelConfig(
     (s) => s.registerModelConfigProvider
   );
-  (0, import_react13.useEffect)(() => {
+  (0, import_react14.useEffect)(() => {
     const config = {
       system: instruction
     };
@@ -558,13 +623,13 @@ var useAssistantInstructions = (instruction) => {
 };
 
 // src/primitive-hooks/actionBar/useActionBarCopy.tsx
-var import_react16 = require("react");
+var import_react17 = require("react");
 
 // src/utils/combined/useCombinedStore.ts
-var import_react15 = require("react");
+var import_react16 = require("react");
 
 // src/utils/combined/createCombinedStore.ts
-var import_react14 = require("react");
+var import_react15 = require("react");
 var createCombinedStore = (stores) => {
   const subscribe = (callback) => {
     const unsubscribes = stores.map((store) => store.subscribe(callback));
@@ -576,13 +641,13 @@ var createCombinedStore = (stores) => {
   };
   return (selector) => {
     const getSnapshot = () => selector(...stores.map((store) => store.getState()));
-    return (0, import_react14.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+    return (0, import_react15.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
   };
 };
 
 // src/utils/combined/useCombinedStore.ts
 var useCombinedStore = (stores, selector) => {
-  const useCombined = (0, import_react15.useMemo)(() => createCombinedStore(stores), stores);
+  const useCombined = (0, import_react16.useMemo)(() => createCombinedStore(stores), stores);
   return useCombined(selector);
 };
 
@@ -605,7 +670,7 @@ var useActionBarCopy = ({
       return !c.isEditing && m.message.content.some((c2) => c2.type === "text" && c2.text.length > 0);
     }
   );
-  const callback = (0, import_react16.useCallback)(() => {
+  const callback = (0, import_react17.useCallback)(() => {
     const { message } = useMessage.getState();
     const { setIsCopied } = useMessageUtils.getState();
     const { isEditing, value: composerValue } = useEditComposer.getState();
@@ -620,14 +685,14 @@ var useActionBarCopy = ({
 };
 
 // src/primitive-hooks/actionBar/useActionBarEdit.tsx
-var import_react17 = require("react");
+var import_react18 = require("react");
 var useActionBarEdit = () => {
   const { useMessage, useEditComposer } = useMessageContext();
   const disabled = useCombinedStore(
     [useMessage, useEditComposer],
     (m, c) => m.message.role !== "user" || c.isEditing
   );
-  const callback = (0, import_react17.useCallback)(() => {
+  const callback = (0, import_react18.useCallback)(() => {
     const { edit } = useEditComposer.getState();
     edit();
   }, [useEditComposer]);
@@ -636,7 +701,7 @@ var useActionBarEdit = () => {
 };
 
 // src/primitive-hooks/actionBar/useActionBarReload.tsx
-var import_react18 = require("react");
+var import_react19 = require("react");
 var useActionBarReload = () => {
   const { useThread, useThreadActions, useComposer, useViewport } = useThreadContext();
   const { useMessage } = useMessageContext();
@@ -644,7 +709,7 @@ var useActionBarReload = () => {
     [useThread, useMessage],
     (t, m) => t.isRunning || m.message.role !== "assistant"
   );
-  const callback = (0, import_react18.useCallback)(() => {
+  const callback = (0, import_react19.useCallback)(() => {
     const { parentId } = useMessage.getState();
     useThreadActions.getState().startRun(parentId);
     useViewport.getState().scrollToBottom();
@@ -662,7 +727,7 @@ var useBranchPickerCount = () => {
 };
 
 // src/primitive-hooks/branchPicker/useBranchPickerNext.tsx
-var import_react19 = require("react");
+var import_react20 = require("react");
 var useBranchPickerNext = () => {
   const { useThreadActions } = useThreadContext();
   const { useMessage, useEditComposer } = useMessageContext();
@@ -670,7 +735,7 @@ var useBranchPickerNext = () => {
     [useMessage, useEditComposer],
     (m, c) => c.isEditing || m.branches.indexOf(m.message.id) + 1 >= m.branches.length
   );
-  const callback = (0, import_react19.useCallback)(() => {
+  const callback = (0, import_react20.useCallback)(() => {
     const { message, branches } = useMessage.getState();
     useThreadActions.getState().switchToBranch(branches[branches.indexOf(message.id) + 1]);
   }, [useThreadActions, useMessage]);
@@ -686,7 +751,7 @@ var useBranchPickerNumber = () => {
 };
 
 // src/primitive-hooks/branchPicker/useBranchPickerPrevious.tsx
-var import_react20 = require("react");
+var import_react21 = require("react");
 var useBranchPickerPrevious = () => {
   const { useThreadActions } = useThreadContext();
   const { useMessage, useEditComposer } = useMessageContext();
@@ -694,7 +759,7 @@ var useBranchPickerPrevious = () => {
     [useMessage, useEditComposer],
     (m, c) => c.isEditing || m.branches.indexOf(m.message.id) <= 0
   );
-  const callback = (0, import_react20.useCallback)(() => {
+  const callback = (0, import_react21.useCallback)(() => {
     const { message, branches } = useMessage.getState();
     useThreadActions.getState().switchToBranch(branches[branches.indexOf(message.id) - 1]);
   }, [useThreadActions, useMessage]);
@@ -703,11 +768,11 @@ var useBranchPickerPrevious = () => {
 };
 
 // src/primitive-hooks/composer/useComposerCancel.tsx
-var import_react21 = require("react");
+var import_react22 = require("react");
 var useComposerCancel = () => {
   const { useComposer } = useComposerContext();
   const disabled = useComposer((c) => !c.canCancel);
-  const callback = (0, import_react21.useCallback)(() => {
+  const callback = (0, import_react22.useCallback)(() => {
     const { cancel } = useComposer.getState();
     cancel();
   }, [useComposer]);
@@ -726,12 +791,12 @@ var useComposerIf = (props) => {
 };
 
 // src/primitive-hooks/composer/useComposerSend.tsx
-var import_react22 = require("react");
+var import_react23 = require("react");
 var useComposerSend = () => {
   const { useViewport, useComposer: useNewComposer } = useThreadContext();
   const { useComposer } = useComposerContext();
   const disabled = useComposer((c) => !c.isEditing || c.value.length === 0);
-  const callback = (0, import_react22.useCallback)(() => {
+  const callback = (0, import_react23.useCallback)(() => {
     const composerState = useComposer.getState();
     if (!composerState.isEditing) return;
     composerState.send();
@@ -820,11 +885,11 @@ var useThreadEmpty = () => {
 };
 
 // src/primitive-hooks/thread/useThreadScrollToBottom.tsx
-var import_react23 = require("react");
+var import_react24 = require("react");
 var useThreadScrollToBottom = () => {
   const { useComposer, useViewport } = useThreadContext();
   const isAtBottom = useViewport((s) => s.isAtBottom);
-  const handleScrollToBottom = (0, import_react23.useCallback)(() => {
+  const handleScrollToBottom = (0, import_react24.useCallback)(() => {
     useViewport.getState().scrollToBottom();
     useComposer.getState().focus();
   }, [useViewport, useComposer]);
@@ -833,7 +898,7 @@ var useThreadScrollToBottom = () => {
 };
 
 // src/primitive-hooks/thread/useThreadSuggestion.tsx
-var import_react24 = require("react");
+var import_react25 = require("react");
 var useThreadSuggestion = ({
   prompt,
   autoSend
@@ -841,7 +906,7 @@ var useThreadSuggestion = ({
   const { useThread, useComposer } = useThreadContext();
   const append = useAppendMessage();
   const disabled = useThread((t) => t.isRunning);
-  const callback = (0, import_react24.useCallback)(() => {
+  const callback = (0, import_react25.useCallback)(() => {
     const thread = useThread.getState();
     const composer = useComposer.getState();
     if (autoSend && !thread.isRunning) {
@@ -866,7 +931,7 @@ __export(actionBar_exports, {
 
 // src/primitives/actionBar/ActionBarRoot.tsx
 var import_react_primitive = require("@radix-ui/react-primitive");
-var import_react25 = require("react");
+var import_react26 = require("react");
 
 // src/primitives/actionBar/useActionBarFloatStatus.tsx
 var useActionBarFloatStatus = ({
@@ -892,7 +957,7 @@ var useActionBarFloatStatus = ({
 
 // src/primitives/actionBar/ActionBarRoot.tsx
 var import_jsx_runtime4 = require("react/jsx-runtime");
-var ActionBarPrimitiveRoot = (0, import_react25.forwardRef)(({ hideWhenRunning, autohide, autohideFloat, ...rest }, ref) => {
+var ActionBarPrimitiveRoot = (0, import_react26.forwardRef)(({ hideWhenRunning, autohide, autohideFloat, ...rest }, ref) => {
   const hideAndfloatStatus = useActionBarFloatStatus({
     hideWhenRunning,
     autohide,
@@ -911,12 +976,12 @@ var ActionBarPrimitiveRoot = (0, import_react25.forwardRef)(({ hideWhenRunning,
 ActionBarPrimitiveRoot.displayName = "ActionBarPrimitive.Root";
 
 // src/utils/createActionButton.tsx
-var import_react26 = require("react");
+var import_react27 = require("react");
 var import_react_primitive2 = require("@radix-ui/react-primitive");
 var import_primitive = require("@radix-ui/primitive");
 var import_jsx_runtime5 = require("react/jsx-runtime");
 var createActionButton = (displayName, useActionButton, forwardProps = []) => {
-  const ActionButton = (0, import_react26.forwardRef)((props, forwardedRef) => {
+  const ActionButton = (0, import_react27.forwardRef)((props, forwardedRef) => {
     const forwardedProps = {};
     const primitiveProps = {};
     Object.keys(props).forEach((key) => {
@@ -973,17 +1038,17 @@ __export(assistantModal_exports, {
 });
 
 // src/primitives/assistantModal/AssistantModalRoot.tsx
-var import_react28 = require("react");
+var import_react29 = require("react");
 var PopoverPrimitive2 = __toESM(require("@radix-ui/react-popover"));
 var import_primitive2 = require("@radix-ui/primitive");
 
 // src/utils/hooks/useOnComposerFocus.tsx
 var import_react_use_callback_ref = require("@radix-ui/react-use-callback-ref");
-var import_react27 = require("react");
+var import_react28 = require("react");
 var useOnComposerFocus = (callback) => {
   const callbackRef = (0, import_react_use_callback_ref.useCallbackRef)(callback);
   const { useComposer } = useThreadContext();
-  (0, import_react27.useEffect)(() => {
+  (0, import_react28.useEffect)(() => {
     return useComposer.getState().onFocus(() => {
       callbackRef();
     });
@@ -997,7 +1062,7 @@ var usePopoverScope = PopoverPrimitive.createPopoverScope();
 // src/primitives/assistantModal/AssistantModalRoot.tsx
 var import_jsx_runtime6 = require("react/jsx-runtime");
 var useAssistantModalOpenState = (defaultOpen = false) => {
-  const state = (0, import_react28.useState)(defaultOpen);
+  const state = (0, import_react29.useState)(defaultOpen);
   const [, setOpen] = state;
   useOnComposerFocus(() => {
     setOpen(true);
@@ -1026,10 +1091,10 @@ var AssistantModalPrimitiveRoot = ({
 AssistantModalPrimitiveRoot.displayName = "AssistantModalPrimitive.Root";
 
 // src/primitives/assistantModal/AssistantModalTrigger.tsx
-var import_react29 = require("react");
+var import_react30 = require("react");
 var PopoverPrimitive3 = __toESM(require("@radix-ui/react-popover"));
 var import_jsx_runtime7 = require("react/jsx-runtime");
-var AssistantModalPrimitiveTrigger = (0, import_react29.forwardRef)(
+var AssistantModalPrimitiveTrigger = (0, import_react30.forwardRef)(
   ({
     __scopeAssistantModal,
     ...rest
@@ -1041,11 +1106,11 @@ var AssistantModalPrimitiveTrigger = (0, import_react29.forwardRef)(
 AssistantModalPrimitiveTrigger.displayName = "AssistantModalPrimitive.Trigger";
 
 // src/primitives/assistantModal/AssistantModalContent.tsx
-var import_react30 = require("react");
+var import_react31 = require("react");
 var PopoverPrimitive4 = __toESM(require("@radix-ui/react-popover"));
 var import_primitive3 = require("@radix-ui/primitive");
 var import_jsx_runtime8 = require("react/jsx-runtime");
-var AssistantModalPrimitiveContent = (0, import_react30.forwardRef)(
+var AssistantModalPrimitiveContent = (0, import_react31.forwardRef)(
   ({
     __scopeAssistantModal,
     side,
@@ -1074,10 +1139,10 @@ var AssistantModalPrimitiveContent = (0, import_react30.forwardRef)(
 AssistantModalPrimitiveContent.displayName = "AssistantModalPrimitive.Content";
 
 // src/primitives/assistantModal/AssistantModalAnchor.tsx
-var import_react31 = require("react");
+var import_react32 = require("react");
 var PopoverPrimitive5 = __toESM(require("@radix-ui/react-popover"));
 var import_jsx_runtime9 = require("react/jsx-runtime");
-var AssistantModalPrimitiveAnchor = (0, import_react31.forwardRef)(
+var AssistantModalPrimitiveAnchor = (0, import_react32.forwardRef)(
   ({
     __scopeAssistantModal,
     ...rest
@@ -1142,26 +1207,6 @@ __export(message_exports, {
 // src/primitives/message/MessageRoot.tsx
 var import_react_primitive3 = require("@radix-ui/react-primitive");
 var import_react33 = require("react");
-
-// src/utils/hooks/useManagedRef.ts
-var import_react32 = require("react");
-var useManagedRef = (callback) => {
-  const cleanupRef = (0, import_react32.useRef)();
-  const ref = (0, import_react32.useCallback)(
-    (el) => {
-      if (cleanupRef.current) {
-        cleanupRef.current();
-      }
-      if (el) {
-        cleanupRef.current = callback(el);
-      }
-    },
-    [callback]
-  );
-  return ref;
-};
-
-// src/primitives/message/MessageRoot.tsx
 var import_react_compose_refs = require("@radix-ui/react-compose-refs");
 var import_jsx_runtime12 = require("react/jsx-runtime");
 var useIsHoveringRef = () => {
@@ -1209,7 +1254,7 @@ var import_react38 = require("react");
 
 // src/context/providers/ContentPartProvider.tsx
 var import_react34 = require("react");
-var import_zustand9 = require("zustand");
+var import_zustand10 = require("zustand");
 var import_jsx_runtime13 = require("react/jsx-runtime");
 var DONE_STATUS = { type: "done" };
 var syncContentPart = ({ message }, useContentPart, partIndex) => {
@@ -1229,7 +1274,7 @@ var syncContentPart = ({ message }, useContentPart, partIndex) => {
 var useContentPartContext2 = (partIndex) => {
   const { useMessage } = useMessageContext();
   const [context] = (0, import_react34.useState)(() => {
-    const useContentPart = (0, import_zustand9.create)(
+    const useContentPart = (0, import_zustand10.create)(
       () => ({})
     );
     syncContentPart(useMessage.getState(), useContentPart, partIndex);
@@ -1787,14 +1832,14 @@ var import_react49 = require("react");
 
 // src/context/providers/MessageProvider.tsx
 var import_react48 = require("react");
-var import_zustand12 = require("zustand");
+var import_zustand13 = require("zustand");
 
 // src/context/stores/EditComposer.ts
-var import_zustand10 = require("zustand");
+var import_zustand11 = require("zustand");
 var makeEditComposerStore = ({
   onEdit,
   onSend
-}) => (0, import_zustand10.create)()((set, get, store) => ({
+}) => (0, import_zustand11.create)()((set, get, store) => ({
   ...makeBaseComposer(set, get, store),
   canCancel: false,
   isEditing: false,
@@ -1813,8 +1858,8 @@ var makeEditComposerStore = ({
 }));
 
 // src/context/stores/MessageUtils.ts
-var import_zustand11 = require("zustand");
-var makeMessageUtilsStore = () => (0, import_zustand11.create)((set) => ({
+var import_zustand12 = require("zustand");
+var makeMessageUtilsStore = () => (0, import_zustand12.create)((set) => ({
   isCopied: false,
   setIsCopied: (value) => {
     set({ isCopied: value });
@@ -1849,7 +1894,7 @@ var syncMessage = (messages, getBranches, useMessage, messageIndex) => {
 var useMessageContext2 = (messageIndex) => {
   const { useThreadMessages, useThreadActions } = useThreadContext();
   const [context] = (0, import_react48.useState)(() => {
-    const useMessage = (0, import_zustand12.create)(() => ({}));
+    const useMessage = (0, import_zustand13.create)(() => ({}));
     const useMessageUtils = makeMessageUtilsStore();
     const useEditComposer = makeEditComposerStore({
       onEdit: () => {
@@ -2273,85 +2318,335 @@ var TooltipIconButton = (0, import_react52.forwardRef)(({ children, tooltip, sid
 });
 TooltipIconButton.displayName = "TooltipIconButton";
 
-// src/runtimes/edge/useEdgeRuntime.ts
-var import_react53 = require("react");
-
-// src/runtimes/edge/converters/toCoreMessages.ts
-var toCoreMessages = (message) => {
-  return message.map((message2) => {
-    return {
-      role: message2.role,
-      content: message2.content.map((part) => {
-        if (part.type === "ui") throw new Error("UI parts are not supported");
-        return part;
-      })
-    };
-  });
-};
-
-// src/runtimes/edge/converters/toLanguageModelTools.ts
-var import_zod = require("zod");
-var import_zod_to_json_schema = __toESM(require("zod-to-json-schema"));
-var toLanguageModelTools = (tools) => {
-  if (!tools) return [];
-  return Object.entries(tools).map(([name, tool]) => ({
-    type: "function",
-    name,
-    ...tool.description ? { description: tool.description } : void 0,
-    parameters: tool.parameters instanceof import_zod.z.ZodType ? (0, import_zod_to_json_schema.default)(tool.parameters) : tool.parameters
-  }));
-};
-
-// src/runtimes/edge/streams/assistantDecoderStream.ts
-function assistantDecoderStream() {
-  const toolCallNames = /* @__PURE__ */ new Map();
-  let currentToolCall;
-  return new TransformStream({
-    transform(chunk, controller) {
-      const [code, value] = parseStreamPart(chunk);
-      if (currentToolCall && code !== "2" /* ToolCallArgsTextDelta */ && code !== "E" /* Error */) {
-        controller.enqueue({
-          type: "tool-call",
-          toolCallType: "function",
-          toolCallId: currentToolCall.id,
-          toolName: currentToolCall.name,
-          args: currentToolCall.argsText
+// src/runtimes/edge/converters/toLanguageModelMessages.ts
+var assistantMessageSplitter = () => {
+  const stash = [];
+  let assistantMessage = {
+    role: "assistant",
+    content: []
+  };
+  let toolMessage = {
+    role: "tool",
+    content: []
+  };
+  return {
+    addTextContentPart: (part) => {
+      if (toolMessage.content.length > 0) {
+        stash.push(assistantMessage);
+        stash.push(toolMessage);
+        assistantMessage = {
+          role: "assistant",
+          content: []
+        };
+        toolMessage = {
+          role: "tool",
+          content: []
+        };
+      }
+      assistantMessage.content.push(part);
+    },
+    addToolCallPart: (part) => {
+      assistantMessage.content.push({
+        type: "tool-call",
+        toolCallId: part.toolCallId,
+        toolName: part.toolName,
+        args: part.args
+      });
+      if (part.result) {
+        toolMessage.content.push({
+          type: "tool-result",
+          toolCallId: part.toolCallId,
+          toolName: part.toolName,
+          result: part.result
+          // isError
         });
-        currentToolCall = void 0;
       }
-      switch (code) {
-        case "0" /* TextDelta */: {
-          controller.enqueue({
-            type: "text-delta",
-            textDelta: value
-          });
-          break;
-        }
-        case "1" /* ToolCallBegin */: {
-          const { id, name } = value;
-          toolCallNames.set(id, name);
-          currentToolCall = { id, name, argsText: "" };
-          break;
-        }
-        case "2" /* ToolCallArgsTextDelta */: {
-          const delta = value;
-          currentToolCall.argsText += delta;
-          controller.enqueue({
-            type: "tool-call-delta",
-            toolCallType: "function",
-            toolCallId: currentToolCall.id,
-            toolName: currentToolCall.name,
-            argsTextDelta: delta
-          });
-          break;
-        }
-        case "3" /* ToolCallResult */: {
-          controller.enqueue({
-            type: "tool-result",
-            toolCallType: "function",
-            toolCallId: value.id,
-            toolName: toolCallNames.get(value.id),
-            result: value.result
+    },
+    getMessages: () => {
+      if (toolMessage.content.length > 0) {
+        return [...stash, assistantMessage, toolMessage];
+      }
+      return [...stash, assistantMessage];
+    }
+  };
+};
+function toLanguageModelMessages(message) {
+  return message.flatMap((message2) => {
+    const role = message2.role;
+    switch (role) {
+      case "system": {
+        return [{ role: "system", content: message2.content[0].text }];
+      }
+      case "user": {
+        const msg = {
+          role: "user",
+          content: message2.content.map(
+            (part) => {
+              const type = part.type;
+              switch (type) {
+                case "text": {
+                  return part;
+                }
+                case "image": {
+                  return {
+                    type: "image",
+                    image: new URL(part.image)
+                  };
+                }
+                default: {
+                  const unhandledType = type;
+                  throw new Error(
+                    `Unspported content part type: ${unhandledType}`
+                  );
+                }
+              }
+            }
+          )
+        };
+        return [msg];
+      }
+      case "assistant": {
+        const splitter = assistantMessageSplitter();
+        for (const part of message2.content) {
+          const type = part.type;
+          switch (type) {
+            case "text": {
+              splitter.addTextContentPart(part);
+              break;
+            }
+            case "tool-call": {
+              splitter.addToolCallPart(part);
+              break;
+            }
+            default: {
+              const unhandledType = type;
+              throw new Error(`Unhandled content part type: ${unhandledType}`);
+            }
+          }
+        }
+        return splitter.getMessages();
+      }
+      default: {
+        const unhandledRole = role;
+        throw new Error(`Unknown message role: ${unhandledRole}`);
+      }
+    }
+  });
+}
+
+// src/runtimes/edge/converters/fromLanguageModelMessages.ts
+var fromLanguageModelMessages = (lm, { mergeRoundtrips }) => {
+  const messages = [];
+  for (const lmMessage of lm) {
+    const role = lmMessage.role;
+    switch (role) {
+      case "system": {
+        messages.push({
+          role: "system",
+          content: [
+            {
+              type: "text",
+              text: lmMessage.content
+            }
+          ]
+        });
+        break;
+      }
+      case "user": {
+        messages.push({
+          role: "user",
+          content: lmMessage.content.map((part) => {
+            const type = part.type;
+            switch (type) {
+              case "text": {
+                return {
+                  type: "text",
+                  text: part.text
+                };
+              }
+              case "image": {
+                if (part.image instanceof URL) {
+                  return {
+                    type: "image",
+                    image: part.image.href
+                  };
+                }
+                throw new Error("Only images with URL data are supported");
+              }
+              default: {
+                const unhandledType = type;
+                throw new Error(`Unknown content part type: ${unhandledType}`);
+              }
+            }
+          })
+        });
+        break;
+      }
+      case "assistant": {
+        const newContent = lmMessage.content.map((part) => {
+          if (part.type === "tool-call") {
+            return {
+              type: "tool-call",
+              toolCallId: part.toolCallId,
+              toolName: part.toolName,
+              argsText: JSON.stringify(part.args),
+              args: part.args
+            };
+          }
+          return part;
+        });
+        if (mergeRoundtrips) {
+          const previousMessage = messages[messages.length - 1];
+          if (previousMessage?.role === "assistant") {
+            previousMessage.content.push(...newContent);
+            break;
+          }
+        }
+        messages.push({
+          role: "assistant",
+          content: newContent
+        });
+        break;
+      }
+      case "tool": {
+        const previousMessage = messages[messages.length - 1];
+        if (previousMessage?.role !== "assistant")
+          throw new Error(
+            "A tool message must be preceded by an assistant message."
+          );
+        for (const tool of lmMessage.content) {
+          const toolCall = previousMessage.content.find(
+            (c) => c.type === "tool-call" && c.toolCallId === tool.toolCallId
+          );
+          if (!toolCall)
+            throw new Error("Received tool result for an unknown tool call.");
+          if (toolCall.toolName !== tool.toolName)
+            throw new Error("Tool call name mismatch.");
+          toolCall.result = tool.result;
+          if (tool.isError) {
+            toolCall.isError = true;
+          }
+        }
+        break;
+      }
+      default: {
+        const unhandledRole = role;
+        throw new Error(`Unknown message role: ${unhandledRole}`);
+      }
+    }
+  }
+  return messages;
+};
+
+// src/runtimes/edge/converters/fromCoreMessage.ts
+var fromCoreMessages = (message) => {
+  return message.map((message2) => {
+    return {
+      id: generateId(),
+      createdAt: /* @__PURE__ */ new Date(),
+      ...message2.role === "assistant" ? {
+        status: { type: "done" }
+      } : void 0,
+      ...message2
+    };
+  });
+};
+
+// src/runtimes/edge/converters/toCoreMessages.ts
+var toCoreMessages = (message) => {
+  return message.map((message2) => {
+    return {
+      role: message2.role,
+      content: message2.content.map((part) => {
+        if (part.type === "ui") throw new Error("UI parts are not supported");
+        if (part.type === "tool-call") {
+          const { argsText, ...rest } = part;
+          return rest;
+        }
+        return part;
+      })
+    };
+  });
+};
+
+// src/runtimes/edge/converters/fromLanguageModelTools.ts
+var fromLanguageModelTools = (tools) => {
+  return Object.fromEntries(
+    tools.map((tool) => [
+      tool.name,
+      {
+        description: tool.description,
+        parameters: tool.parameters
+      }
+    ])
+  );
+};
+
+// src/runtimes/edge/converters/toLanguageModelTools.ts
+var import_zod2 = require("zod");
+var import_zod_to_json_schema = __toESM(require("zod-to-json-schema"));
+var toLanguageModelTools = (tools) => {
+  return Object.entries(tools).map(([name, tool]) => ({
+    type: "function",
+    name,
+    ...tool.description ? { description: tool.description } : void 0,
+    parameters: tool.parameters instanceof import_zod2.z.ZodType ? (0, import_zod_to_json_schema.default)(tool.parameters) : tool.parameters
+  }));
+};
+
+// src/runtimes/edge/useEdgeRuntime.ts
+var import_react53 = require("react");
+
+// src/runtimes/edge/streams/assistantDecoderStream.ts
+function assistantDecoderStream() {
+  const toolCallNames = /* @__PURE__ */ new Map();
+  let currentToolCall;
+  return new TransformStream({
+    transform(chunk, controller) {
+      const [code, value] = parseStreamPart(chunk);
+      if (currentToolCall && code !== "2" /* ToolCallArgsTextDelta */ && code !== "E" /* Error */) {
+        controller.enqueue({
+          type: "tool-call",
+          toolCallType: "function",
+          toolCallId: currentToolCall.id,
+          toolName: currentToolCall.name,
+          args: currentToolCall.argsText
+        });
+        currentToolCall = void 0;
+      }
+      switch (code) {
+        case "0" /* TextDelta */: {
+          controller.enqueue({
+            type: "text-delta",
+            textDelta: value
+          });
+          break;
+        }
+        case "1" /* ToolCallBegin */: {
+          const { id, name } = value;
+          toolCallNames.set(id, name);
+          currentToolCall = { id, name, argsText: "" };
+          break;
+        }
+        case "2" /* ToolCallArgsTextDelta */: {
+          const delta = value;
+          currentToolCall.argsText += delta;
+          controller.enqueue({
+            type: "tool-call-delta",
+            toolCallType: "function",
+            toolCallId: currentToolCall.id,
+            toolName: currentToolCall.name,
+            argsTextDelta: delta
+          });
+          break;
+        }
+        case "3" /* ToolCallResult */: {
+          controller.enqueue({
+            type: "tool-result",
+            toolCallType: "function",
+            toolCallId: value.id,
+            toolName: toolCallNames.get(value.id),
+            result: value.result
           });
           break;
         }
@@ -2875,7 +3170,7 @@ var appendOrUpdateFinish = (message, chunk) => {
 };
 
 // src/runtimes/edge/streams/toolResultStream.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 var import_secure_json_parse2 = __toESM(require("secure-json-parse"));
 function toolResultStream(tools) {
   const toolCallExecutions = /* @__PURE__ */ new Map();
@@ -2889,12 +3184,16 @@ function toolResultStream(tools) {
           const tool = tools?.[toolName];
           if (!tool || !tool.execute) return;
           const args = import_secure_json_parse2.default.parse(argsText);
-          if (tool.parameters instanceof import_zod2.z.ZodType) {
+          if (tool.parameters instanceof import_zod3.z.ZodType) {
             const result = tool.parameters.safeParse(args);
             if (!result.success) {
               controller.enqueue({
-                type: "error",
-                error: new Error("Invalid tool call arguments")
+                type: "tool-result",
+                toolCallType,
+                toolCallId,
+                toolName,
+                result: "Function parameter validation failed. " + JSON.stringify(result.error.issues),
+                isError: true
               });
               return;
             } else {
@@ -2911,9 +3210,14 @@ function toolResultStream(tools) {
                       result: result2
                     });
                   } catch (error) {
+                    console.error("Error: ", error);
                     controller.enqueue({
-                      type: "error",
-                      error
+                      type: "tool-result",
+                      toolCallType,
+                      toolCallId,
+                      toolName,
+                      result: "Error: " + error,
+                      isError: true
                     });
                   } finally {
                     toolCallExecutions.delete(toolCallId);
@@ -2969,12 +3273,17 @@ var EdgeChatAdapter = class {
       body: JSON.stringify({
         system: config.system,
         messages: toCoreMessages(messages),
-        tools: toLanguageModelTools(
-          config.tools
-        )
+        tools: config.tools ? toLanguageModelTools(config.tools) : [],
+        ...config.callSettings,
+        ...config.config
       }),
       signal: abortSignal
     });
+    if (result.status !== 200) {
+      throw new Error(
+        `Edge runtime returned status ${result.status}: ${await result.text()}`
+      );
+    }
     const stream = result.body.pipeThrough(new TextDecoderStream()).pipeThrough(chunkByLineStream()).pipeThrough(assistantDecoderStream()).pipeThrough(toolResultStream(config.tools)).pipeThrough(runResultStream(initialContent));
     let message;
     let update;
@@ -3027,240 +3336,6 @@ var useEdgeRuntime = ({
   return useLocalRuntime(adapter, { initialMessages });
 };
 
-// src/runtimes/edge/converters/toLanguageModelMessages.ts
-var assistantMessageSplitter = () => {
-  const stash = [];
-  let assistantMessage = {
-    role: "assistant",
-    content: []
-  };
-  let toolMessage = {
-    role: "tool",
-    content: []
-  };
-  return {
-    addTextContentPart: (part) => {
-      if (toolMessage.content.length > 0) {
-        stash.push(assistantMessage);
-        stash.push(toolMessage);
-        assistantMessage = {
-          role: "assistant",
-          content: []
-        };
-        toolMessage = {
-          role: "tool",
-          content: []
-        };
-      }
-      assistantMessage.content.push(part);
-    },
-    addToolCallPart: (part) => {
-      assistantMessage.content.push({
-        type: "tool-call",
-        toolCallId: part.toolCallId,
-        toolName: part.toolName,
-        args: part.args
-      });
-      if (part.result) {
-        toolMessage.content.push({
-          type: "tool-result",
-          toolCallId: part.toolCallId,
-          toolName: part.toolName,
-          result: part.result
-          // isError
-        });
-      }
-    },
-    getMessages: () => {
-      if (toolMessage.content.length > 0) {
-        return [...stash, assistantMessage, toolMessage];
-      }
-      return [...stash, assistantMessage];
-    }
-  };
-};
-function toLanguageModelMessages(message) {
-  return message.flatMap((message2) => {
-    const role = message2.role;
-    switch (role) {
-      case "system": {
-        return [{ role: "system", content: message2.content[0].text }];
-      }
-      case "user": {
-        const msg = {
-          role: "user",
-          content: message2.content.map(
-            (part) => {
-              const type = part.type;
-              switch (type) {
-                case "text": {
-                  return part;
-                }
-                case "image": {
-                  return {
-                    type: "image",
-                    image: new URL(part.image)
-                  };
-                }
-                default: {
-                  const unhandledType = type;
-                  throw new Error(
-                    `Unspported content part type: ${unhandledType}`
-                  );
-                }
-              }
-            }
-          )
-        };
-        return [msg];
-      }
-      case "assistant": {
-        const splitter = assistantMessageSplitter();
-        for (const part of message2.content) {
-          const type = part.type;
-          switch (type) {
-            case "text": {
-              splitter.addTextContentPart(part);
-              break;
-            }
-            case "tool-call": {
-              splitter.addToolCallPart(part);
-              break;
-            }
-            default: {
-              const unhandledType = type;
-              throw new Error(`Unhandled content part type: ${unhandledType}`);
-            }
-          }
-        }
-        return splitter.getMessages();
-      }
-      default: {
-        const unhandledRole = role;
-        throw new Error(`Unknown message role: ${unhandledRole}`);
-      }
-    }
-  });
-}
-
-// src/runtimes/edge/converters/fromLanguageModelMessages.ts
-var fromLanguageModelMessages = (lm, mergeRoundtrips) => {
-  const messages = [];
-  for (const lmMessage of lm) {
-    const role = lmMessage.role;
-    switch (role) {
-      case "system": {
-        messages.push({
-          role: "system",
-          content: [
-            {
-              type: "text",
-              text: lmMessage.content
-            }
-          ]
-        });
-        break;
-      }
-      case "user": {
-        messages.push({
-          role: "user",
-          content: lmMessage.content.map((part) => {
-            const type = part.type;
-            switch (type) {
-              case "text": {
-                return {
-                  type: "text",
-                  text: part.text
-                };
-              }
-              case "image": {
-                if (part.image instanceof URL) {
-                  return {
-                    type: "image",
-                    image: part.image.href
-                  };
-                }
-                throw new Error("Only images with URL data are supported");
-              }
-              default: {
-                const unhandledType = type;
-                throw new Error(`Unknown content part type: ${unhandledType}`);
-              }
-            }
-          })
-        });
-        break;
-      }
-      case "assistant": {
-        const newContent = lmMessage.content.map((part) => {
-          if (part.type === "tool-call") {
-            return {
-              type: "tool-call",
-              toolCallId: part.toolCallId,
-              toolName: part.toolName,
-              argsText: JSON.stringify(part.args),
-              args: typeof part.args === "string" ? part.args : part.args
-            };
-          }
-          return part;
-        });
-        if (mergeRoundtrips) {
-          const previousMessage = messages[messages.length - 1];
-          if (previousMessage?.role === "assistant") {
-            previousMessage.content.push(...newContent);
-            break;
-          }
-        }
-        messages.push({
-          role: "assistant",
-          content: newContent
-        });
-        break;
-      }
-      case "tool": {
-        const previousMessage = messages[messages.length - 1];
-        if (previousMessage?.role !== "assistant")
-          throw new Error(
-            "A tool message must be preceded by an assistant message."
-          );
-        for (const tool of lmMessage.content) {
-          const toolCall = previousMessage.content.find(
-            (c) => c.type === "tool-call" && c.toolCallId === tool.toolCallId
-          );
-          if (!toolCall)
-            throw new Error("Received tool result for an unknown tool call.");
-          if (toolCall.toolName !== tool.toolName)
-            throw new Error("Tool call name mismatch.");
-          toolCall.result = tool.result;
-          if (tool.isError) {
-            toolCall.isError = true;
-          }
-        }
-        break;
-      }
-      default: {
-        const unhandledRole = role;
-        throw new Error(`Unknown message role: ${unhandledRole}`);
-      }
-    }
-  }
-  return messages;
-};
-
-// src/runtimes/edge/converters/fromCoreMessage.ts
-var fromCoreMessages = (message) => {
-  return message.map((message2) => {
-    return {
-      id: generateId(),
-      createdAt: /* @__PURE__ */ new Date(),
-      ...message2.role === "assistant" ? {
-        status: { type: "done" }
-      } : void 0,
-      ...message2
-    };
-  });
-};
-
 // src/runtimes/local/LocalRuntime.tsx
 var LocalRuntime = class extends BaseAssistantRuntime {
   _proxyConfigProvider;
@@ -3339,47 +3414,47 @@ var LocalThreadRuntime = class {
   async startRun(parentId) {
     this.repository.resetHead(parentId);
     const messages = this.repository.getMessages();
-    const message = {
+    let message = {
       id: generateId(),
       role: "assistant",
       status: { type: "in_progress" },
       content: [{ type: "text", text: "" }],
       createdAt: /* @__PURE__ */ new Date()
     };
-    this.repository.addOrUpdateMessage(parentId, { ...message });
     this.abortController?.abort();
     this.abortController = new AbortController();
+    this.repository.addOrUpdateMessage(parentId, { ...message });
     this.notifySubscribers();
-    try {
-      const updateHandler = ({ content }) => {
-        message.content = content;
-        const newMessage = { ...message };
-        this.repository.addOrUpdateMessage(parentId, newMessage);
-        this.notifySubscribers();
-        return newMessage;
+    const updateMessage = (m) => {
+      message = {
+        ...message,
+        ...m
       };
+      this.repository.addOrUpdateMessage(parentId, message);
+      this.notifySubscribers();
+      return message;
+    };
+    try {
       const result = await this.adapter.run({
         messages,
         abortSignal: this.abortController.signal,
         config: this.configProvider.getModelConfig(),
-        onUpdate: updateHandler
+        onUpdate: updateMessage
       });
-      if (result !== void 0) {
-        updateHandler(result);
-      }
       if (result.status?.type === "in_progress")
         throw new Error(
           "Unexpected in_progress status returned from ChatModelAdapter"
         );
-      message.status = result.status ?? { type: "done" };
+      this.abortController = null;
+      updateMessage({ status: { type: "done" }, ...result });
       this.repository.addOrUpdateMessage(parentId, { ...message });
     } catch (e) {
-      message.status = { type: "error", error: e };
-      this.repository.addOrUpdateMessage(parentId, { ...message });
-      throw e;
-    } finally {
+      const isAbortError = e instanceof Error && e.name === "AbortError";
       this.abortController = null;
-      this.notifySubscribers();
+      updateMessage({
+        status: isAbortError ? { type: "cancelled" } : { type: "error", error: e }
+      });
+      if (!isAbortError) throw e;
     }
   }
   cancelRun() {
@@ -4137,9 +4212,12 @@ var assistant_modal_default = Object.assign(AssistantModal, exports12);
   UserMessage,
   fromCoreMessages,
   fromLanguageModelMessages,
+  fromLanguageModelTools,
   makeAssistantTool,
   makeAssistantToolUI,
+  toCoreMessages,
   toLanguageModelMessages,
+  toLanguageModelTools,
   useActionBarCopy,
   useActionBarEdit,
   useActionBarReload,