@assistant-ui/core 0.3.19 → 0.3.21

package/dist/react/primitives/message/MessageAttachments.js.map

@@ -1 +1 @@
-{"version":3,"file":"MessageAttachments.js","names":["CompleteAttachment","ComponentType","FC","ReactNode","memo","useMemo","RenderChildrenWithAccessor","useAuiState","useShallowSelector","MessageAttachmentByIndexProvider","MessageAttachmentsComponentConfig","Image","Document","File","Attachment","MessagePrimitiveAttachments","Props","components","children","value","attachment","getComponent","type","AttachmentComponent","t0","$","_c","_temp","t1","t2","Component","t3","MessagePrimitiveAttachmentByIndex","index","prev","next","displayName","MessagePrimitiveAttachmentsInner","attachmentIds","s","message","role","attachments","map","id","attachmentId","aui","getState","getItem"],"sources":["../../../../src/react/primitives/message/MessageAttachments.tsx"],"sourcesContent":["import type { CompleteAttachment } from \"../../../types/attachment\";\nimport {\n  type ComponentType,\n  type FC,\n  type ReactNode,\n  memo,\n  useMemo,\n} from \"react\";\nimport { RenderChildrenWithAccessor, useAuiState } from \"@assistant-ui/store\";\nimport { useShallowSelector } from \"@assistant-ui/store/internal\";\nimport { MessageAttachmentByIndexProvider } from \"../../providers/AttachmentByIndexProvider\";\n\ntype MessageAttachmentsComponentConfig = {\n  Image?: ComponentType | undefined;\n  Document?: ComponentType | undefined;\n  File?: ComponentType | undefined;\n  Attachment?: ComponentType | undefined;\n};\n\nexport namespace MessagePrimitiveAttachments {\n  export type Props =\n    | {\n        /** @deprecated Use the children render function instead. */\n        components: MessageAttachmentsComponentConfig;\n        children?: never;\n      }\n    | {\n        /** Render function called for each attachment. Receives the attachment. */\n        children: (value: { attachment: CompleteAttachment }) => ReactNode;\n        components?: never;\n      };\n}\n\nconst getComponent = (\n  components: MessageAttachmentsComponentConfig | undefined,\n  attachment: CompleteAttachment,\n) => {\n  const type = attachment.type;\n  switch (type) {\n    case \"image\":\n      return components?.Image ?? components?.Attachment;\n    case \"document\":\n      return components?.Document ?? components?.Attachment;\n    case \"file\":\n      return components?.File ?? components?.Attachment;\n    default:\n      return components?.Attachment;\n  }\n};\n\nconst AttachmentComponent: FC<{\n  components: MessageAttachmentsComponentConfig | undefined;\n}> = ({ components }) => {\n  const attachment = useAuiState((s) => s.attachment);\n  if (!attachment) return null;\n\n  const Component = getComponent(components, attachment as CompleteAttachment);\n  if (!Component) return null;\n  return <Component />;\n};\n\nexport namespace MessagePrimitiveAttachmentByIndex {\n  export type Props = {\n    index: number;\n    components?: MessageAttachmentsComponentConfig;\n  };\n}\n\n/**\n * Renders a single attachment at the specified index within the current message.\n */\nexport const MessagePrimitiveAttachmentByIndex: FC<MessagePrimitiveAttachmentByIndex.Props> =\n  memo(\n    ({ index, components }) => {\n      return (\n        <MessageAttachmentByIndexProvider index={index}>\n          <AttachmentComponent components={components} />\n        </MessageAttachmentByIndexProvider>\n      );\n    },\n    (prev, next) =>\n      prev.index === next.index &&\n      prev.components?.Image === next.components?.Image &&\n      prev.components?.Document === next.components?.Document &&\n      prev.components?.File === next.components?.File &&\n      prev.components?.Attachment === next.components?.Attachment,\n  );\n\nMessagePrimitiveAttachmentByIndex.displayName =\n  \"MessagePrimitive.AttachmentByIndex\";\n\nconst MessagePrimitiveAttachmentsInner: FC<{\n  children: (value: { attachment: CompleteAttachment }) => ReactNode;\n}> = ({ children }) => {\n  const attachmentIds = useAuiState(\n    useShallowSelector((s) => {\n      if (s.message.role !== \"user\") return [];\n      return (s.message.attachments ?? []).map((attachment) => attachment.id);\n    }),\n  );\n\n  return useMemo(\n    () =>\n      attachmentIds.map((attachmentId, index) => (\n        <MessageAttachmentByIndexProvider key={attachmentId} index={index}>\n          <RenderChildrenWithAccessor\n            getItemState={(aui) => aui.message.attachment({ index }).getState()}\n          >\n            {(getItem) =>\n              children({\n                get attachment() {\n                  return getItem() as CompleteAttachment;\n                },\n              })\n            }\n          </RenderChildrenWithAccessor>\n        </MessageAttachmentByIndexProvider>\n      )),\n    [attachmentIds, children],\n  );\n};\n\nexport const MessagePrimitiveAttachments: FC<\n  MessagePrimitiveAttachments.Props\n> = ({ components, children }) => {\n  if (components) {\n    return (\n      <MessagePrimitiveAttachmentsInner>\n        {({ attachment }) => {\n          const Component = getComponent(components, attachment);\n          if (!Component) return null;\n          return <Component />;\n        }}\n      </MessagePrimitiveAttachmentsInner>\n    );\n  }\n  return (\n    <MessagePrimitiveAttachmentsInner>\n      {children}\n    </MessagePrimitiveAttachmentsInner>\n  );\n};\n\nMessagePrimitiveAttachments.displayName = \"MessagePrimitive.Attachments\";\n"],"mappings":";;;;;;;AAiCA,MAAMqB,gBACJJ,YACAG,eACG;CAEH,QADaA,WAAWE,MACxB;EACE,KAAK,SACH,OAAOL,YAAYN,SAASM,YAAYH;EAC1C,KAAK,YACH,OAAOG,YAAYL,YAAYK,YAAYH;EAC7C,KAAK,QACH,OAAOG,YAAYJ,QAAQI,YAAYH;EACzC,SACE,OAAOG,YAAYH;CACvB;AACF;AAEA,MAAMS,uBAEDC,OAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CAAC,MAAA,EAAAT,eAAAO;CACJ,MAAAJ,aAAmBb,YAAYoB,KAAmB;CAClD,IAAI,CAACP,YAAU,OAAS;CAEmB,MAAAQ,KAAAR;CAAgC,IAAAS;CAAA,IAAAJ,EAAA,OAAAR,cAAAQ,EAAA,OAAAG,IAAA;EAAzDC,KAAAR,aAAaJ,YAAYW,EAAgC;EAACH,EAAA,KAAAR;EAAAQ,EAAA,KAAAG;EAAAH,EAAA,KAAAI;CAAA,OAAAA,KAAAJ,EAAA;CAA5E,MAAAK,YAAkBD;CAClB,IAAI,CAACC,WAAS,OAAS;CAAK,IAAAC;CAAA,IAAAN,EAAA,OAAAK,WAAA;EACrBC,KAAA,oBAAC,WAAD,CAAU,CAAA;EAAGN,EAAA,KAAAK;EAAAL,EAAA,KAAAM;CAAA,OAAAA,KAAAN,EAAA;CAAA,OAAbM;AAAa;;;;AAatB,MAAaC,oCACX5B,MACEoB,OAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CAAC,MAAA,EAAAO,OAAAhB,eAAAO;CAAqB,IAAAI;CAAA,IAAAH,EAAA,OAAAR,YAAA;EAGhBW,KAAA,oBAAC,qBAAD,EAAiCX,WAAU,CAAA;EAAIQ,EAAA,KAAAR;EAAAQ,EAAA,KAAAG;CAAA,OAAAA,KAAAH,EAAA;CAAA,IAAAI;CAAA,IAAAJ,EAAA,OAAAQ,SAAAR,EAAA,OAAAG,IAAA;EADjDC,KAAA,oBAAC,kCAAD;GAAyCI;GACvCL,UAAAA;EAD+B,CAAA;EAEEH,EAAA,KAAAQ;EAAAR,EAAA,KAAAG;EAAAH,EAAA,KAAAI;CAAA,OAAAA,KAAAJ,EAAA;CAAA,OAFnCI;AAEmC,IAGtCK,MAAMC,SACLD,KAAKD,UAAUE,KAAKF,SACpBC,KAAKjB,YAAYN,UAAUwB,KAAKlB,YAAYN,SAC5CuB,KAAKjB,YAAYL,aAAauB,KAAKlB,YAAYL,YAC/CsB,KAAKjB,YAAYJ,SAASsB,KAAKlB,YAAYJ,QAC3CqB,KAAKjB,YAAYH,eAAeqB,KAAKlB,YAAYH,UACrD;AAEFkB,kCAAkCI,cAChC;AAEF,MAAMC,oCAEA,EAAEnB,eAAe;CACrB,MAAMoB,gBAAgB/B,YACpBC,oBAAoB+B,MAAM;EACxB,IAAIA,EAAEC,QAAQC,SAAS,QAAQ,OAAO,CAAA;EACtC,QAAQF,EAAEC,QAAQE,eAAe,CAAA,EAAA,CAAIC,KAAKvB,eAAeA,WAAWwB,EAAE;CACxE,CAAC,CACH;CAEA,OAAOvC,cAEHiC,cAAcK,KAAKE,cAAcZ,UAC/B,oBAAC,kCAAD;EAA4DA;EAC1D,UAAA,oBAAC,4BAAD;GACE,eAAea,QAAQA,IAAIN,QAAQpB,WAAW,EAAEa,MAAM,CAAC,CAAC,CAACc,SAAS;GAEhEC,WAAAA,YACA9B,SAAS,EACP,IAAIE,aAAa;IACf,OAAO4B,QAAQ;GACjB,EACF,CAAC;EAEuB,CAAA;CACI,GAZKH,YAYL,CACnC,GACH,CAACP,eAAepB,QAAQ,CAC1B;AACF;AAEA,MAAaH,+BAETS,OAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CAAC,MAAA,EAAAT,YAAAC,aAAAM;CACH,IAAIP,YAAU;EAAA,IAAAW;EAAA,IAAAH,EAAA,OAAAR,YAAA;GAEVW,KAAA,oBAAC,kCAAD,EAAA,WACGC,OAAA;IAAC,MAAA,EAAAT,eAAAS;IACA,MAAAC,YAAkBT,aAAaJ,YAAYG,UAAU;IACrD,IAAI,CAACU,WAAS,OAAS;IAAK,OACrB,oBAAC,WAAD,CAAU,CAAA;GAAG,EAJS,CAAA;GAMEL,EAAA,KAAAR;GAAAQ,EAAA,KAAAG;EAAA,OAAAA,KAAAH,EAAA;EAAA,OANnCG;CAMmC;CAEtC,IAAAA;CAAA,IAAAH,EAAA,OAAAP,UAAA;EAECU,KAAA,oBAAC,kCAAD,EACGV,SAD8B,CAAA;EAEEO,EAAA,KAAAP;EAAAO,EAAA,KAAAG;CAAA,OAAAA,KAAAH,EAAA;CAAA,OAFnCG;AAEmC;AAIvCb,4BAA4BqB,cAAc;AA3FrC,SAAAT,MAAAY,GAAA;CAAA,OACmCA,EAACnB;AAAW"}
+{"version":3,"file":"MessageAttachments.js","names":["Attachment","ComponentType","FC","ReactNode","memo","useMemo","RenderChildrenWithAccessor","useAuiState","useShallowSelector","MessageAttachmentByIndexProvider","MessageAttachmentsComponentConfig","Image","Document","File","MessagePrimitiveAttachments","Props","components","children","value","attachment","getComponent","type","AttachmentComponent","t0","$","_c","_temp","t1","Component","t2","MessagePrimitiveAttachmentByIndex","index","prev","next","displayName","MessagePrimitiveAttachmentsInner","attachmentIds","s","message","role","attachments","submission","map","id","attachmentId","aui","getState","getItem"],"sources":["../../../../src/react/primitives/message/MessageAttachments.tsx"],"sourcesContent":["import type { Attachment } from \"../../../types/attachment\";\nimport {\n  type ComponentType,\n  type FC,\n  type ReactNode,\n  memo,\n  useMemo,\n} from \"react\";\nimport { RenderChildrenWithAccessor, useAuiState } from \"@assistant-ui/store\";\nimport { useShallowSelector } from \"@assistant-ui/store/internal\";\nimport { MessageAttachmentByIndexProvider } from \"../../providers/AttachmentByIndexProvider\";\n\ntype MessageAttachmentsComponentConfig = {\n  Image?: ComponentType | undefined;\n  Document?: ComponentType | undefined;\n  File?: ComponentType | undefined;\n  Attachment?: ComponentType | undefined;\n};\n\nexport namespace MessagePrimitiveAttachments {\n  export type Props =\n    | {\n        /** @deprecated Use the children render function instead. */\n        components: MessageAttachmentsComponentConfig;\n        children?: never;\n      }\n    | {\n        /**\n         * Render function called for each attachment. Receives the attachment,\n         * which is still being prepared while the message is the composer's\n         * submission.\n         */\n        children: (value: { attachment: Attachment }) => ReactNode;\n        components?: never;\n      };\n}\n\nconst getComponent = (\n  components: MessageAttachmentsComponentConfig | undefined,\n  attachment: Attachment,\n) => {\n  const type = attachment.type;\n  switch (type) {\n    case \"image\":\n      return components?.Image ?? components?.Attachment;\n    case \"document\":\n      return components?.Document ?? components?.Attachment;\n    case \"file\":\n      return components?.File ?? components?.Attachment;\n    default:\n      return components?.Attachment;\n  }\n};\n\nconst AttachmentComponent: FC<{\n  components: MessageAttachmentsComponentConfig | undefined;\n}> = ({ components }) => {\n  const attachment = useAuiState((s) => s.attachment);\n  if (!attachment) return null;\n\n  const Component = getComponent(components, attachment);\n  if (!Component) return null;\n  return <Component />;\n};\n\nexport namespace MessagePrimitiveAttachmentByIndex {\n  export type Props = {\n    index: number;\n    components?: MessageAttachmentsComponentConfig;\n  };\n}\n\n/**\n * Renders a single attachment at the specified index within the current message.\n */\nexport const MessagePrimitiveAttachmentByIndex: FC<MessagePrimitiveAttachmentByIndex.Props> =\n  memo(\n    ({ index, components }) => {\n      return (\n        <MessageAttachmentByIndexProvider index={index}>\n          <AttachmentComponent components={components} />\n        </MessageAttachmentByIndexProvider>\n      );\n    },\n    (prev, next) =>\n      prev.index === next.index &&\n      prev.components?.Image === next.components?.Image &&\n      prev.components?.Document === next.components?.Document &&\n      prev.components?.File === next.components?.File &&\n      prev.components?.Attachment === next.components?.Attachment,\n  );\n\nMessagePrimitiveAttachmentByIndex.displayName =\n  \"MessagePrimitive.AttachmentByIndex\";\n\nconst MessagePrimitiveAttachmentsInner: FC<{\n  children: (value: { attachment: Attachment }) => ReactNode;\n}> = ({ children }) => {\n  const attachmentIds = useAuiState(\n    useShallowSelector((s) => {\n      if (s.message.role !== \"user\") return [];\n      const attachments =\n        s.message.submission?.attachments ?? s.message.attachments;\n      return (attachments ?? []).map((attachment) => attachment.id);\n    }),\n  );\n\n  return useMemo(\n    () =>\n      attachmentIds.map((attachmentId, index) => (\n        <MessageAttachmentByIndexProvider key={attachmentId} index={index}>\n          <RenderChildrenWithAccessor\n            getItemState={(aui) => aui.message.attachment({ index }).getState()}\n          >\n            {(getItem) =>\n              children({\n                get attachment() {\n                  return getItem();\n                },\n              })\n            }\n          </RenderChildrenWithAccessor>\n        </MessageAttachmentByIndexProvider>\n      )),\n    [attachmentIds, children],\n  );\n};\n\nexport const MessagePrimitiveAttachments: FC<\n  MessagePrimitiveAttachments.Props\n> = ({ components, children }) => {\n  if (components) {\n    return (\n      <MessagePrimitiveAttachmentsInner>\n        {({ attachment }) => {\n          const Component = getComponent(components, attachment);\n          if (!Component) return null;\n          return <Component />;\n        }}\n      </MessagePrimitiveAttachmentsInner>\n    );\n  }\n  return (\n    <MessagePrimitiveAttachmentsInner>\n      {children}\n    </MessagePrimitiveAttachmentsInner>\n  );\n};\n\nMessagePrimitiveAttachments.displayName = \"MessagePrimitive.Attachments\";\n"],"mappings":"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"}

