@assistant-ui/core 0.2.12 → 0.2.14

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

@@ -44,9 +44,24 @@ import { useShallow } from "zustand/shallow";
 
 type MessagePartRange =
   | { type: "single"; index: number }
-  | { type: "toolGroup"; startIndex: number; endIndex: number }
-  | { type: "reasoningGroup"; startIndex: number; endIndex: number }
-  | { type: "chainOfThoughtGroup"; startIndex: number; endIndex: number };
+  | {
+      type: "toolGroup";
+      startIndex: number;
+      endIndex: number;
+      idKey?: string | undefined;
+    }
+  | {
+      type: "reasoningGroup";
+      startIndex: number;
+      endIndex: number;
+      idKey?: string | undefined;
+    }
+  | {
+      type: "chainOfThoughtGroup";
+      startIndex: number;
+      endIndex: number;
+      idKey?: string | undefined;
+    };
 
 /**
  * Creates a group state manager for a specific part type.
@@ -91,10 +106,13 @@ const createGroupState = <
  * Groups consecutive tool-call and reasoning message parts into ranges.
  * Always groups tool calls and reasoning parts, even if there's only one.
  * When useChainOfThought is true, groups tool-call and reasoning parts together.
+ * `partIds[i]` optionally carries a stable identity for part `i`; group
+ * ranges derive an `idKey` from their first part's id (first claim wins).
  */
