@assistant-ui/core 0.1.14 → 0.1.16

package/src/react/primitives/message/MessageAttachments.tsx

@@ -1,5 +1,11 @@
 import type { CompleteAttachment } from "../../../types/attachment";
-import { ComponentType, type FC, type ReactNode, memo, useMemo } from "react";
+import {
+  type ComponentType,
+  type FC,
+  type ReactNode,
+  memo,
+  useMemo,
+} from "react";
 import { RenderChildrenWithAccessor, useAuiState } from "@assistant-ui/store";
 import { MessageAttachmentByIndexProvider } from "../../providers/AttachmentByIndexProvider";
 

package/src/react/primitives/message/MessageParts.tsx

@@ -3,7 +3,7 @@ import {
   type FC,
   type ReactNode,
   memo,
-  PropsWithChildren,
+  type PropsWithChildren,
   useMemo,
 } from "react";
 import {
@@ -32,6 +32,7 @@ import type {
   QuoteMessagePartComponent,
 } from "../../types/MessagePartComponentTypes";
 import type { MessagePartStatus } from "../../../types/message";
+import type { DataRenderersState } from "../../types/scopes/dataRenderers";
 import { useShallow } from "zustand/shallow";
 
 type MessagePartRange =
@@ -284,17 +285,25 @@ const ToolUIDisplay = ({
   return <Render {...props} />;
 };
 
+const getDataRenderer = (
+  dataRenderers: DataRenderersState,
+  name: string,
+  inlineFallback: DataMessagePartComponent | undefined,
+): DataMessagePartComponent | undefined => {
+  const named = dataRenderers.renderers[name]?.[0];
+  if (named) return named;
+  return dataRenderers.fallbacks[0] ?? inlineFallback;
+};
+
 const DataUIDisplay = ({
   Fallback,
   ...props
 }: {
   Fallback: DataMessagePartComponent | undefined;
 } & DataMessagePartProps) => {
-  const Render = useAuiState((s) => {
-    const Render = s.dataRenderers.renderers[props.name] ?? Fallback;
-    if (Array.isArray(Render)) return Render[0] ?? Fallback;
-    return Render;
-  });
+  const Render = useAuiState((s) =>
+    getDataRenderer(s.dataRenderers, props.name, Fallback),
+  );
   if (!Render) return null;
   return <Render {...props} />;
 };
@@ -433,6 +442,10 @@ const COMPLETE_STATUS: MessagePartStatus = Object.freeze({
   type: "complete",
 });
 
+const RUNNING_STATUS: MessagePartStatus = Object.freeze({
+  type: "running",
+});
+
 const EmptyPartsImpl: FC<MessagePartComponentProps> = ({ components }) => {
   const status = useAuiState(
     (s) => (s.message.status ?? COMPLETE_STATUS) as MessagePartStatus,
@@ -522,12 +535,11 @@ const RegisteredToolUI: FC = () => {
  */
 const RegisteredDataRendererUI: FC = () => {
   const part = useAuiState((s) => s.part);
-  const Render = useAuiState((s) => {
-    if (s.part.type !== "data") return null;
-    const entry = s.dataRenderers.renderers[s.part.name];
-    if (Array.isArray(entry)) return entry[0] ?? null;
-    return entry ?? null;
-  });
+  const Render = useAuiState((s) =>
+    s.part.type === "data"
+      ? (getDataRenderer(s.dataRenderers, s.part.name, undefined) ?? null)
+      : null,
+  );
 
   if (!Render || part.type !== "data") return null;
 
@@ -563,6 +575,12 @@ export type { PartState };
  *
  * For tool-call parts, adds `toolUI`, `addResult`, and `resume`.
  * For data parts, adds `dataRendererUI`.
+ *
+ * The render function is also invoked once with a synthetic empty text part
+ * (`{ type: "text", text: "", status: { type: "running" } }`) when the
+ * assistant message has no parts yet but is in the running state, so a
+ * loading indicator can render. Differentiate this from a real empty text
+ * via `part.status?.type === "running" && part.text === ""`.
  */
 export type EnrichedPartState =
   | (Extract<PartState, { type: "tool-call" }> & {
@@ -579,58 +597,77 @@ export type EnrichedPartState =
     })
   | Exclude<PartState, { type: "tool-call" } | { type: "data" }>;
 
+const EMPTY_RUNNING_TEXT_PART: Extract<EnrichedPartState, { type: "text" }> =
+  Object.freeze({
+    type: "text",
+    text: "",
+    status: RUNNING_STATUS,
+  });
+
 const MessagePrimitivePartsInner: FC<{
   children: (value: { part: EnrichedPartState }) => ReactNode;
 }> = ({ children }) => {
   const aui = useAui();
   const contentLength = useAuiState((s) => s.message.parts.length);
+  const isRunning = useAuiState(
+    (s) => (s.message.status?.type ?? "complete") === "running",
+  );
+  const isEmptyRunning = contentLength === 0 && isRunning;
+  // Subscribed (not snapshotted like `tools`) so fallbacks registered after
+  // the first render trigger a re-render and `hasUI` re-evaluates.
+  const dataRenderers = useAuiState((s) => s.dataRenderers);
 
   // biome-ignore lint/correctness/useExhaustiveDependencies: aui accessors are stable refs
-  return useMemo(
-    () =>
-      Array.from({ length: contentLength }, (_, index) => (
-        <PartByIndexProvider key={index} index={index}>
-          <RenderChildrenWithAccessor
-            getItemState={(aui) => aui.message().part({ index }).getState()}
-          >
-            {(getItem) => {
-              const result = children({
-                get part() {
-                  const state = getItem();
-                  if (state.type === "tool-call") {
-                    const entry = aui.tools().getState().tools[state.toolName];
-                    const hasUI = Array.isArray(entry) ? !!entry[0] : !!entry;
-                    const partMethods = aui.message().part({ index });
-                    return {
-                      ...state,
-                      toolUI: hasUI ? <RegisteredToolUI /> : null,
-                      addResult: partMethods.addToolResult,
-                      resume: partMethods.resumeToolCall,
-                    };
-                  }
-                  if (state.type === "data") {
-                    const entry = aui.dataRenderers().getState().renderers[
-                      state.name
-                    ];
-                    const hasUI = Array.isArray(entry) ? !!entry[0] : !!entry;
-                    return {
-                      ...state,
-                      dataRendererUI: hasUI ? (
-                        <RegisteredDataRendererUI />
-                      ) : null,
-                    };
-                  }
-                  return state;
-                },
-              });
-              if (result !== null) return result;
-              return <DefaultPartFallback />;
-            }}
-          </RenderChildrenWithAccessor>
-        </PartByIndexProvider>
-      )),
-    [contentLength, children],
-  );
+  return useMemo(() => {
+    if (contentLength === 0) {
+      if (!isEmptyRunning) return null;
+
+      return (
+        <TextMessagePartProvider text="" isRunning>
+          {children({ part: EMPTY_RUNNING_TEXT_PART })}
+        </TextMessagePartProvider>
+      );
+    }
+
+    return Array.from({ length: contentLength }, (_, index) => (
+      <PartByIndexProvider key={index} index={index}>
+        <RenderChildrenWithAccessor
+          getItemState={(aui) => aui.message().part({ index }).getState()}
+        >
+          {(getItem) => {
+            const result = children({
+              get part() {
+                const state = getItem();
+                if (state.type === "tool-call") {
+                  const entry = aui.tools().getState().tools[state.toolName];
+                  const hasUI = Array.isArray(entry) ? !!entry[0] : !!entry;
+                  const partMethods = aui.message().part({ index });
+                  return {
+                    ...state,
+                    toolUI: hasUI ? <RegisteredToolUI /> : null,
+                    addResult: partMethods.addToolResult,
+                    resume: partMethods.resumeToolCall,
+                  };
+                }
+                if (state.type === "data") {
+                  const hasUI =
+                    getDataRenderer(dataRenderers, state.name, undefined) !==
+                    undefined;
+                  return {
+                    ...state,
+                    dataRendererUI: hasUI ? <RegisteredDataRendererUI /> : null,
+                  };
+                }
+                return state;
+              },
+            });
+            if (result !== null) return result;
+            return <DefaultPartFallback />;
+          }}
+        </RenderChildrenWithAccessor>
+      </PartByIndexProvider>
+    ));
+  }, [contentLength, children, isEmptyRunning, dataRenderers]);
 };
 
 /**

package/src/react/primitives/part/PartMessages.tsx

@@ -3,7 +3,7 @@ import { useAuiState } from "@assistant-ui/store";
 import type { ThreadMessage } from "../../../types/message";
 import { ReadonlyThreadProvider } from "../../providers/ReadonlyThreadProvider";
 import {
-  ThreadPrimitiveMessages,
+  type ThreadPrimitiveMessages,
   ThreadPrimitiveMessagesImpl,
 } from "../thread/ThreadMessages";
 

package/src/react/primitives/thread/ThreadMessages.tsx

@@ -7,7 +7,7 @@ import {
 } from "react";
 import { RenderChildrenWithAccessor, useAuiState } from "@assistant-ui/store";
 import { MessageByIndexProvider } from "../../providers/MessageByIndexProvider";
-import { MessageState } from "../../../store";
+import type { MessageState } from "../../../store";
 
 type MessagesComponentConfig =
   | {
@@ -124,9 +124,10 @@ const getComponent = (
           DEFAULT_SYSTEM_MESSAGE
         );
       }
-    default:
+    default: {
       const _exhaustiveCheck: never = role;
       throw new Error(`Unknown message role: ${_exhaustiveCheck}`);
+    }
   }
 };
 

package/src/react/primitives/threadList/ThreadListItems.tsx

@@ -1,4 +1,10 @@
-import { ComponentType, FC, ReactNode, memo, useMemo } from "react";
+import {
+  type ComponentType,
+  type FC,
+  type ReactNode,
+  memo,
+  useMemo,
+} from "react";
 import { RenderChildrenWithAccessor, useAuiState } from "@assistant-ui/store";
 import type { ThreadListItemState } from "../../../store/scopes/thread-list-item";
 import { ThreadListItemByIndexProvider } from "../../providers/ThreadListItemByIndexProvider";

package/src/react/providers/AttachmentByIndexProvider.tsx

@@ -1,4 +1,4 @@
-import { type FC, type PropsWithChildren } from "react";
+import type { FC, PropsWithChildren } from "react";
 import { useAui, AuiProvider, Derived } from "@assistant-ui/store";
 
 export const MessageAttachmentByIndexProvider: FC<

package/src/react/providers/ChainOfThoughtByIndicesProvider.tsx

@@ -1,4 +1,4 @@
-import { type FC, type PropsWithChildren } from "react";
+import type { FC, PropsWithChildren } from "react";
 import { useAui, useAuiState, AuiProvider } from "@assistant-ui/store";
 import { ChainOfThoughtClient } from "../../store/clients/chain-of-thought-client";
 import type { ChainOfThoughtPart } from "../../store/scopes/chain-of-thought";

package/src/react/providers/ChainOfThoughtPartByIndexProvider.tsx

@@ -1,4 +1,4 @@
-import { type FC, type PropsWithChildren } from "react";
+import type { FC, PropsWithChildren } from "react";
 import { useAui, AuiProvider, Derived } from "@assistant-ui/store";
 
 export const ChainOfThoughtPartByIndexProvider: FC<

package/src/react/providers/MessageByIndexProvider.tsx

@@ -1,4 +1,4 @@
-import { type FC, type PropsWithChildren } from "react";
+import type { FC, PropsWithChildren } from "react";
 import { useAui, AuiProvider, Derived } from "@assistant-ui/store";
 
 export const MessageByIndexProvider: FC<

package/src/react/providers/PartByIndexProvider.tsx

@@ -1,4 +1,4 @@
-import { type FC, type PropsWithChildren } from "react";
+import type { FC, PropsWithChildren } from "react";
 import { useAui, AuiProvider, Derived } from "@assistant-ui/store";
 
 export const PartByIndexProvider: FC<

package/src/react/providers/QueueItemByIndexProvider.tsx

@@ -1,4 +1,4 @@
-import { type FC, type PropsWithChildren } from "react";
+import type { FC, PropsWithChildren } from "react";
 import { AuiProvider, Derived, useAui } from "@assistant-ui/store";
 
 export type QueueItemByIndexProviderProps = PropsWithChildren<{

package/src/react/providers/SuggestionByIndexProvider.tsx

@@ -1,4 +1,4 @@
-import { type FC, type PropsWithChildren } from "react";
+import type { FC, PropsWithChildren } from "react";
 import { AuiProvider, Derived, useAui } from "@assistant-ui/store";
 
 export type SuggestionByIndexProviderProps = PropsWithChildren<{

package/src/react/providers/TextMessagePartProvider.tsx

@@ -1,4 +1,4 @@
-import { type FC, type PropsWithChildren } from "react";
+import type { FC, PropsWithChildren } from "react";
 import { useAui, AuiProvider, type ClientOutput } from "@assistant-ui/store";
 import type { PartState } from "../../store/scopes/part";
 import { resource, tapMemo } from "@assistant-ui/tap";

package/src/react/providers/ThreadListItemByIndexProvider.tsx

@@ -1,4 +1,4 @@
-import { type FC, type PropsWithChildren } from "react";
+import type { FC, PropsWithChildren } from "react";
 import { useAui, AuiProvider, Derived } from "@assistant-ui/store";
 
 export const ThreadListItemByIndexProvider: FC<

package/src/react/providers/ThreadListItemRuntimeProvider.tsx

@@ -1,4 +1,4 @@
-import { type FC, type PropsWithChildren } from "react";
+import type { FC, PropsWithChildren } from "react";
 import { useAui, AuiProvider } from "@assistant-ui/store";
 import type { ThreadListItemRuntime } from "../..";
 import { ThreadListItemClient } from "../../store/internal";

package/src/react/runtimes/RemoteThreadListHookInstanceManager.tsx

@@ -1,21 +1,24 @@
 import {
-  FC,
+  type FC,
+  type RefObject,
   useCallback,
   useRef,
   useEffect,
+  useLayoutEffect,
   memo,
-  PropsWithChildren,
-  ComponentType,
+  type PropsWithChildren,
+  type ComponentType,
   useMemo,
+  Fragment,
 } from "react";
-import { UseBoundStore, StoreApi, create } from "zustand";
+import { type UseBoundStore, type StoreApi, create } from "zustand";
 import { useAui } from "@assistant-ui/store";
 import { ThreadListItemRuntimeProvider } from "../providers/ThreadListItemRuntimeProvider";
 import type { ThreadRuntimeCore } from "../../runtime/interfaces/thread-runtime-core";
 import type { ThreadListRuntimeCore } from "../../runtime/interfaces/thread-list-runtime-core";
 import type { AssistantRuntime } from "../../runtime/api/assistant-runtime";
 import { BaseSubscribable } from "../../subscribable/subscribable";
-import { ThreadRuntimeImpl } from "../../runtime/api/thread-runtime";
+import type { ThreadRuntimeImpl } from "../../runtime/api/thread-runtime";
 import { ThreadListRuntimeImpl } from "../../runtime/api/thread-list-runtime";
 
 type RemoteThreadListHook = () => AssistantRuntime;
@@ -23,6 +26,15 @@ type RemoteThreadListHook = () => AssistantRuntime;
 type RemoteThreadListHookInstance = {
   runtime?: ThreadRuntimeCore;
 };
+
+const ProviderRenderDetector: FC<{
+  detectorRef: RefObject<boolean>;
+}> = ({ detectorRef }) => {
+  useLayoutEffect(() => {
+    detectorRef.current = true;
+  }, [detectorRef]);
+  return null;
+};
 export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
   private useRuntimeHook: UseBoundStore<
     StoreApi<{ useRuntime: RemoteThreadListHook }>
@@ -82,9 +94,11 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
     }
   }
 
-  private _InnerActiveThreadProvider: FC<{
-    threadId: string;
-  }> = ({ threadId }) => {
+  // Rendered outside the user's Provider so deferred `children` cannot strand the binding.
+  private _RuntimeBinder: FC<PropsWithChildren<{ threadId: string }>> = ({
+    threadId,
+    children,
+  }) => {
     const { useRuntime } = this.useRuntimeHook();
     const runtime = useRuntime();
 
@@ -116,9 +130,8 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
 
     useEffect(() => {
       const runtimeCore = threadBinding.getState();
-      const setGetInitializePromise = (runtimeCore as Record<string, unknown>)[
-        "__internal_setGetInitializePromise"
-      ];
+      const setGetInitializePromise = (runtimeCore as Record<string, unknown>)
+        .__internal_setGetInitializePromise;
       if (typeof setGetInitializePromise === "function") {
         setGetInitializePromise.call(runtimeCore, () => initPromiseRef.current);
       }
@@ -139,7 +152,7 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
       });
     }, [runtime, aui]);
 
-    return null;
+    return <>{children}</>;
   };
 
   private _OuterActiveThreadProvider: FC<{
@@ -151,11 +164,30 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
       [threadId],
     );
 
+    const detectorRef = useRef(false);
+    useEffect(() => {
+      if (process.env.NODE_ENV !== "production" && Provider !== Fragment) {
+        const id = setTimeout(() => {
+          if (!detectorRef.current) {
+            console.warn(
+              "RemoteThreadListAdapter.unstable_Provider did not render its `children` synchronously. " +
+                "Render `children` on first commit; deferring them behind a loading state, Suspense boundary, " +
+                "or `useEffect` gate leaves thread context unavailable to downstream consumers.",
+            );
+          }
+        }, 100);
+        return () => clearTimeout(id);
+      }
+      return undefined;
+    }, [Provider]);
+
     return (
       <ThreadListItemRuntimeProvider runtime={runtime}>
-        <Provider>
-          <this._InnerActiveThreadProvider threadId={threadId} />
-        </Provider>
+        <this._RuntimeBinder threadId={threadId}>
+          <Provider>
+            <ProviderRenderDetector detectorRef={detectorRef} />
+          </Provider>
+        </this._RuntimeBinder>
       </ThreadListItemRuntimeProvider>
     );
   });

package/src/react/runtimes/RemoteThreadListThreadListRuntimeCore.tsx

@@ -15,14 +15,7 @@ import {
 } from "../../runtimes/remote-thread-list/remote-thread-state";
 import type { RemoteThreadListOptions } from "../../runtimes/remote-thread-list/types";
 import { RemoteThreadListHookInstanceManager } from "./RemoteThreadListHookInstanceManager";
-import {
-  ComponentType,
-  FC,
-  Fragment,
-  PropsWithChildren,
-  useEffect,
-  useId,
-} from "react";
+import { type FC, Fragment, useEffect, useId } from "react";
 import { create } from "zustand";
 import { AssistantMessageStream } from "assistant-stream";
 import type { ModelContextProvider } from "../../model-context/types";
@@ -36,6 +29,7 @@ export class RemoteThreadListThreadListRuntimeCore
   private readonly _hookManager: RemoteThreadListHookInstanceManager;
 
   private _loadThreadsPromise: Promise<void> | undefined;
+  private _loadGeneration = 0;
 
   private _mainThreadId!: string;
   private readonly _state = new OptimisticState<RemoteThreadState>({
@@ -54,6 +48,7 @@ export class RemoteThreadListThreadListRuntimeCore
   public getLoadThreadsPromise() {
     // TODO this needs to be cached in case this promise is loaded during suspense
     if (!this._loadThreadsPromise) {
+      const generation = this._loadGeneration;
       this._loadThreadsPromise = this._state
         .optimisticUpdate({
           execute: () => this._options.adapter.list(),
@@ -63,7 +58,9 @@ export class RemoteThreadListThreadListRuntimeCore
               isLoading: true,
             };
           },
+          // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
           then: (state, l) => {
+            if (generation !== this._loadGeneration) return state;
             const newThreadIds = [];
             const newArchivedThreadIds = [];
             const newThreadIdMap = {} as Record<string, THREAD_MAPPING_ID>;
@@ -94,6 +91,7 @@ export class RemoteThreadListThreadListRuntimeCore
                 externalId: thread.externalId,
                 status: thread.status,
                 title: thread.title,
+                custom: thread.custom,
                 initializeTask: Promise.resolve({
                   remoteId: thread.remoteId,
                   externalId: thread.externalId,
@@ -118,6 +116,7 @@ export class RemoteThreadListThreadListRuntimeCore
           },
         })
         .catch(() => {
+          if (generation !== this._loadGeneration) return;
           this._loadThreadsPromise = undefined;
           this._state.update({
             ...this._state.baseValue,
@@ -145,8 +144,7 @@ export class RemoteThreadListThreadListRuntimeCore
       this,
     );
     this.useProvider = create(() => ({
-      Provider: (options.adapter.unstable_Provider ??
-        Fragment) as ComponentType<PropsWithChildren>,
+      Provider: options.adapter.unstable_Provider ?? Fragment,
     }));
     this.__internal_setOptions(options);
     this.switchToNewThread();
@@ -160,8 +158,7 @@ export class RemoteThreadListThreadListRuntimeCore
 
     this._options = options;
 
-    const Provider = (options.adapter.unstable_Provider ??
-      Fragment) as ComponentType<PropsWithChildren>;
+    const Provider = options.adapter.unstable_Provider ?? Fragment;
     if (Provider !== this.useProvider.getState().Provider) {
       this.useProvider.setState({ Provider }, true);
     }
@@ -179,6 +176,12 @@ export class RemoteThreadListThreadListRuntimeCore
     }
   }
 
+  public reload() {
+    this._loadGeneration++;
+    this._loadThreadsPromise = undefined;
+    return this.getLoadThreadsPromise();
+  }
+
   public get isLoading() {
     return this._state.value.isLoading;
   }
@@ -239,6 +242,7 @@ export class RemoteThreadListThreadListRuntimeCore
           externalId: remoteMetadata.externalId,
           status: remoteMetadata.status,
           title: remoteMetadata.title,
+          custom: remoteMetadata.custom,
         } as RemoteThreadData,
       };
 
@@ -247,15 +251,23 @@ export class RemoteThreadListThreadListRuntimeCore
         [remoteMetadata.remoteId]: mappingId,
       };
 
+      // Filter both arrays first so a concurrent `list()` can't leave the id
+      // duplicated or under the wrong status.
+      const threadIdsWithoutRemote = state.threadIds.filter(
+        (id) => id !== remoteMetadata.remoteId,
+      );
+      const archivedThreadIdsWithoutRemote = state.archivedThreadIds.filter(
+        (id) => id !== remoteMetadata.remoteId,
+      );
+
       const newThreadIds =
         remoteMetadata.status === "regular"
-          ? [...state.threadIds, remoteMetadata.remoteId]
-          : state.threadIds;
-
+          ? [...threadIdsWithoutRemote, remoteMetadata.remoteId]
+          : threadIdsWithoutRemote;
       const newArchivedThreadIds =
         remoteMetadata.status === "archived"
-          ? [...state.archivedThreadIds, remoteMetadata.remoteId]
-          : state.archivedThreadIds;
+          ? [...archivedThreadIdsWithoutRemote, remoteMetadata.remoteId]
+          : archivedThreadIdsWithoutRemote;
 
       this._state.update({
         ...state,
@@ -316,6 +328,7 @@ export class RemoteThreadListThreadListRuntimeCore
             remoteId: undefined,
             externalId: undefined,
             title: undefined,
+            custom: undefined,
           } satisfies RemoteThreadData,
         },
       });
@@ -352,6 +365,7 @@ export class RemoteThreadListThreadListRuntimeCore
           },
         };
       },
+      // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
       then: (state, { remoteId, externalId }) => {
         const data = getThreadData(state, threadId);
         if (!data) return state;

package/src/react/runtimes/RuntimeAdapterProvider.tsx

@@ -1,4 +1,4 @@
-import { createContext, FC, ReactNode, useContext } from "react";
+import { createContext, type FC, type ReactNode, useContext } from "react";
 import type { ThreadHistoryAdapter } from "../../adapters/thread-history";
 import type { AttachmentAdapter } from "../../adapters/attachment";
 import type { ModelContextProvider } from "../../model-context/types";

package/src/react/runtimes/cloud/AssistantCloudThreadHistoryAdapter.ts

@@ -1,4 +1,4 @@
-import { RefObject, useState } from "react";
+import { type RefObject, useState } from "react";
 import type {
   GenericThreadHistoryAdapter,
   ThreadHistoryAdapter,
@@ -8,12 +8,12 @@ import type {
 } from "../../../adapters/thread-history";
 import type { ExportedMessageRepositoryItem } from "../../../runtime/utils/message-repository";
 import {
-  AssistantCloud,
+  type AssistantCloud,
   CloudMessagePersistence,
   createFormattedPersistence,
 } from "assistant-cloud";
 import { auiV0Decode, auiV0Encode } from "./auiV0";
-import { AssistantClient, useAui } from "@assistant-ui/store";
+import { type AssistantClient, useAui } from "@assistant-ui/store";
 import type { ThreadListItemMethods } from "../../../store/scopes/thread-list-item";
 
 const globalPersistence = new WeakMap<

package/src/react/runtimes/cloud/auiV0.ts

@@ -1,8 +1,11 @@
 import type { MessageStatus, ThreadMessage } from "../../../types/message";
 import { fromThreadMessageLike } from "../../../runtime/utils/thread-message-like";
-import { CloudMessage } from "assistant-cloud";
+import type { CloudMessage } from "assistant-cloud";
 import { isJSONValue } from "../../../utils/json/is-json";
-import { ReadonlyJSONObject, ReadonlyJSONValue } from "assistant-stream/utils";
+import type {
+  ReadonlyJSONObject,
+  ReadonlyJSONValue,
+} from "assistant-stream/utils";
 import type { ExportedMessageRepositoryItem } from "../../../runtime/utils/message-repository";
 
 type AuiV0MessagePart =