@assistant-ui/react 0.4.5 → 0.4.7

package/dist/index.mjs

@@ -9,7 +9,7 @@ var __export = (target, all) => {
 import { memo } from "react";
 
 // src/context/providers/AssistantProvider.tsx
-import { useEffect as useEffect2, useInsertionEffect as useInsertionEffect2, useRef as useRef2, useState as useState2 } from "react";
+import { useEffect, useInsertionEffect as useInsertionEffect2, useRef as useRef2, useState as useState2 } from "react";
 
 // src/context/react/AssistantContext.ts
 import { createContext, useContext } from "react";
@@ -29,6 +29,21 @@ function useAssistantContext(options) {
 import { create } from "zustand";
 
 // src/types/ModelConfigTypes.ts
+import { z } from "zod";
+var LanguageModelV1CallSettingsSchema = z.object({
+  maxTokens: z.number().int().positive().optional(),
+  temperature: z.number().optional(),
+  topP: z.number().optional(),
+  presencePenalty: z.number().optional(),
+  frequencyPenalty: z.number().optional(),
+  seed: z.number().int().optional(),
+  headers: z.record(z.string().optional()).optional()
+});
+var LanguageModelConfigSchema = z.object({
+  apiKey: z.string().optional(),
+  baseUrl: z.string().optional(),
+  modelName: 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) => {
@@ -52,6 +67,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;
   }, {});
 };
@@ -116,14 +143,7 @@ var makeAssistantToolUIsStore = () => create2((set) => {
 });
 
 // src/context/providers/ThreadProvider.tsx
-import {
-  useCallback,
-  useEffect,
-  useInsertionEffect,
-  useRef,
-  useState,
-  useSyncExternalStore
-} from "react";
+import { useCallback as useCallback2, useInsertionEffect, useState } from "react";
 
 // src/context/react/ThreadContext.ts
 import { createContext as createContext2, useContext as useContext2 } from "react";
@@ -189,7 +209,7 @@ var makeComposerStore = (useThreadMessages, useThreadActions) => {
 import { create as create4 } from "zustand";
 var makeThreadStore = (runtimeRef) => {
   return create4(() => ({
-    isRunning: runtimeRef.current.isRunning
+    isRunning: runtimeRef.getState().isRunning
   }));
 };
 
@@ -215,19 +235,18 @@ var makeThreadViewportStore = () => {
 
 // src/context/stores/ThreadActions.ts
 import { create as create6 } from "zustand";
-var makeThreadActionStore = (runtimeRef) => {
+var makeThreadActionStore = (runtimeStore) => {
   return create6(
     () => 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)
     })
   );
 };
@@ -235,60 +254,96 @@ var makeThreadActionStore = (runtimeRef) => {
 // src/context/stores/ThreadMessages.ts
 import { create as create7 } from "zustand";
 var makeThreadMessagesStore = (runtimeRef) => {
-  return create7(() => runtimeRef.current.messages);
+  return create7(() => runtimeRef.getState().messages);
+};
+
+// src/context/stores/ThreadRuntime.tsx
+import { create as create8 } from "zustand";
+var makeThreadRuntimeStore = (runtime) => {
+  return create8(() => runtime);
+};
+
+// src/utils/hooks/useManagedRef.ts
+import { useCallback, useRef } from "react";
+var useManagedRef = (callback) => {
+  const cleanupRef = useRef();
+  const ref = useCallback(
+    (el) => {
+      if (cleanupRef.current) {
+        cleanupRef.current();
+      }
+      if (el) {
+        cleanupRef.current = callback(el);
+      }
+    },
+    [callback]
+  );
+  return ref;
 };
 
 // src/context/providers/ThreadProvider.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
 var ThreadProvider = ({
   children,
-  runtime
+  provider
 }) => {
-  const runtimeRef = useRef(runtime.thread);
   const [context] = useState(() => {
-    const useThread = makeThreadStore(runtimeRef);
-    const useThreadMessages = makeThreadMessagesStore(runtimeRef);
-    const useThreadActions = makeThreadActionStore(runtimeRef);
+    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 = useSyncExternalStore(
-    useCallback((c) => runtime.subscribe(c), [runtime]),
-    () => runtime.thread,
-    () => runtime.thread
+  const threadRef = useManagedRef(
+    useCallback2(
+      (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]
+    )
   );
   useInsertionEffect(() => {
-    runtimeRef.current = thread;
-  });
-  useEffect(() => {
-    const onThreadUpdate = () => {
-      context.useThread.setState(
-        Object.freeze({
-          isRunning: runtimeRef.current.isRunning
-        }),
-        true
-      );
-      context.useThreadMessages.setState(Object.freeze(runtimeRef.current.messages), true);
+    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__ */ jsxs(ThreadContext.Provider, { value: context, children: [
-    thread.unstable_synchronizer && /* @__PURE__ */ jsx(thread.unstable_synchronizer, {}),
+    Synchronizer && /* @__PURE__ */ jsx(Synchronizer, {}),
     children
   ] });
 };
 
 // src/context/stores/AssistantActions.tsx
-import { create as create8 } from "zustand";
-var makeAssistantActionsStore = (runtimeRef) => create8(
+import { create as create9 } from "zustand";
+var makeAssistantActionsStore = (runtimeRef) => create9(
   () => Object.freeze({
     switchToThread: () => runtimeRef.current.switchToThread(null),
     getRuntime: () => runtimeRef.current
@@ -309,10 +364,10 @@ var AssistantProvider = ({ children, runtime }) => {
     return { useModelConfig, useToolUIs, useAssistantActions };
   });
   const getModelConfig = context.useModelConfig();
-  useEffect2(() => {
+  useEffect(() => {
     return runtime.registerModelConfigProvider(getModelConfig);
   }, [runtime, getModelConfig]);
-  return /* @__PURE__ */ jsx2(AssistantContext.Provider, { value: context, children: /* @__PURE__ */ jsx2(ThreadProvider, { runtime, children }) });
+  return /* @__PURE__ */ jsx2(AssistantContext.Provider, { value: context, children: /* @__PURE__ */ jsx2(ThreadProvider, { provider: runtime, children }) });
 };
 
 // src/context/providers/AssistantRuntimeProvider.tsx
@@ -365,7 +420,7 @@ function useContentPartContext(options) {
 }
 
 // src/hooks/useAppendMessage.tsx
-import { useCallback as useCallback2 } from "react";
+import { useCallback as useCallback3 } from "react";
 var toAppendMessage = (useThreadMessages, message) => {
   if (typeof message === "string") {
     return {
@@ -382,7 +437,7 @@ var toAppendMessage = (useThreadMessages, message) => {
 };
 var useAppendMessage = () => {
   const { useThreadMessages, useThreadActions, useViewport, useComposer } = useThreadContext();
-  const append = useCallback2(
+  const append = useCallback3(
     (message) => {
       const appendMessage = toAppendMessage(useThreadMessages, message);
       useThreadActions.getState().append(appendMessage);
@@ -395,11 +450,11 @@ var useAppendMessage = () => {
 };
 
 // src/hooks/useSwitchToNewThread.tsx
-import { useCallback as useCallback3 } from "react";
+import { useCallback as useCallback4 } from "react";
 var useSwitchToNewThread = () => {
   const { useAssistantActions } = useAssistantContext();
   const { useComposer } = useThreadContext();
-  const switchToNewThread = useCallback3(() => {
+  const switchToNewThread = useCallback4(() => {
     useAssistantActions.getState().switchToThread(null);
     useComposer.getState().focus();
   }, [useAssistantActions, useComposer]);
@@ -407,14 +462,14 @@ var useSwitchToNewThread = () => {
 };
 
 // src/model-config/useAssistantTool.tsx
-import { useEffect as useEffect3 } from "react";
+import { useEffect as useEffect2 } from "react";
 var useAssistantTool = (tool) => {
   const { useModelConfig, useToolUIs } = useAssistantContext();
   const registerModelConfigProvider = useModelConfig(
     (s) => s.registerModelConfigProvider
   );
   const setToolUI = useToolUIs((s) => s.setToolUI);
-  useEffect3(() => {
+  useEffect2(() => {
     const { toolName, render, ...rest } = tool;
     const config = {
       tools: {
@@ -442,11 +497,11 @@ var makeAssistantTool = (tool) => {
 };
 
 // src/model-config/useAssistantToolUI.tsx
-import { useEffect as useEffect4 } from "react";
+import { useEffect as useEffect3 } from "react";
 var useAssistantToolUI = (tool) => {
   const { useToolUIs } = useAssistantContext();
   const setToolUI = useToolUIs((s) => s.setToolUI);
-  useEffect4(() => {
+  useEffect3(() => {
     if (!tool) return;
     const { toolName, render } = tool;
     return setToolUI(toolName, render);
@@ -463,13 +518,13 @@ var makeAssistantToolUI = (tool) => {
 };
 
 // src/model-config/useAssistantInstructions.tsx
-import { useEffect as useEffect5 } from "react";
+import { useEffect as useEffect4 } from "react";
 var useAssistantInstructions = (instruction) => {
   const { useModelConfig } = useAssistantContext();
   const registerModelConfigProvider = useModelConfig(
     (s) => s.registerModelConfigProvider
   );
-  useEffect5(() => {
+  useEffect4(() => {
     const config = {
       system: instruction
     };
@@ -478,13 +533,13 @@ var useAssistantInstructions = (instruction) => {
 };
 
 // src/primitive-hooks/actionBar/useActionBarCopy.tsx
-import { useCallback as useCallback4 } from "react";
+import { useCallback as useCallback5 } from "react";
 
 // src/utils/combined/useCombinedStore.ts
 import { useMemo as useMemo2 } from "react";
 
 // src/utils/combined/createCombinedStore.ts
-import { useSyncExternalStore as useSyncExternalStore2 } from "react";
+import { useSyncExternalStore } from "react";
 var createCombinedStore = (stores) => {
   const subscribe = (callback) => {
     const unsubscribes = stores.map((store) => store.subscribe(callback));
@@ -496,7 +551,7 @@ var createCombinedStore = (stores) => {
   };
   return (selector) => {
     const getSnapshot = () => selector(...stores.map((store) => store.getState()));
-    return useSyncExternalStore2(subscribe, getSnapshot, getSnapshot);
+    return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
   };
 };
 
@@ -525,7 +580,7 @@ var useActionBarCopy = ({
       return !c.isEditing && m.message.content.some((c2) => c2.type === "text" && c2.text.length > 0);
     }
   );
-  const callback = useCallback4(() => {
+  const callback = useCallback5(() => {
     const { message } = useMessage.getState();
     const { setIsCopied } = useMessageUtils.getState();
     const { isEditing, value: composerValue } = useEditComposer.getState();
@@ -540,14 +595,14 @@ var useActionBarCopy = ({
 };
 
 // src/primitive-hooks/actionBar/useActionBarEdit.tsx
-import { useCallback as useCallback5 } from "react";
+import { useCallback as useCallback6 } from "react";
 var useActionBarEdit = () => {
   const { useMessage, useEditComposer } = useMessageContext();
   const disabled = useCombinedStore(
     [useMessage, useEditComposer],
     (m, c) => m.message.role !== "user" || c.isEditing
   );
-  const callback = useCallback5(() => {
+  const callback = useCallback6(() => {
     const { edit } = useEditComposer.getState();
     edit();
   }, [useEditComposer]);
@@ -556,7 +611,7 @@ var useActionBarEdit = () => {
 };
 
 // src/primitive-hooks/actionBar/useActionBarReload.tsx
-import { useCallback as useCallback6 } from "react";
+import { useCallback as useCallback7 } from "react";
 var useActionBarReload = () => {
   const { useThread, useThreadActions, useComposer, useViewport } = useThreadContext();
   const { useMessage } = useMessageContext();
@@ -564,7 +619,7 @@ var useActionBarReload = () => {
     [useThread, useMessage],
     (t, m) => t.isRunning || m.message.role !== "assistant"
   );
-  const callback = useCallback6(() => {
+  const callback = useCallback7(() => {
     const { parentId } = useMessage.getState();
     useThreadActions.getState().startRun(parentId);
     useViewport.getState().scrollToBottom();
@@ -582,7 +637,7 @@ var useBranchPickerCount = () => {
 };
 
 // src/primitive-hooks/branchPicker/useBranchPickerNext.tsx
-import { useCallback as useCallback7 } from "react";
+import { useCallback as useCallback8 } from "react";
 var useBranchPickerNext = () => {
   const { useThreadActions } = useThreadContext();
   const { useMessage, useEditComposer } = useMessageContext();
@@ -590,7 +645,7 @@ var useBranchPickerNext = () => {
     [useMessage, useEditComposer],
     (m, c) => c.isEditing || m.branches.indexOf(m.message.id) + 1 >= m.branches.length
   );
-  const callback = useCallback7(() => {
+  const callback = useCallback8(() => {
     const { message, branches } = useMessage.getState();
     useThreadActions.getState().switchToBranch(branches[branches.indexOf(message.id) + 1]);
   }, [useThreadActions, useMessage]);
@@ -606,7 +661,7 @@ var useBranchPickerNumber = () => {
 };
 
 // src/primitive-hooks/branchPicker/useBranchPickerPrevious.tsx
-import { useCallback as useCallback8 } from "react";
+import { useCallback as useCallback9 } from "react";
 var useBranchPickerPrevious = () => {
   const { useThreadActions } = useThreadContext();
   const { useMessage, useEditComposer } = useMessageContext();
@@ -614,7 +669,7 @@ var useBranchPickerPrevious = () => {
     [useMessage, useEditComposer],
     (m, c) => c.isEditing || m.branches.indexOf(m.message.id) <= 0
   );
-  const callback = useCallback8(() => {
+  const callback = useCallback9(() => {
     const { message, branches } = useMessage.getState();
     useThreadActions.getState().switchToBranch(branches[branches.indexOf(message.id) - 1]);
   }, [useThreadActions, useMessage]);
@@ -623,11 +678,11 @@ var useBranchPickerPrevious = () => {
 };
 
 // src/primitive-hooks/composer/useComposerCancel.tsx
-import { useCallback as useCallback9 } from "react";
+import { useCallback as useCallback10 } from "react";
 var useComposerCancel = () => {
   const { useComposer } = useComposerContext();
   const disabled = useComposer((c) => !c.canCancel);
-  const callback = useCallback9(() => {
+  const callback = useCallback10(() => {
     const { cancel } = useComposer.getState();
     cancel();
   }, [useComposer]);
@@ -646,12 +701,12 @@ var useComposerIf = (props) => {
 };
 
 // src/primitive-hooks/composer/useComposerSend.tsx
-import { useCallback as useCallback10 } from "react";
+import { useCallback as useCallback11 } from "react";
 var useComposerSend = () => {
   const { useViewport, useComposer: useNewComposer } = useThreadContext();
   const { useComposer } = useComposerContext();
   const disabled = useComposer((c) => !c.isEditing || c.value.length === 0);
-  const callback = useCallback10(() => {
+  const callback = useCallback11(() => {
     const composerState = useComposer.getState();
     if (!composerState.isEditing) return;
     composerState.send();
@@ -740,11 +795,11 @@ var useThreadEmpty = () => {
 };
 
 // src/primitive-hooks/thread/useThreadScrollToBottom.tsx
-import { useCallback as useCallback11 } from "react";
+import { useCallback as useCallback12 } from "react";
 var useThreadScrollToBottom = () => {
   const { useComposer, useViewport } = useThreadContext();
   const isAtBottom = useViewport((s) => s.isAtBottom);
-  const handleScrollToBottom = useCallback11(() => {
+  const handleScrollToBottom = useCallback12(() => {
     useViewport.getState().scrollToBottom();
     useComposer.getState().focus();
   }, [useViewport, useComposer]);
@@ -753,7 +808,7 @@ var useThreadScrollToBottom = () => {
 };
 
 // src/primitive-hooks/thread/useThreadSuggestion.tsx
-import { useCallback as useCallback12 } from "react";
+import { useCallback as useCallback13 } from "react";
 var useThreadSuggestion = ({
   prompt,
   autoSend
@@ -761,7 +816,7 @@ var useThreadSuggestion = ({
   const { useThread, useComposer } = useThreadContext();
   const append = useAppendMessage();
   const disabled = useThread((t) => t.isRunning);
-  const callback = useCallback12(() => {
+  const callback = useCallback13(() => {
     const thread = useThread.getState();
     const composer = useComposer.getState();
     if (autoSend && !thread.isRunning) {
@@ -899,11 +954,11 @@ import { composeEventHandlers as composeEventHandlers2 } from "@radix-ui/primiti
 
 // src/utils/hooks/useOnComposerFocus.tsx
 import { useCallbackRef } from "@radix-ui/react-use-callback-ref";
-import { useEffect as useEffect6 } from "react";
+import { useEffect as useEffect5 } from "react";
 var useOnComposerFocus = (callback) => {
   const callbackRef = useCallbackRef(callback);
   const { useComposer } = useThreadContext();
-  useEffect6(() => {
+  useEffect5(() => {
     return useComposer.getState().onFocus(() => {
       callbackRef();
     });
@@ -1065,26 +1120,6 @@ import {
   forwardRef as forwardRef6,
   useCallback as useCallback14
 } from "react";
-
-// src/utils/hooks/useManagedRef.ts
-import { useCallback as useCallback13, useRef as useRef3 } from "react";
-var useManagedRef = (callback) => {
-  const cleanupRef = useRef3();
-  const ref = useCallback13(
-    (el) => {
-      if (cleanupRef.current) {
-        cleanupRef.current();
-      }
-      if (el) {
-        cleanupRef.current = callback(el);
-      }
-    },
-    [callback]
-  );
-  return ref;
-};
-
-// src/primitives/message/MessageRoot.tsx
 import { useComposedRefs } from "@radix-ui/react-compose-refs";
 import { jsx as jsx12 } from "react/jsx-runtime";
 var useIsHoveringRef = () => {
@@ -1131,8 +1166,8 @@ MessagePrimitiveIf.displayName = "MessagePrimitive.If";
 import { memo as memo2 } from "react";
 
 // src/context/providers/ContentPartProvider.tsx
-import { useEffect as useEffect7, useState as useState4 } from "react";
-import { create as create9 } from "zustand";
+import { useEffect as useEffect6, useState as useState4 } from "react";
+import { create as create10 } from "zustand";
 import { jsx as jsx13 } from "react/jsx-runtime";
 var DONE_STATUS = { type: "done" };
 var syncContentPart = ({ message }, useContentPart, partIndex) => {
@@ -1152,13 +1187,13 @@ var syncContentPart = ({ message }, useContentPart, partIndex) => {
 var useContentPartContext2 = (partIndex) => {
   const { useMessage } = useMessageContext();
   const [context] = useState4(() => {
-    const useContentPart = create9(
+    const useContentPart = create10(
       () => ({})
     );
     syncContentPart(useMessage.getState(), useContentPart, partIndex);
     return { useContentPart };
   });
-  useEffect7(() => {
+  useEffect6(() => {
     syncContentPart(useMessage.getState(), context.useContentPart, partIndex);
     return useMessage.subscribe((message) => {
       syncContentPart(message, context.useContentPart, partIndex);
@@ -1179,7 +1214,7 @@ import { Primitive as Primitive4 } from "@radix-ui/react-primitive";
 import { forwardRef as forwardRef7 } from "react";
 
 // src/utils/hooks/useSmooth.tsx
-import { useEffect as useEffect8, useRef as useRef4, useState as useState5 } from "react";
+import { useEffect as useEffect7, useRef as useRef3, useState as useState5 } from "react";
 var TextStreamAnimator = class {
   constructor(currentText, setText) {
     this.currentText = currentText;
@@ -1227,12 +1262,12 @@ var TextStreamAnimator = class {
 var useSmooth = (text, smooth = false) => {
   const { useMessage } = useMessageContext();
   const id = useMessage((m) => m.message.id);
-  const idRef = useRef4(id);
+  const idRef = useRef3(id);
   const [displayedText, setDisplayedText] = useState5(text);
   const [animatorRef] = useState5(
     new TextStreamAnimator(text, setDisplayedText)
   );
-  useEffect8(() => {
+  useEffect7(() => {
     if (!smooth) {
       animatorRef.stop();
       return;
@@ -1248,7 +1283,7 @@ var useSmooth = (text, smooth = false) => {
     animatorRef.targetText = text;
     animatorRef.start();
   }, [animatorRef, id, smooth, text]);
-  useEffect8(() => {
+  useEffect7(() => {
     return () => {
       animatorRef.stop();
     };
@@ -1434,8 +1469,8 @@ import { Slot } from "@radix-ui/react-slot";
 import {
   forwardRef as forwardRef11,
   useCallback as useCallback15,
-  useEffect as useEffect9,
-  useRef as useRef5
+  useEffect as useEffect8,
+  useRef as useRef4
 } from "react";
 import TextareaAutosize from "react-textarea-autosize";
 import { useEscapeKeydown } from "@radix-ui/react-use-escape-keydown";
@@ -1449,7 +1484,7 @@ var ComposerPrimitiveInput = forwardRef11(
       return c.value;
     });
     const Component = asChild ? Slot : TextareaAutosize;
-    const textareaRef = useRef5(null);
+    const textareaRef = useRef4(null);
     const ref = useComposedRefs2(forwardedRef, textareaRef);
     useEscapeKeydown((e) => {
       const composer = useComposer.getState();
@@ -1478,7 +1513,7 @@ var ComposerPrimitiveInput = forwardRef11(
         textareaRef.current.value.length
       );
     }, [autoFocusEnabled]);
-    useEffect9(() => focus(), [focus]);
+    useEffect8(() => focus(), [focus]);
     useOnComposerFocus(() => {
       if (type === "new") {
         focus();
@@ -1595,7 +1630,7 @@ import { forwardRef as forwardRef14 } from "react";
 
 // src/primitive-hooks/thread/useThreadViewportAutoScroll.tsx
 import { useComposedRefs as useComposedRefs3 } from "@radix-ui/react-compose-refs";
-import { useRef as useRef6 } from "react";
+import { useRef as useRef5 } from "react";
 
 // src/utils/hooks/useOnResizeContent.tsx
 import { useCallbackRef as useCallbackRef2 } from "@radix-ui/react-use-callback-ref";
@@ -1639,11 +1674,11 @@ var useOnResizeContent = (callback) => {
 
 // src/utils/hooks/useOnScrollToBottom.tsx
 import { useCallbackRef as useCallbackRef3 } from "@radix-ui/react-use-callback-ref";
-import { useEffect as useEffect10 } from "react";
+import { useEffect as useEffect9 } from "react";
 var useOnScrollToBottom = (callback) => {
   const callbackRef = useCallbackRef3(callback);
   const { useViewport } = useThreadContext();
-  useEffect10(() => {
+  useEffect9(() => {
     return useViewport.getState().onScrollToBottom(() => {
       callbackRef();
     });
@@ -1654,10 +1689,10 @@ var useOnScrollToBottom = (callback) => {
 var useThreadViewportAutoScroll = ({
   autoScroll = true
 }) => {
-  const divRef = useRef6(null);
+  const divRef = useRef5(null);
   const { useViewport } = useThreadContext();
-  const lastScrollTop = useRef6(0);
-  const isScrollingToBottomRef = useRef6(false);
+  const lastScrollTop = useRef5(0);
+  const isScrollingToBottomRef = useRef5(false);
   const scrollToBottom = (behavior) => {
     const div = divRef.current;
     if (!div || !autoScroll) return;
@@ -1716,15 +1751,15 @@ ThreadPrimitiveViewport.displayName = "ThreadPrimitive.Viewport";
 import { memo as memo3 } from "react";
 
 // src/context/providers/MessageProvider.tsx
-import { useEffect as useEffect11, useState as useState6 } from "react";
-import { create as create12 } from "zustand";
+import { useEffect as useEffect10, useState as useState6 } from "react";
+import { create as create13 } from "zustand";
 
 // src/context/stores/EditComposer.ts
-import { create as create10 } from "zustand";
+import { create as create11 } from "zustand";
 var makeEditComposerStore = ({
   onEdit,
   onSend
-}) => create10()((set, get, store) => ({
+}) => create11()((set, get, store) => ({
   ...makeBaseComposer(set, get, store),
   canCancel: false,
   isEditing: false,
@@ -1743,8 +1778,8 @@ var makeEditComposerStore = ({
 }));
 
 // src/context/stores/MessageUtils.ts
-import { create as create11 } from "zustand";
-var makeMessageUtilsStore = () => create11((set) => ({
+import { create as create12 } from "zustand";
+var makeMessageUtilsStore = () => create12((set) => ({
   isCopied: false,
   setIsCopied: (value) => {
     set({ isCopied: value });
@@ -1779,7 +1814,7 @@ var syncMessage = (messages, getBranches, useMessage, messageIndex) => {
 var useMessageContext2 = (messageIndex) => {
   const { useThreadMessages, useThreadActions } = useThreadContext();
   const [context] = useState6(() => {
-    const useMessage = create12(() => ({}));
+    const useMessage = create13(() => ({}));
     const useMessageUtils = makeMessageUtilsStore();
     const useEditComposer = makeEditComposerStore({
       onEdit: () => {
@@ -1815,7 +1850,7 @@ var useMessageContext2 = (messageIndex) => {
     );
     return { useMessage, useMessageUtils, useEditComposer };
   });
-  useEffect11(() => {
+  useEffect10(() => {
     return useThreadMessages.subscribe((thread) => {
       syncMessage(
         thread,
@@ -2205,108 +2240,358 @@ var TooltipIconButton = forwardRef17(({ children, tooltip, side = "bottom", ...r
 });
 TooltipIconButton.displayName = "TooltipIconButton";
 
-// src/runtimes/edge/useEdgeRuntime.ts
-import { useState as useState7 } from "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
-import { z } from "zod";
-import zodToJsonSchema from "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 z.ZodType ? zodToJsonSchema(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
-        });
-        currentToolCall = void 0;
+// 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: []
+        };
       }
-      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;
-        }
-        case "F" /* Finish */: {
-          controller.enqueue({
-            type: "finish",
-            ...value
-          });
-          break;
-        }
-        case "E" /* Error */: {
-          controller.enqueue({
-            type: "error",
-            error: value
-          });
-          break;
-        }
-        default: {
-          const unhandledType = code;
-          throw new Error(`Unhandled chunk type: ${unhandledType}`);
-        }
+      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: 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
+import { z as z2 } from "zod";
+import zodToJsonSchema from "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 z2.ZodType ? zodToJsonSchema(tool.parameters) : tool.parameters
+  }));
+};
+
+// src/runtimes/edge/useEdgeRuntime.ts
+import { useState as useState7 } from "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;
+        }
+        case "F" /* Finish */: {
+          controller.enqueue({
+            type: "finish",
+            ...value
+          });
+          break;
+        }
+        case "E" /* Error */: {
+          controller.enqueue({
+            type: "error",
+            error: value
+          });
+          break;
+        }
+        default: {
+          const unhandledType = code;
+          throw new Error(`Unhandled chunk type: ${unhandledType}`);
+        }
+      }
+    }
   });
 }
 var parseStreamPart = (part) => {
@@ -2807,7 +3092,7 @@ var appendOrUpdateFinish = (message, chunk) => {
 };
 
 // src/runtimes/edge/streams/toolResultStream.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 import sjson2 from "secure-json-parse";
 function toolResultStream(tools) {
   const toolCallExecutions = /* @__PURE__ */ new Map();
@@ -2821,12 +3106,16 @@ function toolResultStream(tools) {
           const tool = tools?.[toolName];
           if (!tool || !tool.execute) return;
           const args = sjson2.parse(argsText);
-          if (tool.parameters instanceof z2.ZodType) {
+          if (tool.parameters instanceof z3.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 {
@@ -2843,9 +3132,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);
@@ -2901,12 +3195,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;
@@ -2959,240 +3258,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;
@@ -3271,47 +3336,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() {
@@ -4068,9 +4133,12 @@ export {
   user_message_default as UserMessage,
   fromCoreMessages,
   fromLanguageModelMessages,
+  fromLanguageModelTools,
   makeAssistantTool,
   makeAssistantToolUI,
+  toCoreMessages,
   toLanguageModelMessages,
+  toLanguageModelTools,
   useActionBarCopy,
   useActionBarEdit,
   useActionBarReload,