-const groupMessageParts = (
+export const groupMessageParts = (
   messageTypes: readonly string[],
   useChainOfThought: boolean,
+  partIds?: readonly (string | undefined)[],
 ): MessagePartRange[] => {
   const ranges: MessagePartRange[] = [];
 
@@ -137,22 +155,44 @@ const groupMessageParts = (
     reasoningGroup.finalize(messageTypes.length - 1, ranges);
   }
 
+  if (partIds) {
+    const claimed = new Set<string>();
+    for (const range of ranges) {
+      if (range.type === "single") continue;
+      const id = partIds[range.startIndex];
+      if (id !== undefined && !claimed.has(id)) {
+        claimed.add(id);
+        range.idKey = `id:${id}`;
+      }
+    }
+  }
+
   return ranges;
 };
 
 const useMessagePartsGroups = (
   useChainOfThought: boolean,
-): MessagePartRange[] => {
+): { ranges: MessagePartRange[]; partIds: (string | undefined)[] } => {
   const messageTypes = useAuiState(
     useShallow((s) => s.message.parts.map((c: any) => c.type)),
   );
+  const partIds = useAuiState(
+    useShallow((s) =>
+      s.message.parts.map((c: any) =>
+        c.type === "tool-call" ? c.toolCallId : undefined,
+      ),
+    ),
+  );
 
   return useMemo(() => {
     if (messageTypes.length === 0) {
-      return [];
+      return { ranges: [], partIds };
     }
-    return groupMessageParts(messageTypes, useChainOfThought);
-  }, [messageTypes, useChainOfThought]);
+    return {
+      ranges: groupMessageParts(messageTypes, useChainOfThought, partIds),
+      partIds,
+    };
+  }, [messageTypes, partIds, useChainOfThought]);
 };
 
 export namespace MessagePrimitiveParts {
@@ -795,13 +835,24 @@ const MessagePrimitivePartsCompat: FC<{
 }> = ({ components, unstable_showEmptyOnNonTextEnd }) => {
   const contentLength = useAuiState((s) => s.message.parts.length);
   const useChainOfThought = !!components?.ChainOfThought;
-  const messageRanges = useMessagePartsGroups(useChainOfThought);
+  const { ranges: messageRanges, partIds } =
+    useMessagePartsGroups(useChainOfThought);
 
   const partsElements = useMemo(() => {
     if (contentLength === 0) {
       return <EmptyParts components={components} />;
     }
 
+    const claimed = new Set<string>();
+    const toolLeafKey = (partIndex: number) => {
+      const id = partIds[partIndex];
+      if (id !== undefined && !claimed.has(id)) {
+        claimed.add(id);
+        return `part-id:${id}`;
+      }
+      return `part-${partIndex}`;
+    };
+
     return messageRanges.map((range) => {
       if (range.type === "single") {
         return (
@@ -816,7 +867,7 @@ const MessagePrimitivePartsCompat: FC<{
         if (!ChainOfThoughtComponent) return null;
         return (
           <ChainOfThoughtByIndicesProvider
-            key={`chainOfThought-${range.startIndex}`}
+            key={`chainOfThought-${range.idKey ?? range.startIndex}`}
             startIndex={range.startIndex}
             endIndex={range.endIndex}
           >
@@ -828,7 +879,7 @@ const MessagePrimitivePartsCompat: FC<{
           components?.ToolGroup ?? defaultComponents.ToolGroup;
         return (
           <ToolGroupComponent
-            key={`tool-${range.startIndex}`}
+            key={`tool-${range.idKey ?? range.startIndex}`}
             startIndex={range.startIndex}
             endIndex={range.endIndex}
           >
@@ -838,7 +889,7 @@ const MessagePrimitivePartsCompat: FC<{
                 const partIndex = range.startIndex + i;
                 return (
                   <MessagePrimitivePartByIndex
-                    key={`part-${partIndex}`}
+                    key={toolLeafKey(partIndex)}
                     index={partIndex}
                     components={components}
                   />
@@ -874,7 +925,7 @@ const MessagePrimitivePartsCompat: FC<{
         );
       }
     });
-  }, [messageRanges, components, contentLength]);
+  }, [messageRanges, partIds, components, contentLength]);
 
   return (
     <>

package/src/react/providers/TextMessagePartProvider.tsx

@@ -4,13 +4,13 @@ import type { PartState } from "../../store/scopes/part";
 
 import { resource } from "@assistant-ui/tap";
 
-const TextMessagePartClient = resource(function TextMessagePartClient({
+const useTextMessagePartClient = ({
   text,
   isRunning,
 }: {
   text: string;
   isRunning: boolean;
-}): ClientOutput<"part"> {
+}): ClientOutput<"part"> => {
   const state = useMemo<PartState>(
     () => ({
       type: "text",
@@ -32,7 +32,9 @@ const TextMessagePartClient = resource(function TextMessagePartClient({
       throw new Error("Not supported");
     },
   };
-});
+};
+
+const TextMessagePartClient = resource(useTextMessagePartClient);
 
 export const TextMessagePartProvider: FC<
   PropsWithChildren<{

package/src/react/runtimes/RemoteThreadListThreadListRuntimeCore.tsx

@@ -296,6 +296,7 @@ export class RemoteThreadListThreadListRuntimeCore
           externalId: remoteMetadata.externalId,
           status: remoteMetadata.status,
           title: remoteMetadata.title,
+          lastMessageAt: remoteMetadata.lastMessageAt,
           custom: remoteMetadata.custom,
         } as RemoteThreadData,
       };

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

@@ -57,6 +57,11 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
         if (!remoteId) return;
         await formatted.update?.(remoteId, item, localMessageId);
       },
+      async delete() {
+        throw new Error(
+          "Assistant Cloud does not support deleting thread messages yet.",
+        );
+      },
       reportTelemetry(
         items: MessageFormatItem<TMessage>[],
         options?: {
@@ -97,6 +102,12 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
     }
   }
 
+  async delete() {
+    throw new Error(
+      "Assistant Cloud does not support deleting thread messages yet.",
+    );
+  }
+
   async load() {
     const remoteId = this.aui.threadListItem().getState().remoteId;
     if (!remoteId) return { messages: [] };

package/src/react/runtimes/cloud/useCloudThreadListAdapter.tsx

@@ -94,6 +94,9 @@ export const useCloudThreadListAdapter = (
           status: t.is_archived ? "archived" : "regular",
           remoteId: t.id,
           title: t.title,
+          lastMessageAt: t.last_message_at
+            ? new Date(t.last_message_at)
+            : undefined,
           externalId: t.external_id ?? undefined,
           custom: toCustom(t.metadata),
         })),
@@ -153,6 +156,9 @@ export const useCloudThreadListAdapter = (
         status: thread.is_archived ? "archived" : "regular",
         remoteId: thread.id,
         title: thread.title,
+        lastMessageAt: thread.last_message_at
+          ? new Date(thread.last_message_at)
+          : undefined,
         externalId: thread.external_id ?? undefined,
         custom: toCustom(thread.metadata),
       };

package/src/react/utils/groupParts.ts

@@ -119,6 +119,11 @@ export interface GroupNodeGroup {
   readonly key: string;
   /** Structural React key: sibling-index path, e.g. `"0.1.0"`. */
   readonly nodeKey: string;
+  /**
+   * Identity key (`"id:<partId>"`) from the group's first part; undefined
+   * when absent or already claimed by an earlier sibling.
+   */
+  readonly idKey: string | undefined;
   /** Indices of parts in this subtree, in order. */
   readonly indices: readonly number[];
   readonly children: readonly GroupNode[];
@@ -130,6 +135,11 @@ export interface GroupNodePart {
   readonly index: number;
   /** Structural React key: sibling-index path within parent. */
   readonly nodeKey: string;
+  /**
+   * Identity key (`"id:<partId>"`); undefined when absent or already
+   * claimed by an earlier sibling.
+   */
+  readonly idKey: string | undefined;
 }
 
 interface BuildFrame {
@@ -138,6 +148,7 @@ interface BuildFrame {
   indices: number[];
   children: GroupNode[];
   nextChildIdx: number;
+  claimed: Set<string>;
 }
 
 const makeChildNodeKey = (parent: BuildFrame): string => {
@@ -145,13 +156,25 @@ const makeChildNodeKey = (parent: BuildFrame): string => {
   return parent.nodeKey === "" ? String(idx) : `${parent.nodeKey}.${idx}`;
 };
 
+const claimIdKey = (
+  frame: BuildFrame,
+  id: string | undefined,
+): string | undefined => {
+  if (id === undefined || frame.claimed.has(id)) return undefined;
+  frame.claimed.add(id);
+  return `id:${id}`;
+};
+
 /**
  * Build the group tree from an array of normalized group paths.
  * `paths[i]` is the path for part `i`. The output tree contains one
  * `part` node per part and one `group` node per coalesced run.
+ * `partIds[i]` optionally carries a stable identity for part `i` (e.g. a
+ * tool call id), from which nodes derive an `idKey`.
  */
 export const buildGroupTree = (
   paths: readonly (readonly string[])[],
+  partIds?: readonly (string | undefined)[],
 ): readonly GroupNode[] => {
   const root: BuildFrame = {
     key: "",
@@ -159,6 +182,7 @@ export const buildGroupTree = (
     indices: [],
     children: [],
     nextChildIdx: 0,
+    claimed: new Set(),
   };
   const stack: BuildFrame[] = [root];
 
@@ -169,6 +193,7 @@ export const buildGroupTree = (
       type: "group",
       key: closing.key,
       nodeKey: closing.nodeKey,
+      idKey: claimIdKey(parent, partIds?.[closing.indices[0]!]),
       indices: closing.indices,
       children: closing.children,
     });
@@ -202,6 +227,7 @@ export const buildGroupTree = (
         indices: [],
         children: [],
         nextChildIdx: 0,
+        claimed: new Set(),
       });
     }
 
@@ -211,6 +237,7 @@ export const buildGroupTree = (
       type: "part",
       index: i,
       nodeKey: makeChildNodeKey(top),
+      idKey: claimIdKey(top, partIds?.[i]),
     });
 
     // Record the part index in every open ancestor group.

package/src/runtime/api/bindings.ts

@@ -42,5 +42,6 @@ export type ThreadListItemState = {
   readonly externalId: string | undefined;
   readonly status: import("../interfaces/thread-list-runtime-core").ThreadListItemStatus;
   readonly title?: string | undefined;
+  readonly lastMessageAt?: Date | undefined;
   readonly custom?: Record<string, unknown> | undefined;
 };

package/src/runtime/api/message-runtime.ts

@@ -101,6 +101,7 @@ export type MessageRuntime = {
   readonly composer: EditComposerRuntime;
 
   getState(): MessageState;
+  delete(): void | Promise<void>;
   reload(config?: ReloadConfig): void;
   /**
    * @deprecated This API is still under active development and might change without notice.
@@ -155,6 +156,7 @@ export class MessageRuntimeImpl implements MessageRuntime {
 
   protected __internal_bindMethods() {
     this.reload = this.reload.bind(this);
+    this.delete = this.delete.bind(this);
     this.getState = this.getState.bind(this);
     this.subscribe = this.subscribe.bind(this);
     this.getMessagePartByIndex = this.getMessagePartByIndex.bind(this);
@@ -180,6 +182,11 @@ export class MessageRuntimeImpl implements MessageRuntime {
     return this._core.getState();
   }
 
+  public delete() {
+    const state = this._core.getState();
+    return this._threadBinding.getState().deleteMessage(state.id);
+  }
+
   public reload(reloadConfig: ReloadConfig = {}) {
     const editComposerRuntimeCore = this._getEditComposerRuntimeCore();
     const composerRuntimeCore =

package/src/runtime/api/thread-list-runtime.ts

@@ -88,6 +88,7 @@ const getThreadListItemState = (
     externalId: threadData.externalId,
     title: threadData.title,
     status: threadData.status,
+    lastMessageAt: threadData.lastMessageAt,
     custom: threadData.custom,
     isMain: threadData.id === threadList.mainThreadId,
   };

package/src/runtime/api/thread-runtime.ts

@@ -252,6 +252,8 @@ export type ThreadRuntime = {
    */
   append(message: CreateAppendMessage): void;
 
+  deleteMessage(messageId: string): void | Promise<void>;
+
   /**
    * Start a new run with the given configuration.
    * @param config The configuration for starting the run
@@ -374,6 +376,7 @@ export class ThreadRuntimeImpl implements ThreadRuntime {
 
   protected __internal_bindMethods() {
     this.append = this.append.bind(this);
+    this.deleteMessage = this.deleteMessage.bind(this);
     this.resumeRun = this.resumeRun.bind(this);
     this.importExternalState = this.importExternalState.bind(this);
     this.exportExternalState = this.exportExternalState.bind(this);
@@ -411,6 +414,10 @@ export class ThreadRuntimeImpl implements ThreadRuntime {
       );
   }
 
+  public deleteMessage(messageId: string) {
+    return this._threadBinding.getState().deleteMessage(messageId);
+  }
+
   public subscribe(callback: () => void) {
     return this._threadBinding.subscribe(callback);
   }

package/src/runtime/base/base-thread-runtime-core.ts

@@ -56,6 +56,7 @@ export abstract class BaseThreadRuntimeCore implements ThreadRuntimeCore {
 
   public abstract get capabilities(): RuntimeCapabilities;
   public abstract append(message: AppendMessage): void;
+  public abstract deleteMessage(messageId: string): void | Promise<void>;
   public abstract startRun(config: StartRunConfig): void;
   public abstract resumeRun(config: ResumeRunConfig): void;
   public abstract addToolResult(options: AddToolResultOptions): void;

package/src/runtime/branch/external-thread-branch-adapter.ts

@@ -0,0 +1,26 @@
+/**
+ * The branch surface a runtime exposes so the branch picker can navigate
+ * between sibling variants of a message. Read during render; recreate the
+ * adapter object when branch data changes.
+ *
+ * Editing a message creates a branch only if the `onEdit` handler creates a
+ * sibling and `getBranches` reports it. Note that `ExternalThread`'s edit
+ * payload carries the edited message's own id as both `parentId` and
+ * `sourceId`.
+ */
+export type ExternalThreadBranchAdapter = {
+  /**
+   * Returns the sibling branch ids for a message in display order, including
+   * the message's own id. Return an empty array for messages without
+   * alternative branches.
+   */
+  getBranches: (messageId: string) => readonly string[];
+  /**
+   * Makes the given branch the visible one. The runtime is expected to swap
+   * the `messages` array to the selected branch. May be invoked
+   * programmatically while a run is in progress; pending queue items are not
+   * cleared, and reconciling them with the new branch is the runtime's
+   * responsibility.
+   */
+  switchToBranch: (branchId: string) => void;
+};

package/src/runtime/interfaces/thread-list-runtime-core.ts

@@ -10,6 +10,7 @@ export type ThreadListItemCoreState = {
 
   readonly status: ThreadListItemStatus;
   readonly title?: string | undefined;
+  readonly lastMessageAt?: Date | undefined;
   readonly custom?: Record<string, unknown> | undefined;
 
   readonly runtime?: ThreadRuntimeCore | undefined;

package/src/runtime/interfaces/thread-runtime-core.ts

@@ -23,6 +23,7 @@ export type RuntimeCapabilities = {
   readonly switchBranchDuringRun: boolean;
   readonly edit: boolean;
   readonly reload: boolean;
+  readonly delete: boolean;
   readonly cancel: boolean;
   readonly unstable_copy: boolean;
   readonly speech: boolean;
@@ -146,6 +147,7 @@ export type ThreadRuntimeCore = Readonly<{
   switchToBranch: (branchId: string) => void;
 
   append: (message: AppendMessage) => void;
+  deleteMessage: (messageId: string) => void | Promise<void>;
   startRun: (config: StartRunConfig) => void;
   resumeRun: (config: ResumeRunConfig) => void;
   cancelRun: () => void;

package/src/runtimes/external-store/external-store-adapter.ts

@@ -109,6 +109,7 @@ type ExternalStoreAdapterBase<T> = {
   /** Opt in to message queuing. Typically produced by `createMessageQueue`. */
   queue?: ExternalThreadQueueAdapter | undefined;
   onEdit?: ((message: AppendMessage) => Promise<void>) | undefined;
+  onDelete?: ((messageId: string) => Promise<void> | void) | undefined;
   onReload?: // TODO: remove parentId in 0.12.0
     | ((parentId: string | null, config: StartRunConfig) => Promise<void>)
     | undefined;

package/src/runtimes/external-store/external-store-thread-runtime-core.ts

@@ -60,6 +60,7 @@ export class ExternalStoreThreadRuntimeCore
     switchToBranch: false,
     switchBranchDuringRun: false,
     edit: false,
+    delete: false,
     reload: false,
     cancel: false,
     unstable_copy: false,
@@ -148,6 +149,9 @@ export class ExternalStoreThreadRuntimeCore
       switchToBranch: this._store.setMessages !== undefined,
       switchBranchDuringRun: false,
       edit: this._store.onEdit !== undefined,
+      delete:
+        this._store.onDelete !== undefined ||
+        this._store.setMessages !== undefined,
       reload: this._store.onReload !== undefined,
       cancel: this._store.onCancel !== undefined,
       speech: this._store.adapters?.speech !== undefined,
@@ -419,6 +423,26 @@ export class ExternalStoreThreadRuntimeCore
     }
   }
 
+  public async deleteMessage(messageId: string): Promise<void> {
+    if (this._store.onDelete) {
+      await this._store.onDelete(messageId);
+      return;
+    }
+
+    if (!this._store.setMessages)
+      throw new Error("Runtime does not support deleting messages.");
+
+    if (this._store.isRunning) {
+      await this._toolInvocations?.abort();
+    }
+
+    const messages = this.repository.getMessages();
+    const messageIndex = messages.findIndex((m) => m.id === messageId);
+    if (messageIndex === -1) throw new Error("Message not found.");
+
+    this.updateMessages(messages.filter((message) => message.id !== messageId));
+  }
+
   public getQueueItems() {
     // The composer reads this during base-thread construction, before the
     // constructor assigns `_store`, so guard against the unset field.

package/src/runtimes/local/local-runtime-options.ts

@@ -23,7 +23,7 @@ export type LocalRuntimeOptionsBase = {
   };
 
   /**
-   * Names of tools that are allowed to interrupt the run in order to wait for human/external approval.
+   * Names of tools that pause the run until a result is supplied via `addToolResult`.
    */
   unstable_humanToolNames?: string[] | undefined;