@assistant-ui/core 0.2.6 → 0.2.8

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

@@ -11,6 +11,7 @@ import type {
 import {
   buildGroupTree,
   GROUPBY_MEMO_KEY,
+  type GroupByContext,
   type GroupNode,
 } from "../../utils/groupParts";
 import { MessagePartChildren, type EnrichedPartState } from "./MessageParts";
@@ -28,13 +29,40 @@ export namespace MessagePrimitiveGroupedParts {
     readonly indices: readonly number[];
   };
 
+  /**
+   * Synthetic trailing slot for a streaming/loading affordance (a
+   * "thinking…" dot, etc.). Surfaced through the same `{ part }` channel
+   * as groups and leaf parts so a single `switch (part.type)` renders it
+   * via `case "indicator"`.
+   *
+   * It is only ever emitted while the message is running, so its presence
+   * alone means "render your loading UI here" — there's no `status` to
+   * branch on.
+   */
+  export type IndicatorPart = {
+    readonly type: "indicator";
+  };
+
+  /**
+   * When to emit the synthetic {@link IndicatorPart}. It is **only** emitted
+   * while the message is running (streaming); the mode further restricts
+   * 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).
+   * - `"always"` — whenever the message is running, regardless of parts.
+   */
+  export type IndicatorMode = "never" | "empty" | "no-text" | "always";
+
   export type RenderInfo<TKey extends `group-${string}` = `group-${string}`> = {
     /**
      * Either a coalesced group ({@link GroupPart}, identified by a
-     * `group-…` `type`) or a single enriched part. Use one switch over
-     * `part.type` to handle both.
+     * `group-…` `type`), a single enriched leaf part, or the synthetic
+     * {@link IndicatorPart} (`type: "indicator"`). Use one switch over
+     * `part.type` to handle all three.
      */
-    readonly part: GroupPart<TKey> | EnrichedPartState;
+    readonly part: GroupPart<TKey> | EnrichedPartState | IndicatorPart;
     /**
      * For group nodes: the recursively-rendered subtree (subgroups +
      * leaf parts). For leaf parts: a sentinel that throws when rendered
@@ -59,6 +87,9 @@ export namespace MessagePrimitiveGroupedParts {
      * the helper isn't expressive enough (e.g. branching on
      * `part.toolName` or part metadata).
      *
+     * The second argument is a {@link GroupByContext} carrying the tool-UI
+     * registry, for grouping that depends on it (e.g. standalone tool calls).
+     *
      * @example
      * ```tsx
      * import { groupPartByType } from "@assistant-ui/react";
@@ -71,12 +102,27 @@ export namespace MessagePrimitiveGroupedParts {
      * >
      * ```
      */
-    readonly groupBy: (part: PartState) => readonly TKey[] | null;
+    readonly groupBy: (
+      part: PartState,
+      context: GroupByContext,
+    ) => readonly TKey[] | null;
 
     /**
-     * Render function called once per group node and once per leaf part.
-     * Switch on `part.type`: `"group-…"` cases wrap `children`; real
-     * part types (`"text"`, `"tool-call"`, …) render the part directly.
+     * Controls emission of the synthetic {@link IndicatorPart} — a
+     * trailing `{ part: { type: "indicator", status } }` render call you
+     * handle with `case "indicator"` to show loading/status UI.
+     *
+     * @default "no-text"
+     * @see IndicatorMode
+     */
+    readonly indicator?: IndicatorMode;
+
+    /**
+     * Render function called once per group node, once per leaf part, and
+     * (when the `indicator` condition is met) once for the trailing
+     * {@link IndicatorPart}. Switch on `part.type`: `"group-…"` cases wrap
+     * `children`; real part types (`"text"`, `"tool-call"`, …) render the
+     * part directly; `"indicator"` renders status/loading UI.
      *
      * Leaf parts receive the same {@link EnrichedPartState} that
      * `<MessagePrimitive.Parts>` would produce (`toolUI`, `addResult`,
@@ -88,6 +134,31 @@ export namespace MessagePrimitiveGroupedParts {
 
 const COMPLETE_STATUS: MessagePartStatus = Object.freeze({ type: "complete" });
 
+const shouldShowIndicator = (
+  mode: MessagePrimitiveGroupedParts.IndicatorMode,
+  parts: readonly PartState[],
+  isRunning: boolean,
+): boolean => {
+  // The indicator is a streaming affordance — never show it on a settled
+  // message, whatever the mode.
+  if (!isRunning) return false;
+
+  switch (mode) {
+    case "never":
+      return false;
+    case "always":
+      return true;
+    case "empty":
+      return parts.length === 0;
+    case "no-text": {
+      const last = parts[parts.length - 1];
+      return (
+        last !== undefined && last.type !== "text" && last.type !== "reasoning"
+      );
+    }
+  }
+};
+
 /**
  * `children` placeholder passed for leaf-part renders. Leaf parts have no
  * inner subtree; rendering this sentinel signals the consumer wrote
@@ -161,6 +232,7 @@ const renderNode = <TKey extends `group-${string}`>(
  *       case "group-tool":      return <ToolStack>{children}</ToolStack>;
  *       case "text":            return <MarkdownText />;
  *       case "tool-call":       return part.toolUI ?? <ToolFallback {...part} />;
+ *       case "indicator":       return <LoadingDots />;
  *       default:                return null;
  *     }
  *   }}
@@ -169,9 +241,17 @@ const renderNode = <TKey extends `group-${string}`>(
  */
 export const MessagePrimitiveGroupedParts = <TKey extends `group-${string}`>({
   groupBy,
+  indicator = "no-text",
   children,
 }: MessagePrimitiveGroupedParts.Props<TKey>): ReactNode => {
   const parts = useAuiState(useShallow((s) => s.message.parts));
+  // Handed to `groupBy` as its `context` argument (see GroupByContext).
+  const toolUIs = useAuiState((s) => s.tools.toolUIs);
+  // Subscribe to a boolean, not the status object: the tree only needs to
+  // re-render when running-ness flips, and `"never"` opts out entirely.
+  const isRunning = useAuiState((s) =>
+    indicator === "never" ? false : s.message.status?.type === "running",
+  );
 
   // Helpers like `groupPartByType` tag the function with `GROUPBY_MEMO_KEY`
   // (a stable string fingerprint of the helper config). When present,
@@ -182,13 +262,22 @@ export const MessagePrimitiveGroupedParts = <TKey extends `group-${string}`>({
     GROUPBY_MEMO_KEY
   ];
   const memoDep = memoKey ?? groupBy;
-  // biome-ignore lint/correctness/useExhaustiveDependencies: groupBy is captured via memoDep — either as its identity (no memoKey) or as the helper's memoKey fingerprint. Listing groupBy directly would defeat the helper-tagged memo path.
-  const tree = useMemo(
-    () => buildGroupTree(parts.map((part) => groupBy(part) ?? [])),
-    [parts, memoDep],
-  );
+  const tree = useMemo(() => {
+    const context: GroupByContext = { toolUIs };
+    return buildGroupTree(parts.map((part) => groupBy(part, context) ?? []));
+    // oxlint-disable-next-line tap-hooks/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]);
 
-  return <>{tree.map((node) => renderNode(node, parts, children))}</>;
+  return (
+    <>
+      {tree.map((node) => renderNode(node, parts, children))}
+      {shouldShowIndicator(indicator, parts, isRunning) &&
+        children({
+          part: { type: "indicator" },
+          children: <PartChildrenSentinel />,
+        })}
+    </>
+  );
 };
 
 MessagePrimitiveGroupedParts.displayName = "MessagePrimitive.GroupedParts";

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

@@ -308,11 +308,9 @@ const ToolUIDisplay = ({
 }: {
   Fallback: ToolCallMessagePartComponent | undefined;
 } & ToolCallMessagePartProps) => {
-  const Render = useAuiState((s) => {
-    const Render = s.tools.tools[props.toolName] ?? Fallback;
-    if (Array.isArray(Render)) return Render[0] ?? Fallback;
-    return Render;
-  });
+  const Render = useAuiState(
+    (s) => s.tools.toolUIs[props.toolName]?.[0]?.render ?? Fallback,
+  );
   if (!Render) return null;
   return <Render {...props} />;
 };
@@ -574,8 +572,7 @@ function resolveToolRender(
   toolsState: ToolsState,
   part: Extract<PartState, { type: "tool-call" }>,
 ): ToolCallMessagePartComponent | null {
-  const entry = toolsState.tools[part.toolName];
-  const named = Array.isArray(entry) ? (entry[0] ?? null) : (entry ?? null);
+  const named = toolsState.toolUIs[part.toolName]?.[0]?.render ?? null;
   if (named) return named;
   if (isMcpAppUri(part.mcp?.app?.resourceUri) && toolsState.mcpApp) {
     return toolsState.mcpApp.render;

package/src/react/runtimes/RemoteThreadListThreadListRuntimeCore.tsx

@@ -62,7 +62,6 @@ export class RemoteThreadListThreadListRuntimeCore
               isLoading: true,
             };
           },
-          // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
           then: (state, l) => {
             if (generation !== this._loadGeneration) return state;
             const fresh = classifyThreads(l.threads, {
@@ -120,7 +119,6 @@ export class RemoteThreadListThreadListRuntimeCore
       .optimisticUpdate({
         execute: () => adapter.list({ after: cursor }),
         loading: (state) => ({ ...state, isLoadingMore: true }),
-        // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
         then: (state, l) => {
           if (generation !== this._loadGeneration) return state;
           if (adapter !== this._options.adapter) return state;
@@ -423,7 +421,6 @@ 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,10 @@
-import { createContext, type FC, type ReactNode, useContext } from "react";
+import {
+  createContext,
+  type FC,
+  type ReactNode,
+  useContext,
+  useMemo,
+} from "react";
 import type { ThreadHistoryAdapter } from "../../adapters/thread-history";
 import type { AttachmentAdapter } from "../../adapters/attachment";
 import type { ModelContextProvider } from "../../model-context/types";
@@ -23,13 +29,12 @@ export const RuntimeAdapterProvider: FC<RuntimeAdapterProvider.Props> = ({
   children,
 }) => {
   const context = useContext(RuntimeAdaptersContext);
+  const value = useMemo(
+    () => ({ ...context, ...adapters }),
+    [context, adapters],
+  );
   return (
-    <RuntimeAdaptersContext.Provider
-      value={{
-        ...context,
-        ...adapters,
-      }}
-    >
+    <RuntimeAdaptersContext.Provider value={value}>
       {children}
     </RuntimeAdaptersContext.Provider>
   );

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

@@ -43,20 +43,17 @@ export const useCloudThreadListAdapter = (
 
   const unstable_Provider = useCallback<FC<PropsWithChildren>>(
     function Provider({ children }) {
-      // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
       const history = useAssistantCloudThreadHistoryAdapter({
         get current() {
           return adapterRef.current.cloud ?? autoCloud!;
         },
       });
       const cloudInstance = adapterRef.current.cloud ?? autoCloud!;
-      // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
       const attachments = useMemo(
         () => new CloudFileAttachmentAdapter(cloudInstance),
         [cloudInstance],
       );
 
-      // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
       const adapters = useMemo(
         () => ({
           history,

package/src/react/runtimes/external-message-converter.ts

@@ -12,7 +12,7 @@ import {
   type ThreadMessageLike,
 } from "../../runtime/utils/thread-message-like";
 import { getAutoStatus, isAutoStatus } from "../../runtime/utils/auto-status";
-import type { ToolExecutionStatus } from "./useToolInvocations";
+import type { ToolExecutionStatus } from "../../runtimes/tool-invocations/ToolInvocationTracker";
 import type { ReadonlyJSONValue } from "assistant-stream/utils";
 import { generateErrorMessageId } from "../../utils/id";
 import type {
@@ -198,6 +198,10 @@ const joinExternalMessages = (
                 assistantMessage.metadata.submittedFeedback =
                   output.metadata.submittedFeedback;
               }
+
+              if (output.metadata.isOptimistic) {
+                assistantMessage.metadata.isOptimistic = true;
+              }
             }
             // TODO keep this in sync
           }

package/src/react/runtimes/useExternalStoreSharedOptions.ts

@@ -0,0 +1,23 @@
+"use client";
+
+import { useMemo } from "react";
+import type { ExternalStoreSharedOptions } from "../../runtimes/external-store/external-store-shared-options";
+
+export const useExternalStoreSharedOptions = (
+  options: ExternalStoreSharedOptions,
+): ExternalStoreSharedOptions => {
+  const { isDisabled, isSendDisabled, unstable_capabilities, suggestions } =
+    options;
+  return useMemo(
+    () =>
+      ({
+        isDisabled,
+        isSendDisabled,
+        unstable_capabilities,
+        suggestions,
+      }) satisfies {
+        [K in keyof Required<ExternalStoreSharedOptions>]: ExternalStoreSharedOptions[K];
+      },
+    [isDisabled, isSendDisabled, unstable_capabilities, suggestions],
+  );
+};

package/src/react/runtimes/useLocalRuntime.ts

@@ -22,7 +22,6 @@ const useLocalThreadRuntime = (
   chatModel: ChatModelAdapter,
   { initialMessages, ...options }: LocalRuntimeOptions,
 ): AssistantRuntime => {
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   const { modelContext, ...threadListAdapters } = useRuntimeAdapters() ?? {};
   const opt = {
     ...options,
@@ -33,41 +32,33 @@ const useLocalThreadRuntime = (
     },
   };
 
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   const [runtime] = useState(() => new LocalRuntimeCore(opt, initialMessages));
 
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   const threadIdRef = useRef<string | undefined>(undefined);
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   threadIdRef.current = useAuiState((s) => s.threadListItem.remoteId);
 
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   useEffect(() => {
     runtime.threads
       .getMainThreadRuntimeCore()
       .__internal_setGetThreadId(() => threadIdRef.current);
   }, [runtime]);
 
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   useEffect(() => {
     return () => {
       runtime.threads.getMainThreadRuntimeCore().detach();
     };
   }, [runtime]);
 
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   useEffect(() => {
     runtime.threads.getMainThreadRuntimeCore().__internal_setOptions(opt);
     runtime.threads.getMainThreadRuntimeCore().__internal_load();
   });
 
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   useEffect(() => {
     if (!modelContext) return undefined;
     return runtime.registerModelContextProvider(modelContext);
   }, [modelContext, runtime]);
 
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   return useMemo(() => new AssistantRuntimeImpl(runtime), [runtime]);
 };
 
@@ -102,7 +93,6 @@ export const useLocalRuntime = (
   const cloudAdapter = useCloudThreadListAdapter({ cloud });
   return useRemoteThreadListRuntime({
     runtimeHook: function RuntimeHook() {
-      // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
       return useLocalThreadRuntime(chatModel, options);
     },
     adapter: cloudAdapter,

package/src/react/runtimes/useRemoteThreadListRuntime.ts

@@ -29,15 +29,12 @@ class RemoteThreadListRuntimeCore
 const useRemoteThreadListRuntimeImpl = (
   options: RemoteThreadListOptions,
 ): AssistantRuntime => {
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   const [runtime] = useState(() => new RemoteThreadListRuntimeCore(options));
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   useEffect(() => {
     runtime.threads.__internal_setOptions(options);
     runtime.threads.__internal_load();
   }, [runtime, options]);
 
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   return useMemo(() => new AssistantRuntimeImpl(runtime), [runtime]);
 };
 
@@ -80,12 +77,9 @@ export const useRemoteThreadListRuntime = (
     return stableRuntimeHook();
   }
 
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   const runtime = useRemoteThreadListRuntimeImpl(stableOptions);
 
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   const prevThreadIdRef = useRef(options.threadId);
-  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
   useEffect(() => {
     if (options.threadId === prevThreadIdRef.current) return;
     prevThreadIdRef.current = options.threadId;

package/src/react/types/scopes/tools.ts

@@ -5,9 +5,27 @@ export type McpAppResourceOutput = {
   readonly render: ToolCallMessagePartComponent;
 };
 
+/**
+ * A single tool-UI registration: the renderer plus its presentation options.
+ * Stored as a per-tool-name list so the name stays registered while any
+ * registration of it is mounted.
+ */
+type ToolRegistration = {
+  readonly render: ToolCallMessagePartComponent;
+  /** Whether this UI renders standalone, outside the chain-of-thought trace. */
+  readonly standalone: boolean;
+};
+
 export type ToolsState = {
-  tools: Record<string, ToolCallMessagePartComponent[]>;
+  /** Registered tool UIs (renderer + presentation options) keyed by tool name. */
+  toolUIs: Record<string, readonly ToolRegistration[]>;
   mcpApp?: McpAppResourceOutput | undefined;
+  /**
+   * @deprecated Use {@link toolUIs} instead, whose entries carry the renderer
+   * alongside its presentation options. This component-only map is kept for
+   * back-compat and will be removed in v0.15.
+   */
+  tools: Record<string, ToolCallMessagePartComponent[]>;
 };
 
 export type ToolsMethods = {
@@ -15,6 +33,7 @@ export type ToolsMethods = {
   setToolUI(
     toolName: string,
     render: ToolCallMessagePartComponent,
+    options?: { standalone?: boolean },
   ): Unsubscribe;
 };
 

package/src/react/utils/groupParts.ts

@@ -1,5 +1,17 @@
 import { isMcpAppUri } from "../../types/message";
 import type { PartState } from "../../store/scopes/part";
+import type { ToolsState } from "../types/scopes/tools";
+
+/**
+ * Registry context passed to a `groupBy` function as its second argument by
+ * `<MessagePrimitive.GroupedParts>`. Carries the live tool-UI registry so a
+ * `groupBy` can resolve registry-driven grouping (e.g. standalone tool calls)
+ * without the part itself having to carry that information.
+ */
+export type GroupByContext = {
+  /** Tool UIs registered in the tool-UI registry, keyed by tool name. */
+  readonly toolUIs?: ToolsState["toolUIs"];
+};
 
 /**
  * Hierarchical adjacent-coalescing grouping for message parts.
@@ -25,12 +37,20 @@ export const GROUPBY_MEMO_KEY: unique symbol = Symbol.for(
 );
 
 /**
- * Synthetic part-type key recognized by {@link groupPartByType}: a
- * tool-call whose `mcp.app.resourceUri` points at an assistant-ui MCP
- * app. Map this key to control how MCP-app tool calls are grouped —
- * separately from regular `"tool-call"` parts.
+ * Synthetic part-type keys recognized by {@link groupPartByType}, in
+ * addition to real {@link PartState} types:
+ *
+ * - `"standalone-tool-call"` — a tool-call whose UI should be presented on its
+ *   own, outside the chain-of-thought grouping. Matches MCP-app tool calls plus
+ *   any tool-call whose registered UI opts into standalone display (human
+ *   tools, the built-in generative-UI tool, and tools that set
+ *   `display: "standalone"`). Resolving the registry-driven cases reads the
+ *   {@link GroupByContext} passed to the `groupBy` function. Takes precedence
+ *   over the `"tool-call"` entry.
+ * - `"mcp-app"` — **deprecated**, kept for back-compat. Matches only MCP-app
+ *   tool calls. Prefer `"standalone-tool-call"`, which is a superset.
  */
-type GroupPartType = PartState["type"] | "mcp-app";
+type GroupPartType = PartState["type"] | "standalone-tool-call" | "mcp-app";
 
 /**
  * Build a `groupBy` from a `part.type → group-key path` lookup.
@@ -38,9 +58,12 @@ type GroupPartType = PartState["type"] | "mcp-app";
  * function carries a stable {@link GROUPBY_MEMO_KEY} fingerprint so
  * `<MessagePrimitive.GroupedParts>` can memoize its tree across renders.
  *
- * Special key `"mcp-app"` matches tool-call parts that point at an
- * assistant-ui MCP app resource (`ui://...`) and takes precedence over
- * the `"tool-call"` entry for those parts.
+ * The synthetic `"standalone-tool-call"` key matches tool calls that should
+ * render outside the chain-of-thought grouping. MCP-app calls are detected from
+ * the part alone; the registry-driven cases (human tools, the generative-UI
+ * tool, `display: "standalone"` opt-ins) are resolved from the
+ * {@link GroupByContext} that `<MessagePrimitive.GroupedParts>` passes to the
+ * `groupBy` function — the helper needs nothing threaded into it.
  *
  * @example
  * ```tsx
@@ -48,7 +71,7 @@ type GroupPartType = PartState["type"] | "mcp-app";
  *   groupBy={groupPartByType({
  *     reasoning: ["group-thought", "group-reasoning"],
  *     "tool-call": ["group-thought", "group-tool"],
- *     "mcp-app": [],
+ *     "standalone-tool-call": [],
  *   })}
  * >
  *   {({ part, children }) => { ... }}
@@ -57,18 +80,26 @@ type GroupPartType = PartState["type"] | "mcp-app";
  */
 export const groupPartByType = <TKey extends `group-${string}`>(
   map: Partial<Readonly<Record<GroupPartType, readonly TKey[]>>>,
-): ((part: PartState) => readonly TKey[]) => {
+): ((part: PartState, context?: GroupByContext) => readonly TKey[]) => {
   const lookup = map as Readonly<Record<string, readonly TKey[] | undefined>>;
-  const fn = ((part) => {
-    if (
-      part.type === "tool-call" &&
-      lookup["mcp-app"] !== undefined &&
-      isMcpAppUri(part.mcp?.app?.resourceUri)
-    ) {
-      return lookup["mcp-app"]!;
+  const fn = ((part, context) => {
+    if (part.type === "tool-call") {
+      const isMcpApp = isMcpAppUri(part.mcp?.app?.resourceUri);
+      // Read the first registration's flag — the same one `resolveToolRender`
+      // renders — so grouping and rendering never disagree for a tool name.
+      const isStandalone =
+        isMcpApp ||
+        (context?.toolUIs?.[part.toolName]?.[0]?.standalone ?? false);
+      if (isStandalone && lookup["standalone-tool-call"] !== undefined) {
+        return lookup["standalone-tool-call"]!;
+      }
+      // TODO(v0.15): drop the deprecated "mcp-app" key (superseded by "standalone-tool-call").
+      if (isMcpApp && lookup["mcp-app"] !== undefined) {
+        return lookup["mcp-app"]!;
+      }
     }
     return lookup[part.type] ?? [];
-  }) as ((part: PartState) => readonly TKey[]) & {
+  }) as ((part: PartState, context?: GroupByContext) => readonly TKey[]) & {
     [GROUPBY_MEMO_KEY]?: string;
   };
   // Sort keys so the fingerprint is insensitive to map insertion order —

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

@@ -42,8 +42,7 @@ export type AttachmentRuntime<
 
 export abstract class AttachmentRuntimeImpl<
   Source extends AttachmentRuntimeSource = AttachmentRuntimeSource,
-> implements AttachmentRuntime
-{
+> implements AttachmentRuntime {
   public get path() {
     return this._core.path;
   }

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

@@ -1,3 +1,4 @@
+import type { ToolModelContentPart } from "assistant-stream";
 import type { ReadonlyJSONValue } from "assistant-stream/utils";
 import type { ModelContext } from "../../model-context/types";
 import type { Unsubscribe } from "../../types/unsubscribe";
@@ -38,6 +39,13 @@ export type AddToolResultOptions = {
   result: ReadonlyJSONValue;
   isError: boolean;
   artifact?: ReadonlyJSONValue | undefined;
+  /**
+   * Optional model-content payload produced by the tool. Populated when a
+   * client-side `execute()` or `streamCall` returns a `ToolResponse` with
+   * `modelContent`. Forwarded through `adapter.onAddToolResult` so the
+   * adapter can include it when sending the result back to its backend.
+   */
+  modelContent?: readonly ToolModelContentPart[] | undefined;
 };
 
 export type ResumeToolCallOptions = {

package/src/runtime/internal.ts

@@ -18,10 +18,7 @@ export { DefaultEditComposerRuntimeCore } from "./base/default-edit-composer-run
 // Runtime Impl Classes
 export { AssistantRuntimeImpl } from "./api/assistant-runtime";
 
-export {
-  getThreadState,
-  ThreadRuntimeImpl,
-} from "./api/thread-runtime";
+export { getThreadState, ThreadRuntimeImpl } from "./api/thread-runtime";
 export type {
   ThreadRuntimeCoreBinding,
   ThreadListItemRuntimeBinding,