@assistant-ui/react 0.12.28 → 0.14.2

package/src/client/ExternalThread.ts

@@ -50,6 +50,13 @@ export type ExternalThreadQueueAdapter = {
 export type ExternalThreadProps = {
   messages: readonly ExternalThreadMessage[];
   isRunning?: boolean;
+  /**
+   * Whether sending new messages is currently disabled. When `true`, the
+   * thread composer's input remains usable but `send()` is a no-op and
+   * `composer.canSend` is `false`. Edit composers (saving message edits)
+   * intentionally ignore this flag.
+   */
+  isSendDisabled?: boolean;
   /**
    * Callback for new messages (non-queue runtimes).
    * @note Unused when `queue` is provided — new messages are routed through `queue.enqueue` instead.
@@ -146,7 +153,6 @@ const MessageClient = resource(
         branchNumber: 1,
         branchCount: 1,
         speech: undefined,
-        submittedFeedback: undefined,
         parts: partClients.state,
         isCopied,
         isHovering,
@@ -242,6 +248,7 @@ type ComposerClientResourceProps = {
   type: "thread" | "edit";
   isEditing: boolean;
   canCancel: boolean;
+  isSendDisabled?: boolean;
   onCancel: () => void;
   onBeginEdit?: () => void;
   onSend?: (message: AppendMessage) => void;
@@ -273,6 +280,7 @@ const ComposerClientResource = resource(
     type,
     isEditing,
     canCancel,
+    isSendDisabled = false,
     onCancel,
     onBeginEdit,
     onSend,
@@ -342,34 +350,36 @@ const ComposerClientResource = resource(
       [queueItems],
     );
 
-    const state = tapMemo(
-      () => ({
+    const state = tapMemo(() => {
+      const isEmpty = !text.trim() && !attachments.length;
+      return {
         text,
         role,
         attachments: attachmentClients.state,
         runConfig,
         isEditing,
         canCancel,
+        canSend: isEditing && !isEmpty && !isSendDisabled,
         attachmentAccept: "*",
-        isEmpty: !text.trim() && !attachments.length,
+        isEmpty,
         type,
         dictation: undefined,
         quote,
         queue: queueItems,
-      }),
-      [
-        text,
-        role,
-        attachmentClients.state,
-        runConfig,
-        isEditing,
-        canCancel,
-        type,
-        attachments.length,
-        quote,
-        queueItems,
-      ],
-    );
+      };
+    }, [
+      text,
+      role,
+      attachmentClients.state,
+      runConfig,
+      isEditing,
+      canCancel,
+      isSendDisabled,
+      type,
+      attachments.length,
+      quote,
+      queueItems,
+    ]);
 
     return {
       getState: () => state,
@@ -417,6 +427,8 @@ const ComposerClientResource = resource(
         setQuote(undefined);
       },
       send: (opts?: ComposerSendOptions) => {
+        if (!state.canSend) return;
+
         const currentQuote = quote;
         const composedMessage: AppendMessage = {
           role,
@@ -459,6 +471,7 @@ export const ExternalThread = resource(
   ({
     messages,
     isRunning = false,
+    isSendDisabled = false,
     onNew,
     onEdit,
     onReload,
@@ -504,6 +517,7 @@ export const ExternalThread = resource(
         type: "thread",
         isEditing: true,
         canCancel: isRunning,
+        isSendDisabled,
         onCancel: handleCancelRun,
         onSend: handleSendNew,
         queue,
@@ -589,7 +603,6 @@ export const ExternalThread = resource(
         onStartRun?.();
       },
       resumeRun: () => {},
-      unstable_resumeRun: () => {},
       cancelRun: handleCancelRun,
       getModelContext: () => ({ tools: {}, config: {} }),
       export: () => ({ messages: [] }),

package/src/client/InMemoryThreadList.ts

@@ -142,6 +142,8 @@ export const InMemoryThreadList = resource(
         mainThreadId,
         newThreadId: null,
         isLoading: false,
+        isLoadingMore: false,
+        hasMore: false,
         threadIds: regularThreads.map((t) => t.id),
         archivedThreadIds: archivedThreads.map((t) => t.id),
         threadItems: threadListItems.state,
@@ -155,6 +157,7 @@ export const InMemoryThreadList = resource(
       switchToNewThread: handleSwitchToNewThread,
       getLoadThreadsPromise: () => RESOLVED_PROMISE,
       reload: () => RESOLVED_PROMISE,
+      loadMore: () => RESOLVED_PROMISE,
       item: (selector) => {
         if (selector === "main") {
           const index = threads.findIndex((t) => t.id === mainThreadId);

package/src/client/SingleThreadList.ts

@@ -47,6 +47,8 @@ export const SingleThreadList = resource(
         mainThreadId: THREAD_ID,
         newThreadId: null,
         isLoading: false,
+        isLoadingMore: false,
+        hasMore: false,
         threadIds: [THREAD_ID],
         archivedThreadIds: [],
         threadItems: [itemClient.state],
@@ -65,6 +67,7 @@ export const SingleThreadList = resource(
       },
       getLoadThreadsPromise: () => RESOLVED_PROMISE,
       reload: () => RESOLVED_PROMISE,
+      loadMore: () => RESOLVED_PROMISE,
       item: (selector) => {
         if (
           selector !== "main" &&

package/src/context/providers/ThreadViewportProvider.tsx

@@ -19,6 +19,8 @@ export type ThreadViewportProviderProps = PropsWithChildren<{
 
 const useThreadViewportStoreValue = (options: ThreadViewportStoreOptions) => {
   const outerViewport = useThreadViewportStore({ optional: true });
+  // Viewport options are initial configuration. Keeping them non-reactive avoids
+  // fanout through every message in long threads when anchoring config changes.
   const [store] = useState(() => makeThreadViewportStore(options));
 
   // Forward scrollToBottom from outer viewport to inner viewport
@@ -37,18 +39,6 @@ const useThreadViewportStoreValue = (options: ThreadViewportStoreOptions) => {
     });
   }, [store, outerViewport]);
 
-  // Sync options to store when they change
-  useEffect(() => {
-    const nextState = {
-      turnAnchor: options.turnAnchor ?? "bottom",
-    };
-
-    const currentState = store.getState();
-    if (currentState.turnAnchor !== nextState.turnAnchor) {
-      writableStore(store).setState(nextState);
-    }
-  }, [store, options.turnAnchor]);
-
   return store;
 };
 

package/src/context/stores/ThreadViewport.ts

@@ -60,28 +60,80 @@ export type ThreadViewportState = {
   /** Controls scroll anchoring: "top" anchors user messages at top, "bottom" is classic behavior */
   readonly turnAnchor: "top" | "bottom";
 
+  /** Clamps tall user messages so the assistant response stays in view. */
+  readonly topAnchorMessageClamp: {
+    readonly tallerThan: string;
+    readonly visibleHeight: string;
+  };
+
   /** Raw height values from registered elements */
   readonly height: {
     /** Total viewport height */
     readonly viewport: number;
     /** Total content inset height (footer, anchor message, etc.) */
     readonly inset: number;
-    /** Height of the anchor user message (full height) */
-    readonly userMessage: number;
   };
 
+  /** Current DOM elements used for geometry-based top anchoring */
+  readonly element: {
+    readonly viewport: HTMLElement | null;
+    readonly anchor: HTMLElement | null;
+    readonly target: HTMLElement | null;
+  };
+
+  /** Numeric clamp configuration for the active top-anchor target message */
+  readonly targetConfig: {
+    readonly tallerThan: number;
+    readonly visibleHeight: number;
+  } | null;
+
+  /**
+   * The current top-anchor turn activated in this viewport session.
+   * History-loaded messages do not populate this; it is set when a run creates
+   * a live user/assistant pair and remains after the run completes.
+   */
+  readonly topAnchorTurn: {
+    readonly anchorId: string;
+    readonly targetId: string;
+  } | null;
+
   /** Register a viewport and get a handle to update its height */
   readonly registerViewport: () => SizeHandle;
 
   /** Register a content inset (footer, anchor message, etc.) and get a handle to update its height */
   readonly registerContentInset: () => SizeHandle;
 
-  /** Register the anchor user message height */
-  readonly registerUserMessageHeight: () => SizeHandle;
+  /** Register the scroll viewport element */
+  readonly registerViewportElement: (
+    element: HTMLElement | null,
+  ) => Unsubscribe;
+
+  /** Register the current anchor user message element */
+  readonly registerAnchorElement: (element: HTMLElement | null) => Unsubscribe;
+
+  /**
+   * Register the current top-anchor target (last assistant response) element
+   * along with its numeric clamp configuration. When unregistered, both
+   * `element.target` and `targetConfig` clear together.
+   */
+  readonly registerAnchorTargetElement: (
+    element: HTMLElement | null,
+    config?: { readonly tallerThan: number; readonly visibleHeight: number },
+  ) => Unsubscribe;
+
+  readonly setTopAnchorTurn: (
+    turn: { readonly anchorId: string; readonly targetId: string } | null,
+  ) => void;
 };
 
 export type ThreadViewportStoreOptions = {
   turnAnchor?: "top" | "bottom" | undefined;
+  topAnchorMessageClamp?:
+    | {
+        tallerThan?: string | undefined;
+        visibleHeight?: string | undefined;
+      }
+    | undefined;
 };
 
 export const makeThreadViewportStore = (
@@ -107,14 +159,27 @@ export const makeThreadViewportStore = (
       },
     });
   });