package/dist/react/primitives/message/MessageGroupedParts.d.ts

@@ -1,125 +1,129 @@
-import { MessagePartStatus, ToolCallMessagePartStatus } from "../../../types/message.js";
-import { PartState } from "../../../store/scopes/part.js";
-import { EnrichedPartState } from "./MessageParts.js";
-import { GroupByContext } from "../../utils/groupParts.js";
-import { ReactNode } from "react";
-//#region src/react/primitives/message/MessageGroupedParts.d.ts
-declare namespace MessagePrimitiveGroupedParts {
-  /** Per status tallies over the group's `indices`; they sum to `indices.length`. */
-  type GroupCounts = {
-    readonly running: number;
-    readonly complete: number;
-    readonly incomplete: number;
-    readonly requiresAction: number;
-  };
-  /**
-   * A coalesced group of adjacent parts. Surfaced through the same
-   * `{ part }` channel as a leaf {@link EnrichedPartState} so consumers
-   * dispatch on a single `switch (part.type)`. `type` is the group key
-   * (always `"group-…"`); `status` is running when any contained part runs,
-   * otherwise it mirrors the last contained part.
-   */
-  type GroupPart<TKey extends `group-${string}` = `group-${string}`> = {
-    readonly type: TKey;
-    readonly status: MessagePartStatus | ToolCallMessagePartStatus;
-    /** Per status tallies over `indices`. */
-    readonly counts: GroupCounts;
-    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.
-   */
-  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 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.
-   */
-  type IndicatorMode = "never" | "empty" | "no-text" | "always";
-  type RenderInfo<TKey extends `group-${string}` = `group-${string}`> = {
+import { type ReactNode } from "react";
+import type { PartState } from "../../../store/scopes/part.js";
+import type { MessagePartStatus, ToolCallMessagePartStatus } from "../../../types/message.js";
+import { type GroupByContext } from "../../utils/groupParts.js";
+import { type EnrichedPartState } from "./MessageParts.js";
+export declare namespace MessagePrimitiveGroupedParts {
+    /** Per status tallies over the group's `indices`; they sum to `indices.length`. */
+    type GroupCounts = {
+        readonly running: number;
+        readonly complete: number;
+        readonly incomplete: number;
+        readonly requiresAction: number;
+    };
     /**
-     * Either a coalesced group ({@link GroupPart}, identified by a
-     * `group-…` `type`), a single enriched leaf part, or the synthetic
-     * {@link IndicatorPart} (`type: "indicator"`). Use one switch over
-     * `part.type` to handle all three.
+     * A coalesced group of adjacent parts. Surfaced through the same
+     * `{ part }` channel as a leaf {@link EnrichedPartState} so consumers
+     * dispatch on a single `switch (part.type)`. `type` is the group key
+     * (always `"group-…"`); `status` is running when any contained part runs,
+     * otherwise it mirrors the last contained part.
      */
-    readonly part: GroupPart<TKey> | EnrichedPartState | IndicatorPart;
+    type GroupPart<TKey extends `group-${string}` = `group-${string}`> = {
+        readonly type: TKey;
+        readonly status: MessagePartStatus | ToolCallMessagePartStatus;
+        /** Per status tallies over `indices`. */
+        readonly counts: GroupCounts;
+        readonly indices: readonly number[];
+    };
     /**
-     * For group nodes: the recursively-rendered subtree (subgroups +
-     * leaf parts). For leaf parts: a sentinel that throws when rendered
-     * — accidental fall-through (`default: return children;`) errors
-     * loudly instead of silently rendering nothing.
-     */
-    readonly children: ReactNode;
-  };
-  type Props<TKey extends `group-${string}` = `group-${string}`> = {
-    /**
-     * Maps each part to a group-key path. Adjacent parts that share a
-     * prefix coalesce into the same group. Return `[]` (or `null`) to
-     * leave a part ungrouped.
-     *
-     * Group keys must start with `"group-"` so the renderer's
-     * `switch (part.type)` can tell groups apart from real part types.
-     *
-     * **Prefer {@link groupPartByType}** for the common case of mapping by
-     * `part.type` or tool name — it ships a stable memo fingerprint so the tree
-     * survives unrelated re-renders. Use an inline function only when
-     * the helper isn't expressive enough (e.g. branching on
-     * `part.parentId` 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).
+     * 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"`.
      *
-     * @example
-     * ```tsx
-     * import { groupPartByType } from "@assistant-ui/react";
-     *
-     * <MessagePrimitive.GroupedParts
-     *   groupBy={groupPartByType({
-     *     reasoning: ["group-thought", "group-reasoning"],
-     *     "tool-call": ["group-thought", "group-tool"],
-     *   })}
-     * >
-     * ```
+     * 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.
      */
-    readonly groupBy: (part: PartState, context: GroupByContext) => readonly TKey[] | null;
+    type IndicatorPart = {
+        readonly type: "indicator";
+    };
     /**
-     * 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`,
-     * `resume`, `respondToApproval`, `dataRendererUI`).
+     * 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 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.
      */
-    readonly children: (info: RenderInfo<TKey>) => ReactNode;
-  };
+    type IndicatorMode = "never" | "empty" | "no-text" | "always";
+    type RenderInfo<TKey extends `group-${string}` = `group-${string}`> = {
+        /**
+         * Either a coalesced group ({@link GroupPart}, identified by a
+         * `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 | IndicatorPart;
+        /**
+         * For group nodes: the recursively-rendered subtree (subgroups +
+         * leaf parts). For leaf parts: a sentinel that throws when rendered
+         * — accidental fall-through (`default: return children;`) errors
+         * loudly instead of silently rendering nothing. Returning `null` for a
+         * leaf renders its registered tool or data UI, when one exists; return an
+         * empty fragment to suppress that registered UI explicitly.
+         */
+        readonly children: ReactNode;
+    };
+    type Props<TKey extends `group-${string}` = `group-${string}`> = {
+        /**
+         * Maps each part to a group-key path. Adjacent parts that share a
+         * prefix coalesce into the same group. Return `[]` (or `null`) to
+         * leave a part ungrouped.
+         *
+         * Group keys must start with `"group-"` so the renderer's
+         * `switch (part.type)` can tell groups apart from real part types.
+         *
+         * **Prefer {@link groupPartByType}** for the common case of mapping by
+         * `part.type` or tool name — it ships a stable memo fingerprint so the tree
+         * survives unrelated re-renders. Use an inline function only when
+         * the helper isn't expressive enough (e.g. branching on
+         * `part.parentId` 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";
+         *
+         * <MessagePrimitive.GroupedParts
+         *   groupBy={groupPartByType({
+         *     reasoning: ["group-thought", "group-reasoning"],
+         *     "tool-call": ["group-thought", "group-tool"],
+         *   })}
+         * >
+         * ```
+         */
+        readonly groupBy: (part: PartState, context: GroupByContext) => readonly TKey[] | null;
+        /**
+         * 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. Returning `null` for a tool or data leaf uses its
+         * registered UI, while an empty fragment suppresses it; `"indicator"`
+         * renders status/loading UI.
+         *
+         * Leaf parts receive the same {@link EnrichedPartState} that
+         * `<MessagePrimitive.Parts>` would produce (`toolUI`, `addResult`,
+         * `resume`, `respondToApproval`, `unstable_recordInteraction`,
+         * `dataRendererUI`).
+         */
+        readonly children: (info: RenderInfo<TKey>) => ReactNode;
+    };
 }
 /**
  * Groups adjacent message parts into a tree of coalesced runs and
@@ -154,10 +158,8 @@ declare namespace MessagePrimitiveGroupedParts {
  * </MessagePrimitive.GroupedParts>
  * ```
  */
-declare const MessagePrimitiveGroupedParts: {
-  <TKey extends `group-${string}`>({ groupBy, indicator, children }: MessagePrimitiveGroupedParts.Props<TKey>): ReactNode;
-  displayName: string;
+export declare const MessagePrimitiveGroupedParts: {
+    <TKey extends `group-${string}`>({ groupBy, indicator, children, }: MessagePrimitiveGroupedParts.Props<TKey>): ReactNode;
+    displayName: string;
 };
-//#endregion
-export { MessagePrimitiveGroupedParts };
 //# sourceMappingURL=MessageGroupedParts.d.ts.map

package/dist/react/primitives/message/MessageGroupedParts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MessageGroupedParts.d.ts","names":[],"sources":["../../../../src/react/primitives/message/MessageGroupedParts.tsx"],"mappings":";;;;;;kBAmBiB;;OAEH;aACD;aACA;aACA;aACA;;;;;;;;;OAUC,UAAU;aACX,MAAM;aACN,QAAQ,oBAAoB;;aAE5B,QAAQ;aACR;;;;;;;;;;;;OAaC;aACD;;;;;;;;;;;;;OAcC;OAEA,WAAW;;;;;;;aAOZ,MAAM,UAAU,QAAQ,oBAAoB;;;;;;;aAO5C,UAAU;;OAGT,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA8BP,UACP,MAAM,WACN,SAAS,4BACG;;;;;;;;;aAUL,YAAY;;;;;;;;;;;;aAaZ,WAAW,MAAM,WAAW,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoHtC;GAAgC,kCAA8B,SAAA,WAAA,YAIxE,6BAA6B,MAAM,QAAQ"}
+{"version":3,"file":"MessageGroupedParts.d.ts","sourceRoot":"","sources":["../../../../src/react/primitives/message/MessageGroupedParts.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAqB,KAAK,SAAS,EAAW,MAAM,OAAO,CAAC;AAGnE,OAAO,KAAK,EAAE,SAAS,EAAE,sCAAmC;AAC5D,OAAO,KAAK,EACV,iBAAiB,EACjB,yBAAyB,EAC1B,kCAA+B;AAEhC,OAAO,EAGL,KAAK,cAAc,EAEpB,kCAA+B;AAChC,OAAO,EAGL,KAAK,iBAAiB,EACvB,0BAAuB;AAExB,yBAAiB,4BAA4B,CAAC;IAC5C,mFAAmF;IACnF,KAAY,WAAW,GAAG;QACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;KACjC,CAAC;IAEF;;;;;;OAMG;IACH,KAAY,SAAS,CAAC,IAAI,SAAS,SAAS,MAAM,EAAE,GAAG,SAAS,MAAM,EAAE,IAAI;QAC1E,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;QACpB,QAAQ,CAAC,MAAM,EAAE,iBAAiB,GAAG,yBAAyB,CAAC;QAC/D,yCAAyC;QACzC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;QAC7B,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;KACrC,CAAC;IAEF;;;;;;;;;OASG;IACH,KAAY,aAAa,GAAG;QAC1B,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;KAC5B,CAAC;IAEF;;;;;;;;;;OAUG;IACH,KAAY,aAAa,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,GAAG,QAAQ,CAAC;IAErE,KAAY,UAAU,CAAC,IAAI,SAAS,SAAS,MAAM,EAAE,GAAG,SAAS,MAAM,EAAE,IAAI;QAC3E;;;;;WAKG;QACH,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,IAAI,CAAC,GAAG,iBAAiB,GAAG,aAAa,CAAC;QACnE;;;;;;;WAOG;QACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;KAC9B,CAAC;IAEF,KAAY,KAAK,CAAC,IAAI,SAAS,SAAS,MAAM,EAAE,GAAG,SAAS,MAAM,EAAE,IAAI;QACtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA4BG;QACH,QAAQ,CAAC,OAAO,EAAE,CAChB,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,cAAc,KACpB,SAAS,IAAI,EAAE,GAAG,IAAI,CAAC;QAE5B;;;;;;;WAOG;QACH,QAAQ,CAAC,SAAS,CAAC,EAAE,aAAa,CAAC;QAEnC;;;;;;;;;;;;;WAaG;QACH,QAAQ,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,CAAC,KAAK,SAAS,CAAC;KAC1D,CAAC;CACH;AAqFD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,4BAA4B;KAAI,IAAI,SAAS,SAAS,MAAM,EAAE,qCAIxE,4BAA4B,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,SAAS;;CAwCtD,CAAC"}

package/dist/react/primitives/message/MessageGroupedParts.js

@@ -1,6 +1,6 @@
 "use client";
 import { getGroupSummary } from "../../../utils/getGroupStatus.js";
-import { MessagePartChildren } from "./MessageParts.js";
+import { DefaultPartFallback, MessagePartChildren } from "./MessageParts.js";
 import { GROUPBY_MEMO_KEY, buildGroupTree } from "../../utils/groupParts.js";
 import { Fragment, useMemo } from "@assistant-ui/tap/react-shim";
 import { useAuiState } from "@assistant-ui/store";
@@ -26,7 +26,7 @@ const shouldShowIndicator = (mode, parts, isRunning) => {
 * surface the bug loudly instead of silently rendering nothing.
 */
 const PartChildrenSentinel = () => {
-	throw new Error("MessagePrimitive.GroupedParts: rendered `children` under a leaf part. `children` is only meaningful for `group-…` cases — add a matching case for the part type or return `null` to skip it.");
+	throw new Error("MessagePrimitive.GroupedParts: rendered `children` under a leaf part. `children` is only meaningful for `group-…` cases — add a matching case for the part type or return `null` to use registered UIs.");
 };
 const renderNode = (node, parts, render) => {
 	if (node.type === "part") return /* @__PURE__ */ jsx(MessagePartChildren, {
@@ -34,7 +34,7 @@ const renderNode = (node, parts, render) => {
 		children: ({ part }) => render({
 			part,
 			children: /* @__PURE__ */ jsx(PartChildrenSentinel, {})
-		})
+		}) ?? /* @__PURE__ */ jsx(DefaultPartFallback, {})
 	}, node.idKey ? `part-${node.idKey}` : `part-${node.index}`);
 	const { status, counts } = getGroupSummary(parts, node.indices);
 	const groupPart = {

package/dist/react/primitives/message/MessageGroupedParts.js.map

@@ -1 +1 @@
-{"version":3,"file":"MessageGroupedParts.js","names":["Fragment","FC","ReactNode","useMemo","useAuiState","useShallowSelector","PartState","MessagePartStatus","ToolCallMessagePartStatus","getGroupSummary","buildGroupTree","GROUPBY_MEMO_KEY","GroupByContext","GroupNode","MessagePartChildren","EnrichedPartState","MessagePrimitiveGroupedParts","GroupCounts","running","complete","incomplete","requiresAction","GroupPart","type","TKey","status","counts","indices","IndicatorPart","IndicatorMode","RenderInfo","part","children","Props","groupBy","context","indicator","info","shouldShowIndicator","mode","parts","isRunning","length","last","undefined","PartChildrenSentinel","Error","renderNode","node","render","idKey","index","groupPart","key","nodeKey","map","child","s","message","toolUIs","tools","memoKey","memoDep","tree","toolCallId","displayName"],"sources":["../../../../src/react/primitives/message/MessageGroupedParts.tsx"],"sourcesContent":["\"use client\";\n\nimport { Fragment, type FC, type ReactNode, useMemo } from \"react\";\nimport { useAuiState } from \"@assistant-ui/store\";\nimport { useShallowSelector } from \"@assistant-ui/store/internal\";\nimport type { PartState } from \"../../../store/scopes/part\";\nimport type {\n  MessagePartStatus,\n  ToolCallMessagePartStatus,\n} from \"../../../types/message\";\nimport { getGroupSummary } from \"../../../utils/getGroupStatus\";\nimport {\n  buildGroupTree,\n  GROUPBY_MEMO_KEY,\n  type GroupByContext,\n  type GroupNode,\n} from \"../../utils/groupParts\";\nimport { MessagePartChildren, type EnrichedPartState } from \"./MessageParts\";\n\nexport namespace MessagePrimitiveGroupedParts {\n  /** Per status tallies over the group's `indices`; they sum to `indices.length`. */\n  export type GroupCounts = {\n    readonly running: number;\n    readonly complete: number;\n    readonly incomplete: number;\n    readonly requiresAction: number;\n  };\n\n  /**\n   * A coalesced group of adjacent parts. Surfaced through the same\n   * `{ part }` channel as a leaf {@link EnrichedPartState} so consumers\n   * dispatch on a single `switch (part.type)`. `type` is the group key\n   * (always `\"group-…\"`); `status` is running when any contained part runs,\n   * otherwise it mirrors the last contained part.\n   */\n  export type GroupPart<TKey extends `group-${string}` = `group-${string}`> = {\n    readonly type: TKey;\n    readonly status: MessagePartStatus | ToolCallMessagePartStatus;\n    /** Per status tallies over `indices`. */\n    readonly counts: GroupCounts;\n    readonly indices: readonly number[];\n  };\n\n  /**\n   * Synthetic trailing slot for a streaming/loading affordance (a\n   * \"thinking…\" dot, etc.). Surfaced through the same `{ part }` channel\n   * as groups and leaf parts so a single `switch (part.type)` renders it\n   * via `case \"indicator\"`.\n   *\n   * It is only ever emitted while the message is running, so its presence\n   * alone means \"render your loading UI here\" — there's no `status` to\n   * branch on.\n   */\n  export type IndicatorPart = {\n    readonly type: \"indicator\";\n  };\n\n  /**\n   * When to emit the synthetic {@link IndicatorPart}. It is **only** emitted\n   * while the message is running (streaming); the mode further restricts\n   * which running states qualify:\n   * - `\"never\"` — never.\n   * - `\"empty\"` — only when the message has no parts yet.\n   * - `\"no-text\"` (default) — when the message has no parts yet or the last\n   *   part isn't `text`/`reasoning` (e.g. it ended on a tool call, so the\n   *   assistant likely isn't done).\n   * - `\"always\"` — whenever the message is running, regardless of parts.\n   */\n  export type IndicatorMode = \"never\" | \"empty\" | \"no-text\" | \"always\";\n\n  export type RenderInfo<TKey extends `group-${string}` = `group-${string}`> = {\n    /**\n     * Either a coalesced group ({@link GroupPart}, identified by a\n     * `group-…` `type`), a single enriched leaf part, or the synthetic\n     * {@link IndicatorPart} (`type: \"indicator\"`). Use one switch over\n     * `part.type` to handle all three.\n     */\n    readonly part: GroupPart<TKey> | EnrichedPartState | IndicatorPart;\n    /**\n     * For group nodes: the recursively-rendered subtree (subgroups +\n     * leaf parts). For leaf parts: a sentinel that throws when rendered\n     * — accidental fall-through (`default: return children;`) errors\n     * loudly instead of silently rendering nothing.\n     */\n    readonly children: ReactNode;\n  };\n\n  export type Props<TKey extends `group-${string}` = `group-${string}`> = {\n    /**\n     * Maps each part to a group-key path. Adjacent parts that share a\n     * prefix coalesce into the same group. Return `[]` (or `null`) to\n     * leave a part ungrouped.\n     *\n     * Group keys must start with `\"group-\"` so the renderer's\n     * `switch (part.type)` can tell groups apart from real part types.\n     *\n     * **Prefer {@link groupPartByType}** for the common case of mapping by\n     * `part.type` or tool name — it ships a stable memo fingerprint so the tree\n     * survives unrelated re-renders. Use an inline function only when\n     * the helper isn't expressive enough (e.g. branching on\n     * `part.parentId` or part metadata).\n     *\n     * The second argument is a {@link GroupByContext} carrying the tool-UI\n     * registry, for grouping that depends on it (e.g. standalone tool calls).\n     *\n     * @example\n     * ```tsx\n     * import { groupPartByType } from \"@assistant-ui/react\";\n     *\n     * <MessagePrimitive.GroupedParts\n     *   groupBy={groupPartByType({\n     *     reasoning: [\"group-thought\", \"group-reasoning\"],\n     *     \"tool-call\": [\"group-thought\", \"group-tool\"],\n     *   })}\n     * >\n     * ```\n     */\n    readonly groupBy: (\n      part: PartState,\n      context: GroupByContext,\n    ) => readonly TKey[] | null;\n\n    /**\n     * Controls emission of the synthetic {@link IndicatorPart} — a\n     * trailing `{ part: { type: \"indicator\", status } }` render call you\n     * handle with `case \"indicator\"` to show loading/status UI.\n     *\n     * @default \"no-text\"\n     * @see IndicatorMode\n     */\n    readonly indicator?: IndicatorMode;\n\n    /**\n     * Render function called once per group node, once per leaf part, and\n     * (when the `indicator` condition is met) once for the trailing\n     * {@link IndicatorPart}. Switch on `part.type`: `\"group-…\"` cases wrap\n     * `children`; real part types (`\"text\"`, `\"tool-call\"`, …) render the\n     * part directly; `\"indicator\"` renders status/loading UI.\n     *\n     * Leaf parts receive the same {@link EnrichedPartState} that\n     * `<MessagePrimitive.Parts>` would produce (`toolUI`, `addResult`,\n     * `resume`, `respondToApproval`, `dataRendererUI`).\n     */\n    readonly children: (info: RenderInfo<TKey>) => ReactNode;\n  };\n}\n\nconst shouldShowIndicator = (\n  mode: MessagePrimitiveGroupedParts.IndicatorMode,\n  parts: readonly PartState[],\n  isRunning: boolean,\n): boolean => {\n  // The indicator is a streaming affordance — never show it on a settled\n  // message, whatever the mode.\n  if (!isRunning) return false;\n\n  switch (mode) {\n    case \"never\":\n      return false;\n    case \"always\":\n      return true;\n    case \"empty\":\n      return parts.length === 0;\n    case \"no-text\": {\n      const last = parts[parts.length - 1];\n      return (\n        last === undefined ||\n        (last.type !== \"text\" && last.type !== \"reasoning\")\n      );\n    }\n  }\n};\n\n/**\n * `children` placeholder passed for leaf-part renders. Leaf parts have no\n * inner subtree; rendering this sentinel signals the consumer wrote\n * `default: return children;` and accidentally fell through for a part —\n * surface the bug loudly instead of silently rendering nothing.\n */\nconst PartChildrenSentinel: FC = () => {\n  throw new Error(\n    \"MessagePrimitive.GroupedParts: rendered `children` under a leaf \" +\n      \"part. `children` is only meaningful for `group-…` cases — add a \" +\n      \"matching case for the part type or return `null` to skip it.\",\n  );\n};\n\nconst renderNode = <TKey extends `group-${string}`>(\n  node: GroupNode,\n  parts: readonly PartState[],\n  render: (info: MessagePrimitiveGroupedParts.RenderInfo<TKey>) => ReactNode,\n): ReactNode => {\n  if (node.type === \"part\") {\n    // Key by part identity when available, else absolute part index — never\n    // the structural nodeKey, which leaves zombie fiber subscriptions when\n    // parts reshape (#4051).\n    return (\n      <MessagePartChildren\n        key={node.idKey ? `part-${node.idKey}` : `part-${node.index}`}\n        index={node.index}\n      >\n        {({ part }) => render({ part, children: <PartChildrenSentinel /> })}\n      </MessagePartChildren>\n    );\n  }\n\n  const { status, counts } = getGroupSummary(parts, node.indices);\n  const groupPart: MessagePrimitiveGroupedParts.GroupPart<TKey> = {\n    type: node.key as TKey,\n    status,\n    counts,\n    indices: node.indices,\n  };\n\n  return (\n    <Fragment key={node.idKey ?? node.nodeKey}>\n      {render({\n        part: groupPart,\n        children: (\n          <>{node.children.map((child) => renderNode(child, parts, render))}</>\n        ),\n      })}\n    </Fragment>\n  );\n};\n\n/**\n * Groups adjacent message parts into a tree of coalesced runs and\n * renders each node — group or part — through a single `children`\n * function.\n *\n * The render function receives `{ part, children }` where `part.type`\n * is either a `\"group-…\"` literal (for a group, `children` is the\n * recursively-rendered subtree) or a real part type (`\"text\"`,\n * `\"tool-call\"`, …) for a leaf (`children` is a sentinel that throws\n * if rendered — use `part.type` to distinguish).\n *\n * @example\n * ```tsx\n * <MessagePrimitive.GroupedParts\n *   groupBy={groupPartByType({\n *     reasoning: [\"group-thought\", \"group-reasoning\"],\n *     \"tool-call\": [\"group-thought\", \"group-tool\"],\n *   })}\n * >\n *   {({ part, children }) => {\n *     switch (part.type) {\n *       case \"group-thought\":   return <Thought>{children}</Thought>;\n *       case \"group-reasoning\": return <Reasoning>{children}</Reasoning>;\n *       case \"group-tool\":      return <ToolStack>{children}</ToolStack>;\n *       case \"text\":            return <MarkdownText />;\n *       case \"tool-call\":       return part.toolUI ?? <ToolFallback {...part} />;\n *       case \"indicator\":       return <LoadingDots />;\n *       default:                return null;\n *     }\n *   }}\n * </MessagePrimitive.GroupedParts>\n * ```\n */\nexport const MessagePrimitiveGroupedParts = <TKey extends `group-${string}`>({\n  groupBy,\n  indicator = \"no-text\",\n  children,\n}: MessagePrimitiveGroupedParts.Props<TKey>): ReactNode => {\n  const parts = useAuiState(useShallowSelector((s) => s.message.parts));\n  // Handed to `groupBy` as its `context` argument (see GroupByContext).\n  const toolUIs = useAuiState((s) => s.tools.toolUIs);\n  // Subscribe to a boolean, not the status object: the tree only needs to\n  // re-render when running-ness flips, and `\"never\"` opts out entirely.\n  const isRunning = useAuiState((s) =>\n    indicator === \"never\" ? false : s.message.status?.type === \"running\",\n  );\n\n  // Helpers like `groupPartByType` tag the function with `GROUPBY_MEMO_KEY`\n  // (a stable string fingerprint of the helper config). When present,\n  // memo on `[parts, memoKey]` so the tree survives unrelated renders.\n  // For inline `groupBy`, fall back to recomputing each render — O(n)\n  // and cheap.\n  const memoKey = (groupBy as { [GROUPBY_MEMO_KEY]?: string })[\n    GROUPBY_MEMO_KEY\n  ];\n  const memoDep = memoKey ?? groupBy;\n  const tree = useMemo(() => {\n    const context: GroupByContext = { toolUIs };\n    return buildGroupTree(\n      parts.map((part) => groupBy(part, context) ?? []),\n      parts.map((part) =>\n        part.type === \"tool-call\" ? part.toolCallId : undefined,\n      ),\n    );\n    // 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\n  }, [parts, memoDep, toolUIs]);\n\n  return (\n    <>\n      {tree.map((node) => renderNode(node, parts, children))}\n      {shouldShowIndicator(indicator, parts, isRunning) &&\n        children({\n          part: { type: \"indicator\" },\n          children: <PartChildrenSentinel />,\n        })}\n    </>\n  );\n};\n\nMessagePrimitiveGroupedParts.displayName = \"MessagePrimitive.GroupedParts\";\n"],"mappings":";;;;;;;;;AAmJA,MAAMsC,uBACJC,MACAC,OACAC,cACY;CAGZ,IAAI,CAACA,WAAW,OAAO;CAEvB,QAAQF,MAAR;EACE,KAAK,SACH,OAAO;EACT,KAAK,UACH,OAAO;EACT,KAAK,SACH,OAAOC,MAAME,WAAW;EAC1B,KAAK,WAAW;GACd,MAAMC,OAAOH,MAAMA,MAAME,SAAS;GAClC,OACEC,SAASC,KAAAA,KACRD,KAAKpB,SAAS,UAAUoB,KAAKpB,SAAS;EAE3C;CACF;AACF;;;;;;;AAQA,MAAMsB,6BAAiC;CACrC,MAAM,IAAIC,MACR,8LAGF;AACF;AAEA,MAAMC,cACJC,MACAR,OACAS,WACc;CACd,IAAID,KAAKzB,SAAS,QAIhB,OACE,oBAAC,qBAAD;EAEE,OAAOyB,KAAKG;EAEV,WAAA,EAAEpB,WAAWkB,OAAO;GAAElB;GAAMC,UAAU,oBAAC,sBAAD,CAAqB,CAAA;EAAI,CAAC;CAC/C,GAJdgB,KAAKE,QAAQ,QAAQF,KAAKE,UAAU,QAAQF,KAAKG,OAInC;CAIzB,MAAM,EAAE1B,QAAQC,WAAWjB,gBAAgB+B,OAAOQ,KAAKrB,OAAO;CAC9D,MAAMyB,YAA0D;EAC9D7B,MAAMyB,KAAKK;EACX5B;EACAC;EACAC,SAASqB,KAAKrB;CAChB;CAEA,OACE,oBAAC,UAAD,EAAA,UACGsB,OAAO;EACNlB,MAAMqB;EACNpB,UACE,oBAAA,YAAA,EAAA,UAAGgB,KAAKhB,SAASuB,KAAKC,UAAUT,WAAWS,OAAOhB,OAAOS,MAAM,CAAC,EAAE,CAAA;CAEtE,CAAC,EACO,GAPKD,KAAKE,SAASF,KAAKM,OAOxB;AAEd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,MAAatC,gCAAgE,EAC3EkB,SACAE,YAAY,WACZJ,eACyD;CACzD,MAAMQ,QAAQpC,YAAYC,oBAAoBoD,MAAMA,EAAEC,QAAQlB,KAAK,CAAC;CAEpE,MAAMmB,UAAUvD,aAAaqD,QAAMA,IAAEG,MAAMD,OAAO;CAGlD,MAAMlB,YAAYrC,aAAaqD,QAC7BrB,cAAc,UAAU,QAAQqB,IAAEC,QAAQjC,QAAQF,SAAS,SAC7D;CAUA,MAAMuC,UAHW5B,QACfvB,qBAEyBuB;CAC3B,MAAM6B,OAAO5D,cAAc;EACzB,MAAMgC,UAA0B,EAAEwB,QAAQ;EAC1C,OAAOjD,eACL8B,MAAMe,KAAKxB,SAASG,QAAQH,MAAMI,OAAO,KAAK,CAAA,CAAE,GAChDK,MAAMe,KAAKxB,WACTA,OAAKR,SAAS,cAAcQ,OAAKiC,aAAapB,KAAAA,CAChD,CACF;CAEF,GAAG;EAACJ;EAAOsB;EAASH;CAAO,CAAC;CAE5B,OACE,qBAAA,YAAA,EAAA,UAAA,CACGI,KAAKR,KAAKP,SAASD,WAAWC,MAAMR,OAAOR,QAAQ,CAAC,GACpDM,oBAAoBF,WAAWI,OAAOC,SAAS,KAC9CT,SAAS;EACPD,MAAM,EAAER,MAAM,YAAY;EAC1BS,UAAU,oBAAC,sBAAD,CAAqB,CAAA;CACjC,CAAC,CACL,EAAA,CAAA;AAEJ;AAEAhB,6BAA6BiD,cAAc"}
+{"version":3,"file":"MessageGroupedParts.js","names":["Fragment","FC","ReactNode","useMemo","useAuiState","useShallowSelector","PartState","MessagePartStatus","ToolCallMessagePartStatus","getGroupSummary","buildGroupTree","GROUPBY_MEMO_KEY","GroupByContext","GroupNode","DefaultPartFallback","MessagePartChildren","EnrichedPartState","MessagePrimitiveGroupedParts","GroupCounts","running","complete","incomplete","requiresAction","GroupPart","type","TKey","status","counts","indices","IndicatorPart","IndicatorMode","RenderInfo","part","children","Props","groupBy","context","indicator","info","shouldShowIndicator","mode","parts","isRunning","length","last","undefined","PartChildrenSentinel","Error","renderNode","node","render","idKey","index","groupPart","key","nodeKey","map","child","s","message","toolUIs","tools","memoKey","memoDep","tree","toolCallId","displayName"],"sources":["../../../../src/react/primitives/message/MessageGroupedParts.tsx"],"sourcesContent":["\"use client\";\n\nimport { Fragment, type FC, type ReactNode, useMemo } from \"react\";\nimport { useAuiState } from \"@assistant-ui/store\";\nimport { useShallowSelector } from \"@assistant-ui/store/internal\";\nimport type { PartState } from \"../../../store/scopes/part\";\nimport type {\n  MessagePartStatus,\n  ToolCallMessagePartStatus,\n} from \"../../../types/message\";\nimport { getGroupSummary } from \"../../../utils/getGroupStatus\";\nimport {\n  buildGroupTree,\n  GROUPBY_MEMO_KEY,\n  type GroupByContext,\n  type GroupNode,\n} from \"../../utils/groupParts\";\nimport {\n  DefaultPartFallback,\n  MessagePartChildren,\n  type EnrichedPartState,\n} from \"./MessageParts\";\n\nexport namespace MessagePrimitiveGroupedParts {\n  /** Per status tallies over the group's `indices`; they sum to `indices.length`. */\n  export type GroupCounts = {\n    readonly running: number;\n    readonly complete: number;\n    readonly incomplete: number;\n    readonly requiresAction: number;\n  };\n\n  /**\n   * A coalesced group of adjacent parts. Surfaced through the same\n   * `{ part }` channel as a leaf {@link EnrichedPartState} so consumers\n   * dispatch on a single `switch (part.type)`. `type` is the group key\n   * (always `\"group-…\"`); `status` is running when any contained part runs,\n   * otherwise it mirrors the last contained part.\n   */\n  export type GroupPart<TKey extends `group-${string}` = `group-${string}`> = {\n    readonly type: TKey;\n    readonly status: MessagePartStatus | ToolCallMessagePartStatus;\n    /** Per status tallies over `indices`. */\n    readonly counts: GroupCounts;\n    readonly indices: readonly number[];\n  };\n\n  /**\n   * Synthetic trailing slot for a streaming/loading affordance (a\n   * \"thinking…\" dot, etc.). Surfaced through the same `{ part }` channel\n   * as groups and leaf parts so a single `switch (part.type)` renders it\n   * via `case \"indicator\"`.\n   *\n   * It is only ever emitted while the message is running, so its presence\n   * alone means \"render your loading UI here\" — there's no `status` to\n   * branch on.\n   */\n  export type IndicatorPart = {\n    readonly type: \"indicator\";\n  };\n\n  /**\n   * When to emit the synthetic {@link IndicatorPart}. It is **only** emitted\n   * while the message is running (streaming); the mode further restricts\n   * which running states qualify:\n   * - `\"never\"` — never.\n   * - `\"empty\"` — only when the message has no parts yet.\n   * - `\"no-text\"` (default) — when the message has no parts yet or the last\n   *   part isn't `text`/`reasoning` (e.g. it ended on a tool call, so the\n   *   assistant likely isn't done).\n   * - `\"always\"` — whenever the message is running, regardless of parts.\n   */\n  export type IndicatorMode = \"never\" | \"empty\" | \"no-text\" | \"always\";\n\n  export type RenderInfo<TKey extends `group-${string}` = `group-${string}`> = {\n    /**\n     * Either a coalesced group ({@link GroupPart}, identified by a\n     * `group-…` `type`), a single enriched leaf part, or the synthetic\n     * {@link IndicatorPart} (`type: \"indicator\"`). Use one switch over\n     * `part.type` to handle all three.\n     */\n    readonly part: GroupPart<TKey> | EnrichedPartState | IndicatorPart;\n    /**\n     * For group nodes: the recursively-rendered subtree (subgroups +\n     * leaf parts). For leaf parts: a sentinel that throws when rendered\n     * — accidental fall-through (`default: return children;`) errors\n     * loudly instead of silently rendering nothing. Returning `null` for a\n     * leaf renders its registered tool or data UI, when one exists; return an\n     * empty fragment to suppress that registered UI explicitly.\n     */\n    readonly children: ReactNode;\n  };\n\n  export type Props<TKey extends `group-${string}` = `group-${string}`> = {\n    /**\n     * Maps each part to a group-key path. Adjacent parts that share a\n     * prefix coalesce into the same group. Return `[]` (or `null`) to\n     * leave a part ungrouped.\n     *\n     * Group keys must start with `\"group-\"` so the renderer's\n     * `switch (part.type)` can tell groups apart from real part types.\n     *\n     * **Prefer {@link groupPartByType}** for the common case of mapping by\n     * `part.type` or tool name — it ships a stable memo fingerprint so the tree\n     * survives unrelated re-renders. Use an inline function only when\n     * the helper isn't expressive enough (e.g. branching on\n     * `part.parentId` or part metadata).\n     *\n     * The second argument is a {@link GroupByContext} carrying the tool-UI\n     * registry, for grouping that depends on it (e.g. standalone tool calls).\n     *\n     * @example\n     * ```tsx\n     * import { groupPartByType } from \"@assistant-ui/react\";\n     *\n     * <MessagePrimitive.GroupedParts\n     *   groupBy={groupPartByType({\n     *     reasoning: [\"group-thought\", \"group-reasoning\"],\n     *     \"tool-call\": [\"group-thought\", \"group-tool\"],\n     *   })}\n     * >\n     * ```\n     */\n    readonly groupBy: (\n      part: PartState,\n      context: GroupByContext,\n    ) => readonly TKey[] | null;\n\n    /**\n     * Controls emission of the synthetic {@link IndicatorPart} — a\n     * trailing `{ part: { type: \"indicator\", status } }` render call you\n     * handle with `case \"indicator\"` to show loading/status UI.\n     *\n     * @default \"no-text\"\n     * @see IndicatorMode\n     */\n    readonly indicator?: IndicatorMode;\n\n    /**\n     * Render function called once per group node, once per leaf part, and\n     * (when the `indicator` condition is met) once for the trailing\n     * {@link IndicatorPart}. Switch on `part.type`: `\"group-…\"` cases wrap\n     * `children`; real part types (`\"text\"`, `\"tool-call\"`, …) render the\n     * part directly. Returning `null` for a tool or data leaf uses its\n     * registered UI, while an empty fragment suppresses it; `\"indicator\"`\n     * renders status/loading UI.\n     *\n     * Leaf parts receive the same {@link EnrichedPartState} that\n     * `<MessagePrimitive.Parts>` would produce (`toolUI`, `addResult`,\n     * `resume`, `respondToApproval`, `unstable_recordInteraction`,\n     * `dataRendererUI`).\n     */\n    readonly children: (info: RenderInfo<TKey>) => ReactNode;\n  };\n}\n\nconst shouldShowIndicator = (\n  mode: MessagePrimitiveGroupedParts.IndicatorMode,\n  parts: readonly PartState[],\n  isRunning: boolean,\n): boolean => {\n  // The indicator is a streaming affordance — never show it on a settled\n  // message, whatever the mode.\n  if (!isRunning) return false;\n\n  switch (mode) {\n    case \"never\":\n      return false;\n    case \"always\":\n      return true;\n    case \"empty\":\n      return parts.length === 0;\n    case \"no-text\": {\n      const last = parts[parts.length - 1];\n      return (\n        last === undefined ||\n        (last.type !== \"text\" && last.type !== \"reasoning\")\n      );\n    }\n  }\n};\n\n/**\n * `children` placeholder passed for leaf-part renders. Leaf parts have no\n * inner subtree; rendering this sentinel signals the consumer wrote\n * `default: return children;` and accidentally fell through for a part —\n * surface the bug loudly instead of silently rendering nothing.\n */\nconst PartChildrenSentinel: FC = () => {\n  throw new Error(\n    \"MessagePrimitive.GroupedParts: rendered `children` under a leaf \" +\n      \"part. `children` is only meaningful for `group-…` cases — add a \" +\n      \"matching case for the part type or return `null` to use registered UIs.\",\n  );\n};\n\nconst renderNode = <TKey extends `group-${string}`>(\n  node: GroupNode,\n  parts: readonly PartState[],\n  render: (info: MessagePrimitiveGroupedParts.RenderInfo<TKey>) => ReactNode,\n): ReactNode => {\n  if (node.type === \"part\") {\n    // Key by part identity when available, else absolute part index — never\n    // the structural nodeKey, which leaves zombie fiber subscriptions when\n    // parts reshape (#4051).\n    return (\n      <MessagePartChildren\n        key={node.idKey ? `part-${node.idKey}` : `part-${node.index}`}\n        index={node.index}\n      >\n        {({ part }) =>\n          render({ part, children: <PartChildrenSentinel /> }) ?? (\n            <DefaultPartFallback />\n          )\n        }\n      </MessagePartChildren>\n    );\n  }\n\n  const { status, counts } = getGroupSummary(parts, node.indices);\n  const groupPart: MessagePrimitiveGroupedParts.GroupPart<TKey> = {\n    type: node.key as TKey,\n    status,\n    counts,\n    indices: node.indices,\n  };\n\n  return (\n    <Fragment key={node.idKey ?? node.nodeKey}>\n      {render({\n        part: groupPart,\n        children: (\n          <>{node.children.map((child) => renderNode(child, parts, render))}</>\n        ),\n      })}\n    </Fragment>\n  );\n};\n\n/**\n * Groups adjacent message parts into a tree of coalesced runs and\n * renders each node — group or part — through a single `children`\n * function.\n *\n * The render function receives `{ part, children }` where `part.type`\n * is either a `\"group-…\"` literal (for a group, `children` is the\n * recursively-rendered subtree) or a real part type (`\"text\"`,\n * `\"tool-call\"`, …) for a leaf (`children` is a sentinel that throws\n * if rendered — use `part.type` to distinguish).\n *\n * @example\n * ```tsx\n * <MessagePrimitive.GroupedParts\n *   groupBy={groupPartByType({\n *     reasoning: [\"group-thought\", \"group-reasoning\"],\n *     \"tool-call\": [\"group-thought\", \"group-tool\"],\n *   })}\n * >\n *   {({ part, children }) => {\n *     switch (part.type) {\n *       case \"group-thought\":   return <Thought>{children}</Thought>;\n *       case \"group-reasoning\": return <Reasoning>{children}</Reasoning>;\n *       case \"group-tool\":      return <ToolStack>{children}</ToolStack>;\n *       case \"text\":            return <MarkdownText />;\n *       case \"tool-call\":       return part.toolUI ?? <ToolFallback {...part} />;\n *       case \"indicator\":       return <LoadingDots />;\n *       default:                return null;\n *     }\n *   }}\n * </MessagePrimitive.GroupedParts>\n * ```\n */\nexport const MessagePrimitiveGroupedParts = <TKey extends `group-${string}`>({\n  groupBy,\n  indicator = \"no-text\",\n  children,\n}: MessagePrimitiveGroupedParts.Props<TKey>): ReactNode => {\n  const parts = useAuiState(useShallowSelector((s) => s.message.parts));\n  // Handed to `groupBy` as its `context` argument (see GroupByContext).\n  const toolUIs = useAuiState((s) => s.tools.toolUIs);\n  // Subscribe to a boolean, not the status object: the tree only needs to\n  // re-render when running-ness flips, and `\"never\"` opts out entirely.\n  const isRunning = useAuiState((s) =>\n    indicator === \"never\" ? false : s.message.status?.type === \"running\",\n  );\n\n  // Helpers like `groupPartByType` tag the function with `GROUPBY_MEMO_KEY`\n  // (a stable string fingerprint of the helper config). When present,\n  // memo on `[parts, memoKey]` so the tree survives unrelated renders.\n  // For inline `groupBy`, fall back to recomputing each render — O(n)\n  // and cheap.\n  const memoKey = (groupBy as { [GROUPBY_MEMO_KEY]?: string })[\n    GROUPBY_MEMO_KEY\n  ];\n  const memoDep = memoKey ?? groupBy;\n  const tree = useMemo(() => {\n    const context: GroupByContext = { toolUIs };\n    return buildGroupTree(\n      parts.map((part) => groupBy(part, context) ?? []),\n      parts.map((part) =>\n        part.type === \"tool-call\" ? part.toolCallId : undefined,\n      ),\n    );\n    // 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\n  }, [parts, memoDep, toolUIs]);\n\n  return (\n    <>\n      {tree.map((node) => renderNode(node, parts, children))}\n      {shouldShowIndicator(indicator, parts, isRunning) &&\n        children({\n          part: { type: \"indicator\" },\n          children: <PartChildrenSentinel />,\n        })}\n    </>\n  );\n};\n\nMessagePrimitiveGroupedParts.displayName = \"MessagePrimitive.GroupedParts\";\n"],"mappings":";;;;;;;;;AA4JA,MAAMuC,uBACJC,MACAC,OACAC,cACY;CAGZ,IAAI,CAACA,WAAW,OAAO;CAEvB,QAAQF,MAAR;EACE,KAAK,SACH,OAAO;EACT,KAAK,UACH,OAAO;EACT,KAAK,SACH,OAAOC,MAAME,WAAW;EAC1B,KAAK,WAAW;GACd,MAAMC,OAAOH,MAAMA,MAAME,SAAS;GAClC,OACEC,SAASC,KAAAA,KACRD,KAAKpB,SAAS,UAAUoB,KAAKpB,SAAS;EAE3C;CACF;AACF;;;;;;;AAQA,MAAMsB,6BAAiC;CACrC,MAAM,IAAIC,MACR,yMAGF;AACF;AAEA,MAAMC,cACJC,MACAR,OACAS,WACc;CACd,IAAID,KAAKzB,SAAS,QAIhB,OACE,oBAAC,qBAAD;EAEE,OAAOyB,KAAKG;EAEV,WAAA,EAAEpB,WACFkB,OAAO;GAAElB;GAAMC,UAAU,oBAAC,sBAAD,CAAqB,CAAA;EAAI,CAAC,KACjD,oBAAC,qBAAD,CAAoB,CAAA;CAGL,GARdgB,KAAKE,QAAQ,QAAQF,KAAKE,UAAU,QAAQF,KAAKG,OAQnC;CAIzB,MAAM,EAAE1B,QAAQC,WAAWlB,gBAAgBgC,OAAOQ,KAAKrB,OAAO;CAC9D,MAAMyB,YAA0D;EAC9D7B,MAAMyB,KAAKK;EACX5B;EACAC;EACAC,SAASqB,KAAKrB;CAChB;CAEA,OACE,oBAAC,UAAD,EAAA,UACGsB,OAAO;EACNlB,MAAMqB;EACNpB,UACE,oBAAA,YAAA,EAAA,UAAGgB,KAAKhB,SAASuB,KAAKC,UAAUT,WAAWS,OAAOhB,OAAOS,MAAM,CAAC,EAAE,CAAA;CAEtE,CAAC,EACO,GAPKD,KAAKE,SAASF,KAAKM,OAOxB;AAEd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,MAAatC,gCAAgE,EAC3EkB,SACAE,YAAY,WACZJ,eACyD;CACzD,MAAMQ,QAAQrC,YAAYC,oBAAoBqD,MAAMA,EAAEC,QAAQlB,KAAK,CAAC;CAEpE,MAAMmB,UAAUxD,aAAasD,QAAMA,IAAEG,MAAMD,OAAO;CAGlD,MAAMlB,YAAYtC,aAAasD,QAC7BrB,cAAc,UAAU,QAAQqB,IAAEC,QAAQjC,QAAQF,SAAS,SAC7D;CAUA,MAAMuC,UAHW5B,QACfxB,qBAEyBwB;CAC3B,MAAM6B,OAAO7D,cAAc;EACzB,MAAMiC,UAA0B,EAAEwB,QAAQ;EAC1C,OAAOlD,eACL+B,MAAMe,KAAKxB,SAASG,QAAQH,MAAMI,OAAO,KAAK,CAAA,CAAE,GAChDK,MAAMe,KAAKxB,WACTA,OAAKR,SAAS,cAAcQ,OAAKiC,aAAapB,KAAAA,CAChD,CACF;CAEF,GAAG;EAACJ;EAAOsB;EAASH;CAAO,CAAC;CAE5B,OACE,qBAAA,YAAA,EAAA,UAAA,CACGI,KAAKR,KAAKP,SAASD,WAAWC,MAAMR,OAAOR,QAAQ,CAAC,GACpDM,oBAAoBF,WAAWI,OAAOC,SAAS,KAC9CT,SAAS;EACPD,MAAM,EAAER,MAAM,YAAY;EAC1BS,UAAU,oBAAC,sBAAD,CAAqB,CAAA;CACjC,CAAC,CACL,EAAA,CAAA;AAEJ;AAEAhB,6BAA6BiD,cAAc"}