@assistant-ui/react 0.11.58 → 0.12.1

package/src/legacy-runtime/hooks/MessageContext.ts

@@ -1,12 +1,12 @@
 "use client";
 
 import { MessageRuntime } from "../runtime/MessageRuntime";
-import { useAssistantApi, useAssistantState } from "../../context/react";
+import { useAui, useAuiState } from "@assistant-ui/store";
 import { createStateHookForRuntime } from "../../context/react/utils/createStateHookForRuntime";
 import { EditComposerRuntime } from "../runtime";
 
 /**
- * @deprecated Use `useAssistantApi()` with `api.message()` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
+ * @deprecated Use `useAui()` with `aui.message()` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
  *
  * Hook to access the MessageRuntime from the current context.
  *
@@ -38,12 +38,12 @@ import { EditComposerRuntime } from "../runtime";
  *
  * // After:
  * function MessageActions() {
- *   const api = useAssistantApi();
+ *   const aui = useAui();
  *   const handleReload = () => {
- *     api.message().reload();
+ *     aui.message().reload();
  *   };
  *   const handleEdit = () => {
- *     api.message().startEdit();
+ *     aui.message().startEdit();
  *   };
  *   return (
  *     <div>
@@ -63,10 +63,10 @@ export function useMessageRuntime(options?: {
 export function useMessageRuntime(options?: {
   optional?: boolean | undefined;
 }) {
-  const api = useAssistantApi();
-  const runtime = useAssistantState(() =>
-    api.message.source
-      ? (api.message().__internal_getRuntime?.() ?? null)
+  const aui = useAui();
+  const runtime = useAuiState(() =>
+    aui.message.source
+      ? (aui.message().__internal_getRuntime?.() ?? null)
       : null,
   );
   if (!runtime && !options?.optional) {
@@ -76,7 +76,7 @@ export function useMessageRuntime(options?: {
 }
 
 /**
- * @deprecated Use `useAssistantState(({ message }) => message)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
+ * @deprecated Use `useAuiState(({ message }) => message)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
  *
  * Hook to access the current message state.
  *
@@ -102,9 +102,9 @@ export function useMessageRuntime(options?: {
  *
  * // After:
  * function MessageContent() {
- *   const role = useAssistantState(({ message }) => message.role);
- *   const content = useAssistantState(({ message }) => message.content);
- *   const isLoading = useAssistantState(({ message }) => message.status.type === "running");
+ *   const role = useAuiState(({ message }) => message.role);
+ *   const content = useAuiState(({ message }) => message.content);
+ *   const isLoading = useAuiState(({ message }) => message.status.type === "running");
  *   return (
  *     <div className={`message-${role}`}>
  *       {isLoading ? "Loading..." : content.map(part => part.text).join("")}
@@ -120,7 +120,7 @@ const useEditComposerRuntime = (opt: {
 }): EditComposerRuntime | null => useMessageRuntime(opt)?.composer ?? null;
 
 /**
- * @deprecated Use `useAssistantState(({ message }) => message.composer)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
+ * @deprecated Use `useAuiState(({ message }) => message.composer)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
  */
 export const useEditComposer = createStateHookForRuntime(
   useEditComposerRuntime,

package/src/legacy-runtime/hooks/MessagePartContext.ts

@@ -2,10 +2,10 @@
 
 import { MessagePartRuntime } from "../runtime/MessagePartRuntime";
 import { createStateHookForRuntime } from "../../context/react/utils/createStateHookForRuntime";
-import { useAssistantApi, useAssistantState } from "../../context/react";
+import { useAui, useAuiState } from "@assistant-ui/store";
 
 /**
- * @deprecated Use `useAssistantApi()` with `api.part()` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
+ * @deprecated Use `useAui()` with `aui.part()` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
  */
 export function useMessagePartRuntime(options?: {
   optional?: false | undefined;
@@ -16,9 +16,9 @@ export function useMessagePartRuntime(options?: {
 export function useMessagePartRuntime(options?: {
   optional?: boolean | undefined;
 }) {
-  const api = useAssistantApi();
-  const runtime = useAssistantState(() =>
-    api.part.source ? (api.part().__internal_getRuntime?.() ?? null) : null,
+  const aui = useAui();
+  const runtime = useAuiState(() =>
+    aui.part.source ? (aui.part().__internal_getRuntime?.() ?? null) : null,
   );
   if (!runtime && !options?.optional) {
     throw new Error("MessagePartRuntime is not available");
@@ -27,6 +27,6 @@ export function useMessagePartRuntime(options?: {
 }
 
 /**
- * @deprecated Use `useAssistantState(({ part }) => part)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
+ * @deprecated Use `useAuiState(({ part }) => part)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
  */
 export const useMessagePart = createStateHookForRuntime(useMessagePartRuntime);

package/src/legacy-runtime/hooks/ThreadContext.ts

@@ -5,14 +5,10 @@ import { ThreadRuntime } from "../runtime/ThreadRuntime";
 import { ModelContext } from "../../model-context";
 import { createStateHookForRuntime } from "../../context/react/utils/createStateHookForRuntime";
 import { ThreadComposerRuntime } from "../runtime";
-import {
-  useAssistantApi,
-  useAssistantEvent,
-  useAssistantState,
-} from "../../context/react";
+import { useAui, useAuiEvent, useAuiState } from "@assistant-ui/store";
 
 /**
- * @deprecated Use `useAssistantApi()` with `api.thread()` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
+ * @deprecated Use `useAui()` with `aui.thread()` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
  *
  * Hook to access the ThreadRuntime from the current context.
  *
@@ -36,9 +32,9 @@ import {
  *
  * // After:
  * function MyComponent() {
- *   const api = useAssistantApi();
+ *   const aui = useAui();
  *   const handleSendMessage = (text: string) => {
- *     api.thread().append({ role: "user", content: [{ type: "text", text }] });
+ *     aui.thread().append({ role: "user", content: [{ type: "text", text }] });
  *   };
  *   return <button onClick={() => handleSendMessage("Hello!")}>Send</button>;
  * }
@@ -51,9 +47,9 @@ export function useThreadRuntime(options?: {
   optional?: boolean | undefined;
 }): ThreadRuntime | null;
 export function useThreadRuntime(options?: { optional?: boolean | undefined }) {
-  const api = useAssistantApi();
-  const runtime = useAssistantState(() =>
-    api.thread.source ? (api.thread().__internal_getRuntime?.() ?? null) : null,
+  const aui = useAui();
+  const runtime = useAuiState(() =>
+    aui.thread.source ? (aui.thread().__internal_getRuntime?.() ?? null) : null,
   );
   if (!runtime && !options?.optional) {
     throw new Error("ThreadRuntime is not available");
@@ -62,7 +58,7 @@ export function useThreadRuntime(options?: { optional?: boolean | undefined }) {
 }
 
 /**
- * @deprecated Use `useAssistantState(({ thread }) => thread)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
+ * @deprecated Use `useAuiState(({ thread }) => thread)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
  *
  * Hook to access the current thread state.
  *
@@ -83,8 +79,8 @@ export function useThreadRuntime(options?: { optional?: boolean | undefined }) {
  *
  * // After:
  * function ThreadStatus() {
- *   const isRunning = useAssistantState(({ thread }) => thread.isRunning);
- *   const messageCount = useAssistantState(({ thread }) => thread.messages.length);
+ *   const isRunning = useAuiState(({ thread }) => thread.isRunning);
+ *   const messageCount = useAuiState(({ thread }) => thread.messages.length);
  *   return <div>Running: {isRunning}, Messages: {messageCount}</div>;
  * }
  * ```
@@ -96,14 +92,14 @@ const useThreadComposerRuntime = (opt: {
 }): ThreadComposerRuntime | null => useThreadRuntime(opt)?.composer ?? null;
 
 /**
- * @deprecated Use `useAssistantState(({ thread }) => thread.composer)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
+ * @deprecated Use `useAuiState(({ thread }) => thread.composer)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
  */
 export const useThreadComposer = createStateHookForRuntime(
   useThreadComposerRuntime,
 );
 
 /**
- * @deprecated Use `useAssistantState(({ thread }) => thread.modelContext)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
+ * @deprecated Use `useAuiState(({ thread }) => thread.modelContext)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
  */
 export function useThreadModelContext(options?: {
   optional?: false | undefined;
@@ -117,7 +113,7 @@ export function useThreadModelContext(options?: {
   const [, rerender] = useState({});
 
   const runtime = useThreadRuntime(options);
-  useAssistantEvent("thread.model-context-update", () => rerender({}));
+  useAuiEvent("thread.modelContextUpdate", () => rerender({}));
 
   if (!runtime) return null;
   return runtime?.getModelContext();

package/src/legacy-runtime/hooks/ThreadListItemContext.ts

@@ -2,10 +2,10 @@
 
 import { ThreadListItemRuntime } from "../runtime/ThreadListItemRuntime";
 import { createStateHookForRuntime } from "../../context/react/utils/createStateHookForRuntime";
-import { useAssistantApi, useAssistantState } from "../../context/react";
+import { useAui, useAuiState } from "@assistant-ui/store";
 
 /**
- * @deprecated Use `useAssistantApi()` with `api.threadListItem()` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
+ * @deprecated Use `useAui()` with `aui.threadListItem()` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
  */
 export function useThreadListItemRuntime(options?: {
   optional?: false | undefined;
@@ -16,10 +16,10 @@ export function useThreadListItemRuntime(options?: {
 export function useThreadListItemRuntime(options?: {
   optional?: boolean | undefined;
 }) {
-  const api = useAssistantApi();
-  const runtime = useAssistantState(() =>
-    api.threadListItem.source
-      ? (api.threadListItem().__internal_getRuntime?.() ?? null)
+  const aui = useAui();
+  const runtime = useAuiState(() =>
+    aui.threadListItem.source
+      ? (aui.threadListItem().__internal_getRuntime?.() ?? null)
       : null,
   );
   if (!runtime && !options?.optional) {
@@ -29,7 +29,7 @@ export function useThreadListItemRuntime(options?: {
 }
 
 /**
- * @deprecated Use `useAssistantState(({ threadListItem }) => threadListItem)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
+ * @deprecated Use `useAuiState(({ threadListItem }) => threadListItem)` instead. See migration guide: https://assistant-ui.com/docs/migrations/v0-12
  */
 export const useThreadListItem = createStateHookForRuntime(
   useThreadListItemRuntime,

package/src/legacy-runtime/runtime/RuntimeBindings.ts

@@ -64,10 +64,6 @@ export type ThreadListItemState = {
   readonly id: string;
   readonly remoteId: string | undefined;
   readonly externalId: string | undefined;
-  /**
-   * @deprecated Use `id` instead. This field will be removed in version 0.12.0.
-   */
-  readonly threadId: string;
   readonly status: ThreadListItemStatus;
   readonly title?: string | undefined;
 };

package/src/legacy-runtime/runtime/ThreadListItemRuntime.ts

@@ -3,7 +3,7 @@ import { ThreadListItemRuntimePath } from "./RuntimePathTypes";
 import { SubscribableWithState } from "./subscribable/Subscribable";
 import { ThreadListRuntimeCoreBinding } from "./ThreadListRuntime";
 
-export type ThreadListItemEventType = "switched-to" | "switched-away";
+export type ThreadListItemEventType = "switchedTo" | "switchedAway";
 
 import type {
   ThreadListItemState,
@@ -120,7 +120,7 @@ export class ThreadListItemRuntimeImpl implements ThreadListItemRuntime {
 
   public unstable_on(event: ThreadListItemEventType, callback: () => void) {
     // if the runtime is bound to a specific thread, trigger if isMain is toggled
-    // if the runtime is bound to the main thread, trigger switched-to if threadId changes
+    // if the runtime is bound to the main thread, trigger switchedTo if threadId changes
 
     let prevIsMain = this._core.getState().isMain;
     let prevThreadId = this._core.getState().id;
@@ -132,8 +132,8 @@ export class ThreadListItemRuntimeImpl implements ThreadListItemRuntime {
       prevIsMain = newIsMain;
       prevThreadId = newThreadId;
 
-      if (event === "switched-to" && !newIsMain) return;
-      if (event === "switched-away" && newIsMain) return;
+      if (event === "switchedTo" && !newIsMain) return;
+      if (event === "switchedAway" && newIsMain) return;
       callback();
     });
   }

package/src/legacy-runtime/runtime/ThreadListRuntime.ts

@@ -18,9 +18,9 @@ import { NestedSubscriptionSubject } from "./subscribable/NestedSubscriptionSubj
 
 export type ThreadListState = {
   readonly mainThreadId: string;
-  readonly newThread: string | undefined;
-  readonly threads: readonly string[];
-  readonly archivedThreads: readonly string[];
+  readonly newThreadId: string | undefined;
+  readonly threadIds: readonly string[];
+  readonly archivedThreadIds: readonly string[];
   readonly isLoading: boolean;
   readonly threadItems: Readonly<
     Record<string, Omit<ThreadListItemState, "isMain" | "threadId">>
@@ -49,11 +49,11 @@ const getThreadListState = (
 ): ThreadListState => {
   return {
     mainThreadId: threadList.mainThreadId,
-    newThread: threadList.newThreadId,
-    threads: threadList.threadIds,
-    archivedThreads: threadList.archivedThreadIds,
+    newThreadId: threadList.newThreadId,
+    threadIds: threadList.threadIds,
+    archivedThreadIds: threadList.archivedThreadIds,
     isLoading: threadList.isLoading,
-    threadItems: threadList.threadData,
+    threadItems: threadList.threadItems,
   };
 };
 
@@ -67,7 +67,6 @@ const getThreadListItemState = (
   if (!threadData) return SKIP_UPDATE;
   return {
     id: threadData.id,
-    threadId: threadData.id, // TODO remove in 0.12.0
     remoteId: threadData.remoteId,
     externalId: threadData.externalId,
     title: threadData.title,

package/src/legacy-runtime/runtime-cores/assistant-transport/useAssistantTransportRuntime.tsx

@@ -31,7 +31,7 @@ import { ToolExecutionStatus, useToolInvocations } from "./useToolInvocations";
 import { toAISDKTools, getEnabledTools, createRequestHeaders } from "./utils";
 import { useRemoteThreadListRuntime } from "../remote-thread-list/useRemoteThreadListRuntime";
 import { InMemoryThreadListAdapter } from "../remote-thread-list/adapter/in-memory";
-import { useAssistantApi, useAssistantState } from "../../../context/react";
+import { useAui, useAuiState } from "@assistant-ui/store";
 import { UserExternalState } from "../../../augmentations";
 
 const symbolAssistantTransportExtras = Symbol("assistant-transport-extras");
@@ -57,10 +57,10 @@ const asAssistantTransportExtras = (
 };
 
 export const useAssistantTransportSendCommand = () => {
-  const api = useAssistantApi();
+  const aui = useAui();
 
   return (command: AssistantTransportCommand) => {
-    const extras = api.thread().getState().extras;
+    const extras = aui.thread().getState().extras;
     const transportExtras = asAssistantTransportExtras(extras);
     transportExtras.sendCommand(command);
   };
@@ -73,7 +73,7 @@ export function useAssistantTransportState<T>(
 export function useAssistantTransportState<T>(
   selector: (state: UserExternalState) => T = (t) => t as T,
 ): T | UserExternalState {
-  return useAssistantState(({ thread }) =>
+  return useAuiState(({ thread }) =>
     selector(asAssistantTransportExtras(thread.extras).state),
   );
 }
@@ -89,9 +89,7 @@ const useAssistantTransportThreadRuntime = <T,>(
     onQueue: () => runManager.schedule(),
   });
 
-  const threadId = useAssistantState(
-    ({ threadListItem }) => threadListItem.remoteId,
-  );
+  const threadId = useAuiState(({ threadListItem }) => threadListItem.remoteId);
 
   const runManager = useRunManager({
     onRun: async (signal: AbortSignal) => {

package/src/legacy-runtime/runtime-cores/assistant-transport/useToolInvocations.ts

@@ -192,6 +192,22 @@ export function useToolInvocations({
                   }
                 } else {
                   if (!content.argsText.startsWith(lastState.argsText)) {
+                    // Check if this is key reordering (both are complete JSON)
+                    // This happens when transitioning from streaming to complete state
+                    // and the provider returns keys in a different order
+                    if (
+                      isArgsTextComplete(lastState.argsText) &&
+                      isArgsTextComplete(content.argsText)
+                    ) {
+                      lastState.controller.argsText.close();
+                      lastToolStates.current[content.toolCallId] = {
+                        argsText: content.argsText,
+                        hasResult: lastState.hasResult,
+                        argsComplete: true,
+                        controller: lastState.controller,
+                      };
+                      return; // Continue to next content part
+                    }
                     throw new Error(
                       `Tool call argsText can only be appended, not updated: ${content.argsText} does not start with ${lastState.argsText}`,
                     );
@@ -249,7 +265,7 @@ export function useToolInvocations({
     if (isInitialState.current) {
       isInitialState.current = false;
     }
-  }, [state, controller, onResult]);
+  }, [state, controller]);
 
   const abort = (): Promise<void> => {
     humanInputRef.current.forEach(({ reject }) => {

package/src/legacy-runtime/runtime-cores/composer/BaseComposerRuntimeCore.tsx

@@ -204,7 +204,7 @@ export abstract class BaseComposerRuntimeCore
       upsertAttachment(await promiseOrGenerator);
     }
 
-    this._notifyEventSubscribers("attachment-add");
+    this._notifyEventSubscribers("attachmentAdd");
     this._notifySubscribers();
   }
 

package/src/legacy-runtime/runtime-cores/core/BaseThreadRuntimeCore.tsx

@@ -216,7 +216,7 @@ export abstract class BaseThreadRuntimeCore implements ThreadRuntimeCore {
   >();
 
   public unstable_on(event: ThreadRuntimeEventType, callback: () => void) {
-    if (event === "model-context-update") {
+    if (event === "modelContextUpdate") {
       return this._contextProvider.subscribe?.(callback) ?? (() => {});
     }
 

package/src/legacy-runtime/runtime-cores/core/ComposerRuntimeCore.tsx

@@ -6,7 +6,7 @@ import type {
 import type { MessageRole, RunConfig } from "../../../types/AssistantTypes";
 import type { DictationAdapter } from "../adapters/speech/SpeechAdapterTypes";
 
-export type ComposerRuntimeEventType = "send" | "attachment-add";
+export type ComposerRuntimeEventType = "send" | "attachmentAdd";
 
 /**
  * State representing an active dictation session.

package/src/legacy-runtime/runtime-cores/core/ThreadListRuntimeCore.tsx

@@ -21,7 +21,7 @@ export type ThreadListRuntimeCore = {
   threadIds: readonly string[];
   archivedThreadIds: readonly string[];
 
-  readonly threadData: Readonly<Record<string, ThreadListItemCoreState>>;
+  readonly threadItems: Readonly<Record<string, ThreadListItemCoreState>>;
 
   getMainThreadRuntimeCore(): ThreadRuntimeCore;
   getThreadRuntimeCore(threadId: string): ThreadRuntimeCore;

package/src/legacy-runtime/runtime-cores/core/ThreadRuntimeCore.tsx

@@ -58,10 +58,10 @@ export type SubmittedFeedback = {
 };
 
 export type ThreadRuntimeEventType =
-  | "run-start"
-  | "run-end"
+  | "runStart"
+  | "runEnd"
   | "initialize"
-  | "model-context-update";
+  | "modelContextUpdate";
 
 export type StartRunConfig = {
   parentId: string | null;

package/src/legacy-runtime/runtime-cores/external-store/ExternalStoreThreadListRuntimeCore.tsx

@@ -47,7 +47,7 @@ export class ExternalStoreThreadListRuntimeCore
     return this._archivedThreads;
   }
 
-  public get threadData() {
+  public get threadItems() {
     return this._threadData;
   }
 

package/src/legacy-runtime/runtime-cores/external-store/ExternalStoreThreadRuntimeCore.tsx

@@ -209,9 +209,9 @@ export class ExternalStoreThreadRuntimeCore
 
     if ((oldStore?.isRunning ?? false) !== (store.isRunning ?? false)) {
       if (store.isRunning) {
-        this._notifyEventSubscribers("run-start");
+        this._notifyEventSubscribers("runStart");
       } else {
-        this._notifyEventSubscribers("run-end");
+        this._notifyEventSubscribers("runEnd");
       }
     }
 

package/src/legacy-runtime/runtime-cores/external-store/ThreadMessageLike.tsx

@@ -85,12 +85,10 @@ export const fromThreadMessageLike = (
     image,
     ...rest
   }: ImageMessagePart): ImageMessagePart | null => {
-    // Accept base64 data URIs
-    const isBase64 = /^data:image\/(png|jpeg|jpg|gif|webp);base64,/.test(image);
-    // Accept HTTP/HTTPS URLs (e.g., from cloud storage)
-    const isUrl = /^https?:\/\//.test(image);
-
-    if (isBase64 || isUrl) {
+    const match = image.match(
+      /^data:image\/(png|jpeg|jpg|gif|webp);base64,(.*)$/,
+    );
+    if (match) {
       return { ...rest, image };
     }
     console.warn(`Invalid image data format detected`);

package/src/legacy-runtime/runtime-cores/external-store/createMessageConverter.tsx

@@ -1,6 +1,6 @@
 "use client";
 import { ThreadState } from "../../runtime";
-import { useAssistantApi, useAssistantState } from "../../../context";
+import { useAui, useAuiState } from "@assistant-ui/store";
 import { ThreadMessage } from "../../../types";
 import {
   useExternalMessageConverter,
@@ -57,13 +57,13 @@ export const createMessageConverter = <T extends object>(
       return first;
     },
     useOriginalMessages: () => {
-      const api = useAssistantApi();
-      const partMessages = useAssistantState((s) => {
-        if (api.part.source) return getExternalStoreMessages(s.part);
+      const aui = useAui();
+      const partMessages = useAuiState((s) => {
+        if (aui.part.source) return getExternalStoreMessages(s.part);
         return undefined;
       });
 
-      const messageMessages = useAssistantState<T[]>(({ message }) =>
+      const messageMessages = useAuiState<T[]>(({ message }) =>
         getExternalStoreMessages(message),
       );
 

package/src/legacy-runtime/runtime-cores/local/LocalThreadListRuntimeCore.tsx

@@ -50,7 +50,7 @@ export class LocalThreadListRuntimeCore
     return DEFAULT_THREAD_ID;
   }
 
-  public get threadData() {
+  public get threadItems() {
     return DEFAULT_THREAD_DATA;
   }
 

package/src/legacy-runtime/runtime-cores/local/LocalThreadRuntimeCore.tsx

@@ -230,7 +230,7 @@ export class LocalThreadRuntimeCore
       createdAt: new Date(),
     };
 
-    this._notifyEventSubscribers("run-start");
+    this._notifyEventSubscribers("runStart");
 
     try {
       this._suggestions = [];
@@ -248,7 +248,7 @@ export class LocalThreadRuntimeCore
         runCallback = undefined;
       } while (shouldContinue(message, this._options.unstable_humanToolNames));
     } finally {
-      this._notifyEventSubscribers("run-end");
+      this._notifyEventSubscribers("runEnd");
     }
 
     this._suggestionsController = new AbortController();
@@ -412,6 +412,10 @@ export class LocalThreadRuntimeCore
         updateMessage({
           status: { type: "incomplete", reason: "cancelled" },
         });
+      } else if (e instanceof Error && e.name === "AbortError") {
+        updateMessage({
+          status: { type: "incomplete", reason: "cancelled" },
+        });
       } else {
         updateMessage({
           status: {

package/src/legacy-runtime/runtime-cores/local/useLocalRuntime.tsx

@@ -8,29 +8,26 @@ import { useRuntimeAdapters } from "../adapters/RuntimeAdapterProvider";
 import { useRemoteThreadListRuntime } from "../remote-thread-list/useRemoteThreadListRuntime";
 import { useCloudThreadListAdapter } from "../remote-thread-list/adapter/cloud";
 import { AssistantRuntimeImpl } from "../../../internal";
-import { useAssistantState } from "../../../context/react";
+import { useAuiState } from "@assistant-ui/store";
 
 const useLocalThreadRuntime = (
   adapter: ChatModelAdapter,
   { initialMessages, ...options }: LocalRuntimeOptions,
 ) => {
   const { modelContext, ...threadListAdapters } = useRuntimeAdapters() ?? {};
-  const opt = useMemo(
-    () => ({
-      ...options,
-      adapters: {
-        ...threadListAdapters,
-        ...options.adapters,
-        chatModel: adapter,
-      },
-    }),
-    [adapter, options, threadListAdapters],
-  );
+  const opt = {
+    ...options,
+    adapters: {
+      ...threadListAdapters,
+      ...options.adapters,
+      chatModel: adapter,
+    },
+  };
 
   const [runtime] = useState(() => new LocalRuntimeCore(opt, initialMessages));
 
   const threadIdRef = useRef<string | undefined>(undefined);
-  threadIdRef.current = useAssistantState(
+  threadIdRef.current = useAuiState(
     ({ threadListItem }) => threadListItem.remoteId,
   );
 
@@ -49,7 +46,7 @@ const useLocalThreadRuntime = (
   useEffect(() => {
     runtime.threads.getMainThreadRuntimeCore().__internal_setOptions(opt);
     runtime.threads.getMainThreadRuntimeCore().__internal_load();
-  }, [runtime, opt]);
+  });
 
   useEffect(() => {
     if (!modelContext) return undefined;