-  const userMessageRegistry = createSizeRegistry((total) => {
+  const registerElementSlot = (
+    key: "viewport" | "anchor",
+    element: HTMLElement | null,
+  ) => {
     store.setState({
-      height: {
-        ...store.getState().height,
-        userMessage: total,
+      element: {
+        ...store.getState().element,
+        [key]: element,
       },
     });
-  });
+
+    return () => {
+      if (store.getState().element[key] !== element) return;
+      store.setState({
+        element: {
+          ...store.getState().element,
+          [key]: null,
+        },
+      });
+    };
+  };
 
   const store = create<ThreadViewportState>(() => ({
     isAtBottom: true,
@@ -131,16 +196,51 @@ export const makeThreadViewportStore = (
     },
 
     turnAnchor: options.turnAnchor ?? "bottom",
+    topAnchorMessageClamp: {
+      tallerThan: options.topAnchorMessageClamp?.tallerThan ?? "10em",
+      visibleHeight: options.topAnchorMessageClamp?.visibleHeight ?? "6em",
+    },
 
     height: {
       viewport: 0,
       inset: 0,
-      userMessage: 0,
     },
+    element: {
+      viewport: null,
+      anchor: null,
+      target: null,
+    },
+    targetConfig: null,
+    topAnchorTurn: null,
 
     registerViewport: viewportRegistry.register,
     registerContentInset: insetRegistry.register,
-    registerUserMessageHeight: userMessageRegistry.register,
+    registerViewportElement: (element) =>
+      registerElementSlot("viewport", element),
+    registerAnchorElement: (element) => registerElementSlot("anchor", element),
+    registerAnchorTargetElement: (element, config) => {
+      store.setState({
+        element: {
+          ...store.getState().element,
+          target: element,
+        },
+        targetConfig: element && config ? config : null,
+      });
+
+      return () => {
+        if (store.getState().element.target !== element) return;
+        store.setState({
+          element: {
+            ...store.getState().element,
+            target: null,
+          },
+          targetConfig: null,
+        });
+      };
+    },
+    setTopAnchorTurn: (topAnchorTurn) => {
+      store.setState({ topAnchorTurn });
+    },
   }));
 
   return store;

package/src/index.ts

@@ -125,7 +125,6 @@ export type {
 // --- external-store ---
 export type { ThreadMessageLike } from "@assistant-ui/core";
 export {
-  getExternalStoreMessage,
   getExternalStoreMessages,
   bindExternalStoreMessage,
 } from "@assistant-ui/core";
@@ -151,25 +150,13 @@ export type {
   LocalRuntimeOptionsBase,
 } from "@assistant-ui/core";
 export { useLocalRuntime } from "./legacy-runtime/runtime-cores/local/useLocalRuntime";
-/**
- * @deprecated Use `useLocalRuntime` instead.
- */
-export { useLocalRuntime as useLocalThreadRuntime } from "./legacy-runtime/runtime-cores/local/useLocalRuntime";
 export type { LocalRuntimeOptions } from "./legacy-runtime/runtime-cores/local/LocalRuntimeOptions";
 
 // --- remote-thread-list ---
 export { useRemoteThreadListRuntime } from "./legacy-runtime/runtime-cores/remote-thread-list/useRemoteThreadListRuntime";
-/** @deprecated Use `useRemoteThreadListRuntime` instead. */
-export { useRemoteThreadListRuntime as unstable_useRemoteThreadListRuntime } from "./legacy-runtime/runtime-cores/remote-thread-list/useRemoteThreadListRuntime";
 export { useCloudThreadListAdapter } from "./legacy-runtime/runtime-cores/remote-thread-list/adapter/cloud";
-/** @deprecated Use `useCloudThreadListAdapter` instead. */
-export { useCloudThreadListAdapter as unstable_useCloudThreadListAdapter } from "./legacy-runtime/runtime-cores/remote-thread-list/adapter/cloud";
 export type { RemoteThreadListAdapter } from "@assistant-ui/core";
-/** @deprecated Use `RemoteThreadListAdapter` instead. */
-export type { RemoteThreadListAdapter as unstable_RemoteThreadListAdapter } from "@assistant-ui/core";
 export { InMemoryThreadListAdapter } from "@assistant-ui/core";
-/** @deprecated Use `InMemoryThreadListAdapter` instead. */
-export { InMemoryThreadListAdapter as unstable_InMemoryThreadListAdapter } from "@assistant-ui/core";
 
 // Re-export from @assistant-ui/core (runtime-cores root)
 export type { ExportedMessageRepositoryItem } from "@assistant-ui/core";
@@ -287,12 +274,14 @@ export type {
   AppendMessage,
   TextMessagePart,
   ReasoningMessagePart,
+  SourceProviderMetadata,
   SourceMessagePart,
   ImageMessagePart,
   FileMessagePart,
   DataMessagePart,
   Unstable_AudioMessagePart,
   ToolCallMessagePart,
+  ToolModelContentPart,
   MessageStatus,
   MessagePartStatus,
   ToolCallMessagePartStatus,
@@ -392,24 +381,21 @@ export {
 
 export type { Assistant } from "./augmentations";
 
-// Backwards compatibility — deprecated exports, to be removed in v0.13
-
-/**
- * @deprecated Use `useAui` instead. This alias will be removed in v0.13.
- */
-export { useAui as useAssistantApi } from "@assistant-ui/store";
-
-/**
- * @deprecated Use `useAuiState` instead. This alias will be removed in v0.13.
- */
-export { useAuiState as useAssistantState } from "@assistant-ui/store";
-
-/**
- * @deprecated Use `useAuiEvent` instead. This alias will be removed in v0.13.
- */
-export { useAuiEvent as useAssistantEvent } from "@assistant-ui/store";
-
-/**
- * @deprecated Use `AuiIf` instead. This alias will be removed in v0.13.
- */
-export { AuiIf as AssistantIf } from "@assistant-ui/store";
+// --- mcp-apps ---
+export { McpAppRenderer, McpAppsRemoteHost } from "./mcp-apps";
+export type {
+  McpAppRendererOptions,
+  McpAppMetadata,
+  McpAppResource,
+  McpAppResourceMeta,
+  McpAppResourceCSP,
+  McpAppSandboxConfig,
+  McpAppHostInfo,
+  McpAppHostContext,
+  McpAppDisplayMode,
+  McpAppsHost,
+  McpAppsRemoteHostOptions,
+  McpAppToolCallParams,
+  ToolCallMessagePartMcpMetadata,
+} from "./mcp-apps";
+export type { McpAppResourceOutput } from "@assistant-ui/core/react";

package/src/legacy-runtime/cloud/auiV0.ts

@@ -1,4 +1,8 @@
-import type { MessageStatus, ThreadMessage } from "@assistant-ui/core";
+import type {
+  MessageStatus,
+  SourceProviderMetadata,
+  ThreadMessage,
+} from "@assistant-ui/core";
 import { fromThreadMessageLike } from "../runtime-cores/external-store/ThreadMessageLike";
 import type { CloudMessage } from "assistant-cloud";
 import { isJSONValue } from "../../utils/json/is-json";
@@ -23,6 +27,16 @@ type AuiV0MessagePart =
       readonly id: string;
       readonly url: string;
       readonly title?: string;
+      readonly providerMetadata?: SourceProviderMetadata;
+    }
+  | {
+      readonly type: "source";
+      readonly sourceType: "document";
+      readonly id: string;
+      readonly title: string;
+      readonly mediaType: string;
+      readonly filename?: string;
+      readonly providerMetadata?: SourceProviderMetadata;
     }
   | {
       readonly type: "tool-call";
@@ -90,12 +104,31 @@ export function auiV0Encode(message: ThreadMessage): AuiV0Message {
           return { type: "reasoning", text: part.text };
 
         case "source":
+          if (part.sourceType === "url") {
+            return {
+              type: "source",
+              sourceType: "url",
+              id: part.id,
+              url: part.url,
+              ...(part.title != null ? { title: part.title } : undefined),
+              ...(part.providerMetadata != null
+                ? { providerMetadata: part.providerMetadata }
+                : undefined),
+            };
+          }
+
           return {
             type: "source",
-            sourceType: part.sourceType,
+            sourceType: "document",
             id: part.id,
-            url: part.url,
-            ...(part.title ? { title: part.title } : undefined),
+            title: part.title,
+            mediaType: part.mediaType,
+            ...(part.filename != null
+              ? { filename: part.filename }
+              : undefined),
+            ...(part.providerMetadata != null
+              ? { providerMetadata: part.providerMetadata }
+              : undefined),
           };
 
         case "tool-call": {

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

@@ -1,5 +1 @@
-export {
-  toAISDKTools,
-  getEnabledTools,
-  createRequestHeaders,
-} from "@assistant-ui/core";
+export { createRequestHeaders } from "@assistant-ui/core";