@assistant-ui/core 0.2.12 → 0.2.15

package/src/react/client/Tools.ts

@@ -30,7 +30,7 @@ export type { McpAppResourceOutput };
  * context, while each tool renderer is registered with the tools scope for
  * message rendering.
  */
-export const Tools = resource(function Tools({
+const useTools = ({
   toolkit,
   mcpApp,
 }: {
@@ -38,11 +38,8 @@ export const Tools = resource(function Tools({
   toolkit?: Toolkit;
   /** Optional MCP app resource whose tools should be merged into context. */
   mcpApp?: ResourceElement<McpAppResourceOutput> | undefined;
-}): ClientOutput<"tools"> {
-  const mcpAppOutputs = useResources(
-    () => (mcpApp ? [withKey("mcpApp", mcpApp)] : []),
-    [mcpApp],
-  );
+}): ClientOutput<"tools"> => {
+  const mcpAppOutputs = useResources(mcpApp ? [withKey("mcpApp", mcpApp)] : []);
   const mcpAppOutput = mcpAppOutputs[0];
 
   const [toolUIs, setToolUIs] = useState<ToolsState["toolUIs"]>(() => ({}));
@@ -88,7 +85,8 @@ export const Tools = resource(function Tools({
           if (next.length > 0) return { ...prev, [toolName]: next };
           // Drop the key entirely so repeatedly mounted/unmounted tools
           // don't leave empty arrays accumulating across a long session.
-          const { [toolName]: _removed, ...rest } = prev;
+          const rest = { ...prev };
+          delete rest[toolName];
           return rest;
         });
       };
@@ -155,9 +153,11 @@ export const Tools = resource(function Tools({
     getState: () => state,
     setToolUI,
   };
-});
+};
+
+export const Tools = resource(useTools);
 
-attachTransformScopes(Tools, (scopes, parent) => {
+attachTransformScopes(useTools, (scopes, parent) => {
   if (!scopes.modelContext && parent.modelContext.source === null) {
     scopes.modelContext = ModelContext();
   }

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

@@ -49,8 +49,9 @@ export namespace MessagePrimitiveGroupedParts {
    * which running states qualify:
    * - `"never"` — never.
    * - `"empty"` — only when the message has no parts yet.
-   * - `"no-text"` (default) — when the last part isn't `text`/`reasoning`
-   *   (e.g. it ended on a tool call, so the assistant likely isn't done).
+   * - `"no-text"` (default) — when the message has no parts yet or the last
+   *   part isn't `text`/`reasoning` (e.g. it ended on a tool call, so the
+   *   assistant likely isn't done).
    * - `"always"` — whenever the message is running, regardless of parts.
    */
   export type IndicatorMode = "never" | "empty" | "no-text" | "always";
@@ -153,7 +154,8 @@ const shouldShowIndicator = (
     case "no-text": {
       const last = parts[parts.length - 1];
       return (
-        last !== undefined && last.type !== "text" && last.type !== "reasoning"
+        last === undefined ||
+        (last.type !== "text" && last.type !== "reasoning")
       );
     }
   }
@@ -179,9 +181,14 @@ const renderNode = <TKey extends `group-${string}`>(
   render: (info: MessagePrimitiveGroupedParts.RenderInfo<TKey>) => ReactNode,
 ): ReactNode => {
   if (node.type === "part") {
-    // Key by absolute part index, not structural nodeKey — prevents zombie fiber subscriptions when parts reshape (#4051).
+    // Key by part identity when available, else absolute part index — never
+    // the structural nodeKey, which leaves zombie fiber subscriptions when
+    // parts reshape (#4051).
     return (
-      <MessagePartChildren key={`part-${node.index}`} index={node.index}>
+      <MessagePartChildren
+        key={node.idKey ? `part-${node.idKey}` : `part-${node.index}`}
+        index={node.index}
+      >
         {({ part }) => render({ part, children: <PartChildrenSentinel /> })}
       </MessagePartChildren>
     );
@@ -195,7 +202,7 @@ const renderNode = <TKey extends `group-${string}`>(
   };
 
   return (
-    <Fragment key={node.nodeKey}>
+    <Fragment key={node.idKey ?? node.nodeKey}>
       {render({
         part: groupPart,
         children: (
@@ -264,7 +271,12 @@ export const MessagePrimitiveGroupedParts = <TKey extends `group-${string}`>({
   const memoDep = memoKey ?? groupBy;
   const tree = useMemo(() => {
     const context: GroupByContext = { toolUIs };
-    return buildGroupTree(parts.map((part) => groupBy(part, context) ?? []));
+    return buildGroupTree(
+      parts.map((part) => groupBy(part, context) ?? []),
+      parts.map((part) =>
+        part.type === "tool-call" ? part.toolCallId : undefined,
+      ),
+    );
     // oxlint-disable-next-line react/exhaustive-deps -- groupBy is captured via memoDep (either its identity or the helper's memoKey fingerprint); listing it directly would defeat the helper-tagged memo path
   }, [parts, memoDep, toolUIs]);
 

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/runtimes/external-message-converter.ts

@@ -36,7 +36,9 @@ const isInterruptedToolCall = (c: ThreadMessageLikeContentItem): boolean => {
   if (c.type !== "tool-call" || c.result !== undefined) return false;
   return (
     c.interrupt != null ||
-    (c.approval != null && c.approval.approved === undefined)
+    (c.approval != null &&
+      c.approval.approved === undefined &&
+      c.approval.resolution === undefined)
   );
 };
 

package/src/react/types/MessagePartComponentTypes.ts

@@ -9,6 +9,7 @@ import type {
   ReasoningMessagePart,
   SourceMessagePart,
   TextMessagePart,
+  ToolApprovalResponse,
   ToolCallMessagePart,
   Unstable_AudioMessagePart,
   QuoteInfo,
@@ -73,12 +74,11 @@ export type ToolCallMessagePartProps<
     resume: (payload: unknown) => void;
     /**
      * Responds to a server-side tool approval gate. Only valid while
-     * `approval` is set on the part and `approval.approved === undefined`.
+     * `approval` is set on the part, `approval.approved === undefined`, and
+     * no `approval.resolution` is recorded. Accepts a boolean decision or the
+     * id of one of `approval.options`; option kinds resolve to the boolean.
      */
-    respondToApproval: (response: {
-      approved: boolean;
-      reason?: string;
-    }) => void;
+    respondToApproval: (response: ToolApprovalResponse) => void;
   };
 
 /** Component used to render a tool-call message part. */

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-part-runtime.ts

@@ -1,8 +1,10 @@
 import type {
   ThreadAssistantMessagePart,
   ThreadUserMessagePart,
+  ToolApprovalResponse,
   ToolCallMessagePartStatus,
 } from "../../types/message";
+import { resolveToolApprovalResponse } from "../utils/resolveToolApprovalResponse";
 import type { Unsubscribe } from "../../types/unsubscribe";
 import type { MessagePartStatus } from "../../types/message";
 import type { SubscribableWithState } from "../../subscribable/subscribable";
@@ -26,7 +28,7 @@ type MessagePartSnapshotBinding = SubscribableWithState<
 export type MessagePartRuntime = {
   addToolResult(result: any | ToolResponse<any>): void;
   resumeToolCall(payload: unknown): void;
-  respondToToolApproval(response: { approved: boolean; reason?: string }): void;
+  respondToToolApproval(response: ToolApprovalResponse): void;
 
   readonly path: MessagePartRuntimePath;
   getState(): MessagePartState;
@@ -104,10 +106,7 @@ export class MessagePartRuntimeImpl implements MessagePartRuntime {
     });
   }
 
-  public respondToToolApproval(response: {
-    approved: boolean;
-    reason?: string;
-  }) {
+  public respondToToolApproval(response: ToolApprovalResponse) {
     const state = this.contentBinding.getState();
     if (!state) throw new Error("Message part is not available");
 
@@ -116,16 +115,20 @@ export class MessagePartRuntimeImpl implements MessagePartRuntime {
         "Tried to respond to tool approval on non-tool message part",
       );
 
-    if (!state.approval || state.approval.approved !== undefined)
+    if (
+      !state.approval ||
+      state.approval.approved !== undefined ||
+      state.approval.resolution !== undefined
+    )
       throw new Error("Tool call has no pending approval");
 
     if (!this.threadApi) throw new Error("Thread API is not available");
 
-    this.threadApi.getState().respondToToolApproval({
-      approvalId: state.approval.id,
-      approved: response.approved,
-      ...(response.reason != null && { reason: response.reason }),
-    });
+    this.threadApi
+      .getState()
+      .respondToToolApproval(
+        resolveToolApprovalResponse(state.approval, response),
+      );
   }
 
   public subscribe(callback: () => void) {

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;
@@ -57,6 +58,8 @@ export type ResumeToolCallOptions = {
 export type RespondToToolApprovalOptions = {
   approvalId: string;
   approved: boolean;
+  /** The approval option that produced this decision, when the request carried options. */
+  optionId?: string;
   reason?: string;
 };
 
@@ -146,6 +149,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;