@assistant-ui/core 0.2.12 → 0.2.15

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

@@ -1 +1 @@
-{"version":3,"file":"MessageGroupedParts.js","names":[],"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 { useShallow } from \"zustand/shallow\";\nimport type { PartState } from \"../../../store/scopes/part\";\nimport type {\n  MessagePartStatus,\n  ToolCallMessagePartStatus,\n} from \"../../../types/message\";\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  /**\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` 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    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 last part isn't `text`/`reasoning`\n   *   (e.g. it ended on a tool call, so the 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` — 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.toolName` 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 COMPLETE_STATUS: MessagePartStatus = Object.freeze({ type: \"complete\" });\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 && 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 absolute part index, not structural nodeKey — prevents zombie fiber subscriptions when parts reshape (#4051).\n    return (\n      <MessagePartChildren key={`part-${node.index}`} index={node.index}>\n        {({ part }) => render({ part, children: <PartChildrenSentinel /> })}\n      </MessagePartChildren>\n    );\n  }\n\n  const status = parts[node.indices.at(-1)!]?.status ?? COMPLETE_STATUS;\n  const groupPart: MessagePrimitiveGroupedParts.GroupPart<TKey> = {\n    type: node.key as TKey,\n    status,\n    indices: node.indices,\n  };\n\n  return (\n    <Fragment key={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(useShallow((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(parts.map((part) => groupBy(part, context) ?? []));\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":";;;;;;;;AAsIA,MAAM,kBAAqC,OAAO,OAAO,EAAE,MAAM,WAAW,CAAC;AAE7E,MAAM,uBACJ,MACA,OACA,cACY;CAGZ,IAAI,CAAC,WAAW,OAAO;CAEvB,QAAQ,MAAR;EACE,KAAK,SACH,OAAO;EACT,KAAK,UACH,OAAO;EACT,KAAK,SACH,OAAO,MAAM,WAAW;EAC1B,KAAK,WAAW;GACd,MAAM,OAAO,MAAM,MAAM,SAAS;GAClC,OACE,SAAS,KAAA,KAAa,KAAK,SAAS,UAAU,KAAK,SAAS;EAEhE;CACF;AACF;;;;;;;AAQA,MAAM,6BAAiC;CACrC,MAAM,IAAI,MACR,8LAGF;AACF;AAEA,MAAM,cACJ,MACA,OACA,WACc;CACd,IAAI,KAAK,SAAS,QAEhB,OACE,oBAAC,qBAAD;EAAgD,OAAO,KAAK;aACxD,EAAE,WAAW,OAAO;GAAE;GAAM,UAAU,oBAAC,sBAAD,CAAuB,CAAA;EAAE,CAAC;CAC/C,GAFK,QAAQ,KAAK,OAElB;CAIzB,MAAM,SAAS,MAAM,KAAK,QAAQ,GAAG,EAAE,EAAG,EAAE,UAAU;CAOtD,OACE,oBAAC,UAAD,EAAA,UACG,OAAO;EACN,MAAM;GARV,MAAM,KAAK;GACX;GACA,SAAS,KAAK;EAMI;EACd,UACE,oBAAA,YAAA,EAAA,UAAG,KAAK,SAAS,KAAK,UAAU,WAAW,OAAO,OAAO,MAAM,CAAC,EAAI,CAAA;CAExE,CAAC,EACO,GAPK,KAAK,OAOV;AAEd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,MAAa,gCAAgE,EAC3E,SACA,YAAY,WACZ,eACyD;CACzD,MAAM,QAAQ,YAAY,YAAY,MAAM,EAAE,QAAQ,KAAK,CAAC;CAE5D,MAAM,UAAU,aAAa,MAAM,EAAE,MAAM,OAAO;CAGlD,MAAM,YAAY,aAAa,MAC7B,cAAc,UAAU,QAAQ,EAAE,QAAQ,QAAQ,SAAS,SAC7D;CAiBA,OACE,qBAAA,YAAA,EAAA,UAAA,CAPW,cAAc;EACzB,MAAM,UAA0B,EAAE,QAAQ;EAC1C,OAAO,eAAe,MAAM,KAAK,SAAS,QAAQ,MAAM,OAAO,KAAK,CAAC,CAAC,CAAC;CAEzE,GAAG;EAAC;EARa,QACf,qBAEyB;EAKP;CAAO,CAInB,CAAC,CAAC,KAAK,SAAS,WAAW,MAAM,OAAO,QAAQ,CAAC,GACpD,oBAAoB,WAAW,OAAO,SAAS,KAC9C,SAAS;EACP,MAAM,EAAE,MAAM,YAAY;EAC1B,UAAU,oBAAC,sBAAD,CAAuB,CAAA;CACnC,CAAC,CACH,EAAA,CAAA;AAEN;AAEA,6BAA6B,cAAc"}
+{"version":3,"file":"MessageGroupedParts.js","names":["Fragment","FC","ReactNode","useMemo","useAuiState","useShallow","PartState","MessagePartStatus","ToolCallMessagePartStatus","buildGroupTree","GROUPBY_MEMO_KEY","GroupByContext","GroupNode","MessagePartChildren","EnrichedPartState","MessagePrimitiveGroupedParts","GroupPart","type","TKey","status","indices","IndicatorPart","IndicatorMode","RenderInfo","part","children","Props","groupBy","context","indicator","info","COMPLETE_STATUS","Object","freeze","shouldShowIndicator","mode","parts","isRunning","length","last","undefined","PartChildrenSentinel","Error","renderNode","node","render","idKey","index","at","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 { useShallow } from \"zustand/shallow\";\nimport type { PartState } from \"../../../store/scopes/part\";\nimport type {\n  MessagePartStatus,\n  ToolCallMessagePartStatus,\n} from \"../../../types/message\";\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  /**\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` 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    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` — 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.toolName` 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 COMPLETE_STATUS: MessagePartStatus = Object.freeze({ type: \"complete\" });\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 = parts[node.indices.at(-1)!]?.status ?? COMPLETE_STATUS;\n  const groupPart: MessagePrimitiveGroupedParts.GroupPart<TKey> = {\n    type: node.key as TKey,\n    status,\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(useShallow((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":";;;;;;;;AAuIA,MAAM+B,kBAAqCC,OAAOC,OAAO,EAAEhB,MAAM,WAAW,CAAC;AAE7E,MAAMiB,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,KAAKtB,SAAS,UAAUsB,KAAKtB,SAAS;EAE3C;CACF;AACF;;;;;;;AAQA,MAAMwB,6BAAiC;CACrC,MAAM,IAAIC,MACR,8LAGF;AACF;AAEA,MAAMC,cACJC,MACAR,OACAS,WACc;CACd,IAAID,KAAK3B,SAAS,QAIhB,OACE,oBAAC,qBAAD;EAEE,OAAO2B,KAAKG;aAEV,EAAEvB,WAAWqB,OAAO;GAAErB;GAAMC,UAAU,oBAAC,sBAAD,CAAqB,CAAA;EAAI,CAAC;CAC/C,GAJdmB,KAAKE,QAAQ,QAAQF,KAAKE,UAAU,QAAQF,KAAKG,OAInC;CAIzB,MAAM5B,SAASiB,MAAMQ,KAAKxB,QAAQ4B,GAAG,EAAE,EAAG,EAAE7B,UAAUY;CAOtD,OACE,oBAAC,UAAD,EAAA,UACGc,OAAO;EACNrB,MAAMyB;GARVhC,MAAM2B,KAAKM;GACX/B;GACAC,SAASwB,KAAKxB;EAMJ6B;EACNxB,UACE,oBAAA,YAAA,EAAA,UAAGmB,KAAKnB,SAAS2B,KAAKC,UAAUV,WAAWU,OAAOjB,OAAOS,MAAM,CAAC,EAAE,CAAA;CAEtE,CAAC,EACO,GAPKD,KAAKE,SAASF,KAAKO,OAOxB;AAEd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,MAAapC,gCAAgE,EAC3EY,SACAE,YAAY,WACZJ,eACyD;CACzD,MAAMW,QAAQhC,YAAYC,YAAYiD,MAAMA,EAAEC,QAAQnB,KAAK,CAAC;CAE5D,MAAMoB,UAAUpD,aAAakD,QAAMA,IAAEG,MAAMD,OAAO;CAGlD,MAAMnB,YAAYjC,aAAakD,QAC7BzB,cAAc,UAAU,QAAQyB,IAAEC,QAAQpC,QAAQF,SAAS,SAC7D;CAsBA,OACE,qBAAA,YAAA,EAAA,UAAA,CAZWd,cAAc;EACzB,MAAMyB,UAA0B,EAAE4B,QAAQ;EAC1C,OAAO/C,eACL2B,MAAMgB,KAAK5B,SAASG,QAAQH,MAAMI,OAAO,KAAK,CAAA,CAAE,GAChDQ,MAAMgB,KAAK5B,WACTA,OAAKP,SAAS,cAAcO,OAAKqC,aAAarB,KAAAA,CAChD,CACF;CAEF,GAAG;EAACJ;EAbaT,QACfjB,qBAEyBiB;EAUP6B;CAAO,CAItBI,CAAI,CAACR,KAAKR,SAASD,WAAWC,MAAMR,OAAOX,QAAQ,CAAC,GACpDS,oBAAoBL,WAAWO,OAAOC,SAAS,KAC9CZ,SAAS;EACPD,MAAM,EAAEP,MAAM,YAAY;EAC1BQ,UAAU,oBAAC,sBAAD,CAAqB,CAAA;CACjC,CAAC,CACL,EAAA,CAAA;AAEJ;AAEAV,6BAA6B+C,cAAc"}

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

@@ -3,6 +3,33 @@ import { DataMessagePartComponent, EmptyMessagePartComponent, FileMessagePartCom
 import { ComponentType, FC, PropsWithChildren, ReactNode } from "react";
 
 //#region src/react/primitives/message/MessageParts.d.ts
+type MessagePartRange = {
+  type: "single";
+  index: 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;
+};
+/**
+ * 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).
+ */
+declare const groupMessageParts: (messageTypes: readonly string[], useChainOfThought: boolean, partIds?: readonly (string | undefined)[]) => MessagePartRange[];
 declare namespace MessagePrimitiveParts {
   type DataConfig = {
     /** Map data event names to specific components */by_name?: Record<string, DataMessagePartComponent | undefined> | undefined; /** Fallback component for unmatched data events */
@@ -187,5 +214,5 @@ type EnrichedPartState = (Extract<PartState, {
  */
 declare const MessagePrimitiveParts: FC<MessagePrimitiveParts.Props>;
 //#endregion
-export { EnrichedPartState, MessagePartComponent, MessagePrimitivePartByIndex, MessagePrimitiveParts, type PartState, defaultComponents };
+export { EnrichedPartState, MessagePartComponent, MessagePrimitivePartByIndex, MessagePrimitiveParts, type PartState, defaultComponents, groupMessageParts };
 //# sourceMappingURL=MessageParts.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"MessageParts.d.ts","names":[],"sources":["../../../../src/react/primitives/message/MessageParts.tsx"],"mappings":";;;;;kBA6JiB,qBAAA;EAAA,KACV,UAAA;IADU,kDAGb,OAAA,GAAU,MAAA,SAAe,wBAAA,2BAHS;IAKlC,QAAA,GAAW,wBAAA;EAAA;EAAA,KAGR,cAAA;IAEK,6CAAR,KAAA,GAAQ,yBAAA,cAIC;IAFT,IAAA,GAAO,wBAAA,cAMA;IAJP,MAAA,GAAS,0BAAA,cAQF;IANP,KAAA,GAAQ,yBAAA,cAoBU;IAlBlB,IAAA,GAAO,wBAAA,cA+BgB;IA7BvB,cAAA,GAAiB,kCAAA,cAgCY;IA9B7B,IAAA,GAAO,UAAA,cAkCqB;IAhC5B,KAAA,GAAQ,yBAAA;IAyCgB;;;;;;;;IAhCxB,YAAA;MA+FsC,uDA5FhC,UAAA,EAAY,6BAAA,EAyGoC;MAvGhD,QAAA,GACI,aAAA;QAAgB,SAAA;QAAmB,KAAA;MAAA;IAAA;EAAA;EAAA,KAM1C,WAAA;IAxCQ,qDA2CP,OAAA,GACI,MAAA,SAAe,4BAAA,2BAvCvB;IA0CI,QAAA,GAAW,aAAA,CAAc,wBAAA;EAAA;IAxCtB,qDA4CH,QAAA,EAAU,aAAA,CAAc,wBAAA;EAAA;EAxC5B;;;;;;EAAA,KAiDG,kBAAA,GAAqB,cAAA;IA3CjB,mEA6CP,SAAA,GAAY,6BAAA,cA3CJ;IA6CR,KAAA,GAAQ,WAAA;IAjCF;;;;;;;;;IA4CN,SAAA,GAAY,aAAA,CACV,iBAAA;MAAoB,UAAA;MAAoB,QAAA;IAAA;IAzBtC;;;;;;;;;IAqCJ,cAAA,GAAiB,uBAAA;IAEjB,cAAA;EAAA;EAdsB;;;;;;;EAAA,KAwBnB,wBAAA,GAA2B,cAAA;IAMd;;;;;IAAhB,cAAA,EAAgB,aAAA;IAEhB,SAAA;IACA,KAAA;IACA,SAAA;IACA,cAAA;EAAA;EAAA,YAGU,KAAA;IAsBc;;;;;;;IAbpB,UAAA,GAAa,kBAAA,GAAqB,wBAAA;IA2D7B;;;;;;;IAnDL,8BAAA;IACA,QAAA;EAAA;IA0D0C,8EAtD1C,QAAA,GAAW,KAAA;MAAS,IAAA,EAAM,iBAAA;IAAA,MAAwB,SAAA;IAClD,UAAA;IACA,8BAAA;EAAA;EAAA;AAAA;;;;;cA4CK,iBAAA;;;;;;;;;KAOe,iBAAA,KAAiB,SAAA;;;KACZ,iBAAA,KAAiB,SAAA;AAAA;AAAA,KAG7C,yBAAA;EACH,UAAA,EAAY,qBAAA,CAAsB,KAAK;AAAA;AAAA,cAG5B,oBAAA,EAAsB,EAAE,CAAC,yBAAA;AAAA,kBAkGrB,2BAAA;EAAA,KACH,KAAA;IACV,KAAA;IACA,UAAA,EAAY,qBAAA,CAAsB,KAAK;EAAA;AAAA;AAH3C;;;AAAA,cAUa,2BAAA,EAA6B,EAAE,CAAC,2BAAA,CAA4B,KAAA;;;;;;AAP9B;AAO3C;;;;;;KA+LY,iBAAA,IACP,OAAA,CAAQ,SAAA;EAAa,IAAA;AAAA;EADd,2EAGG,MAAA,EAAQ,SAAA;EAEjB,SAAA,EAAW,wBAAA,eAJZ;EAMC,MAAA,EAAQ,wBAAA,YAFG;EAIX,iBAAA,EAAmB,wBAAA;AAAA,MAEpB,OAAA,CAAQ,SAAA;EAAa,IAAA;AAAA;EAEK,oFAAhB,cAAA,EAAgB,SAAA;AAAA,KAE3B,OAAA,CAAQ,SAAA;EAAa,IAAA;AAAA;EAAwB,IAAA;AAAA;;;;;;;cAoGpC,qBAAA,EAAuB,EAAE,CAAC,qBAAA,CAAsB,KAAA"}
+{"version":3,"file":"MessageParts.d.ts","names":[],"sources":["../../../../src/react/primitives/message/MessageParts.tsx"],"mappings":"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"}