@assistant-ui/core 0.3.1 → 0.3.3

package/dist/react/primitives/composer/ComposerAttachments.js

@@ -1,7 +1,7 @@
 import { ComposerAttachmentByIndexProvider } from "../../providers/AttachmentByIndexProvider.js";
-import { RenderChildrenWithAccessor, useAuiState } from "@assistant-ui/store";
-import { memo, useMemo } from "@assistant-ui/tap/react-shim";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { memo, useMemo } from "@assistant-ui/tap/react-shim";
+import { RenderChildrenWithAccessor, useAuiState } from "@assistant-ui/store";
 import { jsx } from "react/jsx-runtime";
 //#region src/react/primitives/composer/ComposerAttachments.tsx
 const getComponent = (components, attachment) => {

package/dist/react/primitives/composer/ComposerIf.js

@@ -1,5 +1,5 @@
-import { useAuiState } from "@assistant-ui/store";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { useAuiState } from "@assistant-ui/store";
 //#region src/react/primitives/composer/ComposerIf.tsx
 const useComposerIf = (props) => {
 	const $ = c(3);

package/dist/react/primitives/composer/ComposerQueue.js

@@ -1,6 +1,6 @@
 import { QueueItemByIndexProvider } from "../../providers/QueueItemByIndexProvider.js";
-import { RenderChildrenWithAccessor, useAuiState } from "@assistant-ui/store";
 import { memo, useMemo } from "@assistant-ui/tap/react-shim";
+import { RenderChildrenWithAccessor, useAuiState } from "@assistant-ui/store";
 import { jsx } from "react/jsx-runtime";
 //#region src/react/primitives/composer/ComposerQueue.tsx
 const ComposerPrimitiveQueueInner = ({ children }) => {

package/dist/react/primitives/generativeUI/GenerativeUI.js

@@ -1,7 +1,7 @@
 "use client";
-import { useAuiState } from "@assistant-ui/store";
-import { createElement } from "@assistant-ui/tap/react-shim";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { createElement } from "@assistant-ui/tap/react-shim";
+import { useAuiState } from "@assistant-ui/store";
 import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
 //#region src/react/primitives/generativeUI/GenerativeUI.tsx
 /**

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

@@ -1,7 +1,7 @@
 import { MessageAttachmentByIndexProvider } from "../../providers/AttachmentByIndexProvider.js";
-import { RenderChildrenWithAccessor, useAuiState } from "@assistant-ui/store";
-import { memo, useMemo } from "@assistant-ui/tap/react-shim";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { memo, useMemo } from "@assistant-ui/tap/react-shim";
+import { RenderChildrenWithAccessor, useAuiState } from "@assistant-ui/store";
 import { jsx } from "react/jsx-runtime";
 //#region src/react/primitives/message/MessageAttachments.tsx
 const getComponent = (components, attachment) => {

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

@@ -9,7 +9,8 @@ declare namespace MessagePrimitiveGroupedParts {
    * 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` mirrors the last contained part.
+   * (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;

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":";;;;;;kBAkBiB;;;;;;;OAOH,UAAU;aACX,MAAM;aACN,QAAQ,oBAAoB;aAC5B;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqHtC;GAAgC,kCAA8B,SAAA,WAAA,YAIxE,6BAA6B,MAAM,QAAQ"}
+{"version":3,"file":"MessageGroupedParts.d.ts","names":[],"sources":["../../../../src/react/primitives/message/MessageGroupedParts.tsx"],"mappings":";;;;;;kBAmBiB;;;;;;;;OAQH,UAAU;aACX,MAAM;aACN,QAAQ,oBAAoB;aAC5B;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmHtC;GAAgC,kCAA8B,SAAA,WAAA,YAIxE,6BAA6B,MAAM,QAAQ"}

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

@@ -1,12 +1,12 @@
 "use client";
+import { getGroupStatus } from "../../../utils/getGroupStatus.js";
 import { MessagePartChildren } from "./MessageParts.js";
 import { GROUPBY_MEMO_KEY, buildGroupTree } from "../../utils/groupParts.js";
-import { useAuiState } from "@assistant-ui/store";
 import { Fragment, useMemo } from "@assistant-ui/tap/react-shim";
+import { useAuiState } from "@assistant-ui/store";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 import { useShallow } from "zustand/shallow";
 //#region src/react/primitives/message/MessageGroupedParts.tsx
-const COMPLETE_STATUS = Object.freeze({ type: "complete" });
 const shouldShowIndicator = (mode, parts, isRunning) => {
 	if (!isRunning) return false;
 	switch (mode) {
@@ -36,7 +36,7 @@ const renderNode = (node, parts, render) => {
 			children: /* @__PURE__ */ jsx(PartChildrenSentinel, {})
 		})
 	}, node.idKey ? `part-${node.idKey}` : `part-${node.index}`);
-	const status = parts[node.indices.at(-1)]?.status ?? COMPLETE_STATUS;
+	const status = getGroupStatus(parts, node.indices);
 	return /* @__PURE__ */ jsx(Fragment, { children: render({
 		part: {
 			type: node.key,

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

@@ -1 +1 @@
-{"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;EAEV,WAAA,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"}
+{"version":3,"file":"MessageGroupedParts.js","names":["Fragment","FC","ReactNode","useMemo","useAuiState","useShallow","PartState","MessagePartStatus","ToolCallMessagePartStatus","getGroupStatus","buildGroupTree","GROUPBY_MEMO_KEY","GroupByContext","GroupNode","MessagePartChildren","EnrichedPartState","MessagePrimitiveGroupedParts","GroupPart","type","TKey","status","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 { useShallow } from \"zustand/shallow\";\nimport type { PartState } from \"../../../store/scopes/part\";\nimport type {\n  MessagePartStatus,\n  ToolCallMessagePartStatus,\n} from \"../../../types/message\";\nimport { getGroupStatus } 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  /**\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    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 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 = getGroupStatus(parts, node.indices);\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":";;;;;;;;;AAyIA,MAAMgC,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,KAAKnB,SAAS,UAAUmB,KAAKnB,SAAS;EAE3C;CACF;AACF;;;;;;;AAQA,MAAMqB,6BAAiC;CACrC,MAAM,IAAIC,MACR,8LAGF;AACF;AAEA,MAAMC,cACJC,MACAR,OACAS,WACc;CACd,IAAID,KAAKxB,SAAS,QAIhB,OACE,oBAAC,qBAAD;EAEE,OAAOwB,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,MAAMzB,SAASX,eAAeyB,OAAOQ,KAAKrB,OAAO;CAOjD,OACE,oBAAC,UAAD,EAAA,UACGsB,OAAO;EACNlB,MAAMqB;GARV5B,MAAMwB,KAAKK;GACX3B;GACAC,SAASqB,KAAKrB;EAMJyB;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,MAAahC,gCAAgE,EAC3EY,SACAE,YAAY,WACZJ,eACyD;CACzD,MAAMQ,QAAQ9B,YAAYC,YAAY8C,MAAMA,EAAEC,QAAQlB,KAAK,CAAC;CAE5D,MAAMmB,UAAUjD,aAAa+C,QAAMA,IAAEG,MAAMD,OAAO;CAGlD,MAAMlB,YAAY/B,aAAa+C,QAC7BrB,cAAc,UAAU,QAAQqB,IAAEC,QAAQhC,QAAQF,SAAS,SAC7D;CAsBA,OACE,qBAAA,YAAA,EAAA,UAAA,CAZWf,cAAc;EACzB,MAAM0B,UAA0B,EAAEwB,QAAQ;EAC1C,OAAO3C,eACLwB,MAAMe,KAAKxB,SAASG,QAAQH,MAAMI,OAAO,KAAK,CAAA,CAAE,GAChDK,MAAMe,KAAKxB,WACTA,OAAKP,SAAS,cAAcO,OAAKiC,aAAapB,KAAAA,CAChD,CACF;CAEF,GAAG;EAACJ;EAbaN,QACfjB,qBAEyBiB;EAUPyB;CAAO,CAItBI,CAAI,CAACR,KAAKP,SAASD,WAAWC,MAAMR,OAAOR,QAAQ,CAAC,GACpDM,oBAAoBF,WAAWI,OAAOC,SAAS,KAC9CT,SAAS;EACPD,MAAM,EAAEP,MAAM,YAAY;EAC1BQ,UAAU,oBAAC,sBAAD,CAAqB,CAAA;CACjC,CAAC,CACL,EAAA,CAAA;AAEJ;AAEAV,6BAA6B2C,cAAc"}

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

@@ -4,9 +4,9 @@ import { TextMessagePartProvider } from "../../providers/TextMessagePartProvider
 import { ChainOfThoughtByIndicesProvider } from "../../providers/ChainOfThoughtByIndicesProvider.js";
 import { getMessageQuote } from "../../utils/getMessageQuote.js";
 import { GenerativeUIRender } from "../generativeUI/GenerativeUI.js";
-import { RenderChildrenWithAccessor, useAui, useAuiState } from "@assistant-ui/store";
-import { memo } from "@assistant-ui/tap/react-shim";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { memo } from "@assistant-ui/tap/react-shim";
+import { RenderChildrenWithAccessor, useAui, useAuiState } from "@assistant-ui/store";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 import { useShallow } from "zustand/shallow";
 //#region src/react/primitives/message/MessageParts.tsx

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

@@ -1,7 +1,7 @@
 import { getMessageQuote } from "../../utils/getMessageQuote.js";
-import { useAuiState } from "@assistant-ui/store";
-import { memo } from "@assistant-ui/tap/react-shim";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { memo } from "@assistant-ui/tap/react-shim";
+import { useAuiState } from "@assistant-ui/store";
 import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
 //#region src/react/primitives/message/MessageQuote.tsx
 /**

package/dist/react/primitives/part/PartMessages.js

@@ -1,8 +1,8 @@
 import { ReadonlyThreadProvider } from "../../providers/ReadonlyThreadProvider.js";
 import { ThreadPrimitiveMessagesImpl } from "../thread/ThreadMessages.js";
-import { useAuiState } from "@assistant-ui/store";
-import { memo } from "@assistant-ui/tap/react-shim";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { memo } from "@assistant-ui/tap/react-shim";
+import { useAuiState } from "@assistant-ui/store";
 import { jsx } from "react/jsx-runtime";
 //#region src/react/primitives/part/PartMessages.tsx
 const usePartMessages = () => {

package/dist/react/primitives/thread/ThreadMessages.js

@@ -1,8 +1,8 @@
 import { MessageByIndexProvider } from "../../providers/MessageByIndexProvider.js";
 import { MessageByIdProvider } from "../../providers/MessageByIdProvider.js";
-import { RenderChildrenWithAccessor, useAuiState } from "@assistant-ui/store";
-import { memo, useMemo } from "@assistant-ui/tap/react-shim";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { memo, useMemo } from "@assistant-ui/tap/react-shim";
+import { RenderChildrenWithAccessor, useAuiState } from "@assistant-ui/store";
 import { jsx } from "react/jsx-runtime";
 //#region src/react/primitives/thread/ThreadMessages.tsx
 const isComponentsSame = (prev, next) => {

package/dist/react/primitives/thread/ThreadSuggestions.js

@@ -1,7 +1,7 @@
 import { SuggestionByIndexProvider } from "../../providers/SuggestionByIndexProvider.js";
-import { RenderChildrenWithAccessor, useAuiState } from "@assistant-ui/store";
-import { memo, useMemo } from "@assistant-ui/tap/react-shim";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { memo, useMemo } from "@assistant-ui/tap/react-shim";
+import { RenderChildrenWithAccessor, useAuiState } from "@assistant-ui/store";
 import { jsx } from "react/jsx-runtime";
 //#region src/react/primitives/thread/ThreadSuggestions.tsx
 const SuggestionComponent = (t0) => {

package/dist/react/primitives/threadList/ThreadListItems.js

@@ -1,7 +1,7 @@
 import { ThreadListItemByIndexProvider } from "../../providers/ThreadListItemByIndexProvider.js";
-import { RenderChildrenWithAccessor, useAuiState } from "@assistant-ui/store";
-import { memo, useMemo } from "@assistant-ui/tap/react-shim";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { memo, useMemo } from "@assistant-ui/tap/react-shim";
+import { RenderChildrenWithAccessor, useAuiState } from "@assistant-ui/store";
 import { jsx } from "react/jsx-runtime";
 //#region src/react/primitives/threadList/ThreadListItems.tsx
 /**

package/dist/react/primitives/threadListItem/ThreadListItemTitle.js

@@ -1,5 +1,5 @@
-import { useAuiState } from "@assistant-ui/store";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { useAuiState } from "@assistant-ui/store";
 import { Fragment, jsx } from "react/jsx-runtime";
 //#region src/react/primitives/threadListItem/ThreadListItemTitle.tsx
 const ThreadListItemPrimitiveTitle = (t0) => {

package/dist/react/providers/AttachmentByIndexProvider.js

@@ -1,5 +1,5 @@
-import { AuiProvider, Derived, useAui } from "@assistant-ui/store";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { AuiProvider, Derived, useAui } from "@assistant-ui/store";
 import { jsx } from "react/jsx-runtime";
 //#region src/react/providers/AttachmentByIndexProvider.tsx
 const MessageAttachmentByIndexProvider = (t0) => {

package/dist/react/providers/ChainOfThoughtByIndicesProvider.js

@@ -1,6 +1,6 @@
 import { ChainOfThoughtClient } from "../../store/clients/chain-of-thought-client.js";
-import { AuiProvider, useAui, useAuiState } from "@assistant-ui/store";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { AuiProvider, useAui, useAuiState } from "@assistant-ui/store";
 import { jsx } from "react/jsx-runtime";
 //#region src/react/providers/ChainOfThoughtByIndicesProvider.tsx
 const ChainOfThoughtByIndicesProvider = (t0) => {

package/dist/react/providers/ChainOfThoughtPartByIndexProvider.js

@@ -1,5 +1,5 @@
-import { AuiProvider, Derived, useAui } from "@assistant-ui/store";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { AuiProvider, Derived, useAui } from "@assistant-ui/store";
 import { jsx } from "react/jsx-runtime";
 //#region src/react/providers/ChainOfThoughtPartByIndexProvider.tsx
 const ChainOfThoughtPartByIndexProvider = (t0) => {

package/dist/react/providers/MessageByIdProvider.js

@@ -1,5 +1,5 @@
-import { AuiProvider, Derived, useAui } from "@assistant-ui/store";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { AuiProvider, Derived, useAui } from "@assistant-ui/store";
 import { jsx } from "react/jsx-runtime";
 //#region src/react/providers/MessageByIdProvider.tsx
 const MessageByIdProvider = (t0) => {

package/dist/react/providers/MessageByIndexProvider.js

@@ -1,5 +1,5 @@
-import { AuiProvider, Derived, useAui } from "@assistant-ui/store";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { AuiProvider, Derived, useAui } from "@assistant-ui/store";
 import { jsx } from "react/jsx-runtime";
 //#region src/react/providers/MessageByIndexProvider.tsx
 const MessageByIndexProvider = (t0) => {

package/dist/react/providers/PartByIndexProvider.js

@@ -1,5 +1,5 @@
-import { AuiProvider, Derived, useAui } from "@assistant-ui/store";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { AuiProvider, Derived, useAui } from "@assistant-ui/store";
 import { jsx } from "react/jsx-runtime";
 //#region src/react/providers/PartByIndexProvider.tsx
 const PartByIndexProvider = (t0) => {

package/dist/react/providers/QueueItemByIndexProvider.js

@@ -1,5 +1,5 @@
-import { AuiProvider, Derived, useAui } from "@assistant-ui/store";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { AuiProvider, Derived, useAui } from "@assistant-ui/store";
 import { jsx } from "react/jsx-runtime";
 //#region src/react/providers/QueueItemByIndexProvider.tsx
 const QueueItemByIndexProvider = (t0) => {

package/dist/react/providers/ReadonlyThreadProvider.js

@@ -1,9 +1,9 @@
 import { ThreadRuntimeImpl } from "../../runtime/api/thread-runtime.js";
 import { ReadonlyThreadRuntimeCore } from "../../runtimes/readonly/ReadonlyThreadRuntimeCore.js";
 import { ThreadClient } from "../../store/runtime-clients/thread-runtime-client.js";
-import { AuiProvider, Derived, useAui } from "@assistant-ui/store";
-import { useEffect, useState } from "@assistant-ui/tap/react-shim";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { useEffect, useState } from "@assistant-ui/tap/react-shim";
+import { AuiProvider, Derived, useAui } from "@assistant-ui/store";
 import { jsx } from "react/jsx-runtime";
 //#region src/react/providers/ReadonlyThreadProvider.tsx
 const READONLY_THREAD_PATH = Object.freeze({

package/dist/react/providers/SuggestionByIndexProvider.js

@@ -1,5 +1,5 @@
-import { AuiProvider, Derived, useAui } from "@assistant-ui/store";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { AuiProvider, Derived, useAui } from "@assistant-ui/store";
 import { jsx } from "react/jsx-runtime";
 //#region src/react/providers/SuggestionByIndexProvider.tsx
 const SuggestionByIndexProvider = (t0) => {

package/dist/react/providers/TextMessagePartProvider.js

@@ -1,6 +1,6 @@
-import { AuiProvider, useAui } from "@assistant-ui/store";
-import "@assistant-ui/tap/react-shim";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import "@assistant-ui/tap/react-shim";
+import { AuiProvider, useAui } from "@assistant-ui/store";
 import { resource } from "@assistant-ui/tap";
 import { jsx } from "react/jsx-runtime";
 //#region src/react/providers/TextMessagePartProvider.tsx

package/dist/react/providers/ThreadListItemByIndexProvider.js

@@ -1,5 +1,5 @@
-import { AuiProvider, Derived, useAui } from "@assistant-ui/store";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { AuiProvider, Derived, useAui } from "@assistant-ui/store";
 import { jsx } from "react/jsx-runtime";
 //#region src/react/providers/ThreadListItemByIndexProvider.tsx
 const ThreadListItemByIndexProvider = (t0) => {

package/dist/react/providers/ThreadListItemRuntimeProvider.js

@@ -1,6 +1,6 @@
 import { ThreadListItemClient } from "../../store/runtime-clients/thread-list-item-runtime-client.js";
-import { AuiProvider, useAui } from "@assistant-ui/store";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { AuiProvider, useAui } from "@assistant-ui/store";
 import { jsx } from "react/jsx-runtime";
 //#region src/react/providers/ThreadListItemRuntimeProvider.tsx
 const ThreadListItemRuntimeProvider = (t0) => {

package/dist/react/runtimes/RemoteThreadListHookInstanceManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RemoteThreadListHookInstanceManager.d.ts","names":[],"sources":["../../../src/react/runtimes/RemoteThreadListHookInstanceManager.tsx"],"mappings":";;;;;;;;;;;;;;;KAuBK,6BAA6B;cAcrB,4CAA4C;UAC/C;UAGA;UACA;UACA;EAGN,YAAA,aAAa,sBACb,QAAQ;EAOH,mBAAmB,mBAAgB,QAAA;;;eAPhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BH,qBAAqB,mBAAgB;;;eAxBF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BnC,kBAAkB;EAMlB,eAAe,gBAAgB;UAS9B;UAkEA;EAqCD,iCAAiC;IACtC,UAAU,cAAc"}
+{"version":3,"file":"RemoteThreadListHookInstanceManager.d.ts","names":[],"sources":["../../../src/react/runtimes/RemoteThreadListHookInstanceManager.tsx"],"mappings":";;;;;;;;;;;;;;;KAwBK,6BAA6B;cAcrB,4CAA4C;UAC/C;UAGA;UACA;UACA;EAGN,YAAA,aAAa,sBACb,QAAQ;EAOH,mBAAmB,mBAAgB,QAAA;;;eAPhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BH,qBAAqB,mBAAgB;;;eAxBF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BnC,kBAAkB;EAMlB,eAAe,gBAAgB;UAS9B;UAoEA;EAqCD,iCAAiC;IACtC,UAAU,cAAc"}

package/dist/react/runtimes/RemoteThreadListHookInstanceManager.js

@@ -1,9 +1,9 @@
 import { BaseSubscribable } from "../../subscribable/subscribable.js";
 import { ThreadListRuntimeImpl } from "../../runtime/api/thread-list-runtime.js";
 import { ThreadListItemRuntimeProvider } from "../providers/ThreadListItemRuntimeProvider.js";
-import { useAui } from "@assistant-ui/store";
-import { Fragment, memo, useCallback, useEffect, useLayoutEffect, useMemo, useRef } from "@assistant-ui/tap/react-shim";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { Fragment, memo, useCallback, useEffect, useEffectEvent, useLayoutEffect, useMemo, useRef } from "@assistant-ui/tap/react-shim";
+import { useAui } from "@assistant-ui/store";
 import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
 import { create } from "zustand";
 //#region src/react/runtimes/RemoteThreadListHookInstanceManager.tsx
@@ -96,19 +96,20 @@ var RemoteThreadListHookInstanceManager = class extends BaseSubscribable {
 			const setGetInitializePromise = runtimeCore.__internal_setGetInitializePromise;
 			if (typeof setGetInitializePromise === "function") setGetInitializePromise.call(runtimeCore, () => initPromiseRef.current);
 		}, [threadBinding]);
+		const handleInitialize = useEffectEvent(() => {
+			if (hasInitializedRef.current) return;
+			if (aui.threadListItem.getState().status !== "new") return;
+			hasInitializedRef.current = true;
+			initPromiseRef.current = aui.threadListItem.initialize();
+			const dispose = runtime.thread.unstable_on("runEnd", () => {
+				dispose();
+				aui.threadListItem.generateTitle();
+			});
+		});
 		useEffect(() => {
 			hasInitializedRef.current = false;
-			return runtime.threads.main.unstable_on("initialize", () => {
-				if (hasInitializedRef.current) return;
-				if (aui.threadListItem.getState().status !== "new") return;
-				hasInitializedRef.current = true;
-				initPromiseRef.current = aui.threadListItem.initialize();
-				const dispose = runtime.thread.unstable_on("runEnd", () => {
-					dispose();
-					aui.threadListItem.generateTitle();
-				});
-			});
-		}, [runtime, aui]);
+			return runtime.threads.main.unstable_on("initialize", handleInitialize);
+		}, [runtime]);
 		return /* @__PURE__ */ jsx(Fragment$1, { children });
 	};
 	_OuterActiveThreadProvider = memo(({ threadId, provider: Provider }) => {

package/dist/react/runtimes/RemoteThreadListHookInstanceManager.js.map

@@ -1 +1 @@
-{"version":3,"file":"RemoteThreadListHookInstanceManager.js","names":["FC","RefObject","useCallback","useRef","useEffect","useLayoutEffect","memo","PropsWithChildren","ComponentType","useMemo","Fragment","UseBoundStore","StoreApi","create","useAui","ThreadListItemRuntimeProvider","ThreadRuntimeCore","ThreadListRuntimeCore","AssistantRuntime","BaseSubscribable","ThreadRuntimeImpl","ThreadListRuntimeImpl","RemoteThreadListHook","RemoteThreadListHookInstance","runtime","ProviderRenderDetector","detectorRef","t0","$","_c","t1","t2","current","RemoteThreadListHookInstanceManager","useRuntimeHook","useRuntime","instances","Map","useAliveThreadsKeysChanged","parent","constructor","runtimeHook","startThreadRuntime","threadId","has","set","setState","Promise","resolve","reject","callback","instance","get","dispose","Error","subscribe","getThreadRuntimeCore","undefined","stopThreadRuntime","delete","_notifySubscribers","setRuntimeHook","newRuntimeHook","prevRuntimeHook","getState","_RuntimeBinder","children","threadBinding","thread","__internal_threadBinding","updateRuntime","aliveThread","isMounted","outerSubscribe","aui","initPromiseRef","hasInitializedRef","runtimeCore","setGetInitializePromise","Record","__internal_setGetInitializePromise","call","threads","main","unstable_on","state","threadListItem","status","initialize","generateTitle","_OuterActiveThreadProvider","provider","Provider","getItemById","process","env","NODE_ENV","id","setTimeout","console","warn","clearTimeout","__internal_RenderThreadRuntimes","Array","from","keys","map"],"sources":["../../../src/react/runtimes/RemoteThreadListHookInstanceManager.tsx"],"sourcesContent":["import {\n  type FC,\n  type RefObject,\n  useCallback,\n  useRef,\n  useEffect,\n  useLayoutEffect,\n  memo,\n  type PropsWithChildren,\n  type ComponentType,\n  useMemo,\n  Fragment,\n} from \"react\";\nimport { type UseBoundStore, type StoreApi, create } from \"zustand\";\nimport { useAui } from \"@assistant-ui/store\";\nimport { ThreadListItemRuntimeProvider } from \"../providers/ThreadListItemRuntimeProvider\";\nimport type { ThreadRuntimeCore } from \"../../runtime/interfaces/thread-runtime-core\";\nimport type { ThreadListRuntimeCore } from \"../../runtime/interfaces/thread-list-runtime-core\";\nimport type { AssistantRuntime } from \"../../runtime/api/assistant-runtime\";\nimport { BaseSubscribable } from \"../../subscribable/subscribable\";\nimport type { ThreadRuntimeImpl } from \"../../runtime/api/thread-runtime\";\nimport { ThreadListRuntimeImpl } from \"../../runtime/api/thread-list-runtime\";\n\ntype RemoteThreadListHook = () => AssistantRuntime;\n\ntype RemoteThreadListHookInstance = {\n  runtime?: ThreadRuntimeCore;\n};\n\nconst ProviderRenderDetector: FC<{\n  detectorRef: RefObject<boolean>;\n}> = ({ detectorRef }) => {\n  useLayoutEffect(() => {\n    detectorRef.current = true;\n  }, [detectorRef]);\n  return null;\n};\nexport class RemoteThreadListHookInstanceManager extends BaseSubscribable {\n  private useRuntimeHook: UseBoundStore<\n    StoreApi<{ useRuntime: RemoteThreadListHook }>\n  >;\n  private instances = new Map<string, RemoteThreadListHookInstance>();\n  private useAliveThreadsKeysChanged = create(() => ({}));\n  private parent: ThreadListRuntimeCore;\n\n  constructor(\n    runtimeHook: RemoteThreadListHook,\n    parent: ThreadListRuntimeCore,\n  ) {\n    super();\n    this.parent = parent;\n    this.useRuntimeHook = create(() => ({ useRuntime: runtimeHook }));\n  }\n\n  public startThreadRuntime(threadId: string) {\n    if (!this.instances.has(threadId)) {\n      this.instances.set(threadId, {});\n      this.useAliveThreadsKeysChanged.setState({}, true);\n    }\n\n    return new Promise<ThreadRuntimeCore>((resolve, reject) => {\n      const callback = () => {\n        const instance = this.instances.get(threadId);\n        if (!instance) {\n          dispose();\n          reject(new Error(\"Thread was deleted before runtime was started\"));\n        } else if (!instance.runtime) {\n          return; // misc update\n        } else {\n          dispose();\n          resolve(instance.runtime);\n        }\n      };\n      const dispose = this.subscribe(callback);\n      callback();\n    });\n  }\n\n  public getThreadRuntimeCore(threadId: string) {\n    const instance = this.instances.get(threadId);\n    if (!instance) return undefined;\n    return instance.runtime;\n  }\n\n  public stopThreadRuntime(threadId: string) {\n    this.instances.delete(threadId);\n    this.useAliveThreadsKeysChanged.setState({}, true);\n    this._notifySubscribers();\n  }\n\n  public setRuntimeHook(newRuntimeHook: RemoteThreadListHook) {\n    const prevRuntimeHook = this.useRuntimeHook.getState().useRuntime;\n    if (prevRuntimeHook !== newRuntimeHook) {\n      this.useRuntimeHook.setState({ useRuntime: newRuntimeHook }, true);\n    }\n  }\n\n  // Rendered as a child of the user's Provider so the runtime hook can\n  // read context the Provider injects (e.g. RuntimeAdapterProvider).\n  private _RuntimeBinder: FC<PropsWithChildren<{ threadId: string }>> = ({\n    threadId,\n    children,\n  }) => {\n    const { useRuntime } = this.useRuntimeHook();\n    const runtime = useRuntime();\n\n    const threadBinding = (runtime.thread as ThreadRuntimeImpl)\n      .__internal_threadBinding;\n\n    const updateRuntime = useCallback(() => {\n      const aliveThread = this.instances.get(threadId);\n      if (!aliveThread)\n        throw new Error(\n          `Thread \"${threadId}\" runtime binding not found. This is a bug in assistant-ui.`,\n        );\n\n      aliveThread.runtime = threadBinding.getState();\n      this._notifySubscribers();\n    }, [threadId, threadBinding]);\n\n    const isMounted = useRef(false);\n    if (!isMounted.current) {\n      updateRuntime();\n    }\n\n    useEffect(() => {\n      isMounted.current = true;\n      updateRuntime();\n      return threadBinding.outerSubscribe(updateRuntime);\n    }, [threadBinding, updateRuntime]);\n\n    const aui = useAui();\n    const initPromiseRef = useRef<Promise<unknown> | undefined>(undefined);\n    const hasInitializedRef = useRef(false);\n\n    useEffect(() => {\n      const runtimeCore = threadBinding.getState();\n      const setGetInitializePromise = (runtimeCore as Record<string, unknown>)\n        .__internal_setGetInitializePromise;\n      if (typeof setGetInitializePromise === \"function\") {\n        setGetInitializePromise.call(runtimeCore, () => initPromiseRef.current);\n      }\n    }, [threadBinding]);\n\n    useEffect(() => {\n      hasInitializedRef.current = false;\n      return runtime.threads.main.unstable_on(\"initialize\", () => {\n        if (hasInitializedRef.current) return;\n\n        const state = aui.threadListItem.getState();\n        if (state.status !== \"new\") return;\n        hasInitializedRef.current = true;\n\n        initPromiseRef.current = aui.threadListItem.initialize();\n\n        const dispose = runtime.thread.unstable_on(\"runEnd\", () => {\n          dispose();\n          aui.threadListItem.generateTitle();\n        });\n      });\n    }, [runtime, aui]);\n\n    return <>{children}</>;\n  };\n\n  private _OuterActiveThreadProvider: FC<{\n    threadId: string;\n    provider: ComponentType<PropsWithChildren>;\n  }> = memo(({ threadId, provider: Provider }) => {\n    const runtime = useMemo(\n      () => new ThreadListRuntimeImpl(this.parent).getItemById(threadId),\n      [threadId],\n    );\n\n    const detectorRef = useRef(false);\n    useEffect(() => {\n      if (process.env.NODE_ENV !== \"production\" && Provider !== Fragment) {\n        const id = setTimeout(() => {\n          if (!detectorRef.current) {\n            console.warn(\n              \"RemoteThreadListAdapter.unstable_Provider did not render its `children` synchronously. \" +\n                \"Render `children` on first commit; deferring them behind a loading state, Suspense boundary, \" +\n                \"or `useEffect` gate strands the runtime binder and leaves the thread without context.\",\n            );\n          }\n        }, 100);\n        return () => clearTimeout(id);\n      }\n      return undefined;\n    }, [Provider]);\n\n    return (\n      <ThreadListItemRuntimeProvider runtime={runtime}>\n        <Provider>\n          <this._RuntimeBinder threadId={threadId}>\n            <ProviderRenderDetector detectorRef={detectorRef} />\n          </this._RuntimeBinder>\n        </Provider>\n      </ThreadListItemRuntimeProvider>\n    );\n  });\n\n  public __internal_RenderThreadRuntimes: FC<{\n    provider: ComponentType<PropsWithChildren>;\n  }> = ({ provider }) => {\n    this.useAliveThreadsKeysChanged(); // trigger re-render on alive threads change\n\n    return Array.from(this.instances.keys()).map((threadId) => (\n      <this._OuterActiveThreadProvider\n        key={threadId}\n        threadId={threadId}\n        provider={provider}\n      />\n    ));\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"RemoteThreadListHookInstanceManager.js","names":["FC","RefObject","useCallback","useRef","useEffect","useEffectEvent","useLayoutEffect","memo","PropsWithChildren","ComponentType","useMemo","Fragment","UseBoundStore","StoreApi","create","useAui","ThreadListItemRuntimeProvider","ThreadRuntimeCore","ThreadListRuntimeCore","AssistantRuntime","BaseSubscribable","ThreadRuntimeImpl","ThreadListRuntimeImpl","RemoteThreadListHook","RemoteThreadListHookInstance","runtime","ProviderRenderDetector","detectorRef","t0","$","_c","t1","t2","current","RemoteThreadListHookInstanceManager","useRuntimeHook","useRuntime","instances","Map","useAliveThreadsKeysChanged","parent","constructor","runtimeHook","startThreadRuntime","threadId","has","set","setState","Promise","resolve","reject","callback","instance","get","dispose","Error","subscribe","getThreadRuntimeCore","undefined","stopThreadRuntime","delete","_notifySubscribers","setRuntimeHook","newRuntimeHook","prevRuntimeHook","getState","_RuntimeBinder","children","threadBinding","thread","__internal_threadBinding","updateRuntime","aliveThread","isMounted","outerSubscribe","aui","initPromiseRef","hasInitializedRef","runtimeCore","setGetInitializePromise","Record","__internal_setGetInitializePromise","call","handleInitialize","state","threadListItem","status","initialize","unstable_on","generateTitle","threads","main","_OuterActiveThreadProvider","provider","Provider","getItemById","process","env","NODE_ENV","id","setTimeout","console","warn","clearTimeout","__internal_RenderThreadRuntimes","Array","from","keys","map"],"sources":["../../../src/react/runtimes/RemoteThreadListHookInstanceManager.tsx"],"sourcesContent":["import {\n  type FC,\n  type RefObject,\n  useCallback,\n  useRef,\n  useEffect,\n  useEffectEvent,\n  useLayoutEffect,\n  memo,\n  type PropsWithChildren,\n  type ComponentType,\n  useMemo,\n  Fragment,\n} from \"react\";\nimport { type UseBoundStore, type StoreApi, create } from \"zustand\";\nimport { useAui } from \"@assistant-ui/store\";\nimport { ThreadListItemRuntimeProvider } from \"../providers/ThreadListItemRuntimeProvider\";\nimport type { ThreadRuntimeCore } from \"../../runtime/interfaces/thread-runtime-core\";\nimport type { ThreadListRuntimeCore } from \"../../runtime/interfaces/thread-list-runtime-core\";\nimport type { AssistantRuntime } from \"../../runtime/api/assistant-runtime\";\nimport { BaseSubscribable } from \"../../subscribable/subscribable\";\nimport type { ThreadRuntimeImpl } from \"../../runtime/api/thread-runtime\";\nimport { ThreadListRuntimeImpl } from \"../../runtime/api/thread-list-runtime\";\n\ntype RemoteThreadListHook = () => AssistantRuntime;\n\ntype RemoteThreadListHookInstance = {\n  runtime?: ThreadRuntimeCore;\n};\n\nconst ProviderRenderDetector: FC<{\n  detectorRef: RefObject<boolean>;\n}> = ({ detectorRef }) => {\n  useLayoutEffect(() => {\n    detectorRef.current = true;\n  }, [detectorRef]);\n  return null;\n};\nexport class RemoteThreadListHookInstanceManager extends BaseSubscribable {\n  private useRuntimeHook: UseBoundStore<\n    StoreApi<{ useRuntime: RemoteThreadListHook }>\n  >;\n  private instances = new Map<string, RemoteThreadListHookInstance>();\n  private useAliveThreadsKeysChanged = create(() => ({}));\n  private parent: ThreadListRuntimeCore;\n\n  constructor(\n    runtimeHook: RemoteThreadListHook,\n    parent: ThreadListRuntimeCore,\n  ) {\n    super();\n    this.parent = parent;\n    this.useRuntimeHook = create(() => ({ useRuntime: runtimeHook }));\n  }\n\n  public startThreadRuntime(threadId: string) {\n    if (!this.instances.has(threadId)) {\n      this.instances.set(threadId, {});\n      this.useAliveThreadsKeysChanged.setState({}, true);\n    }\n\n    return new Promise<ThreadRuntimeCore>((resolve, reject) => {\n      const callback = () => {\n        const instance = this.instances.get(threadId);\n        if (!instance) {\n          dispose();\n          reject(new Error(\"Thread was deleted before runtime was started\"));\n        } else if (!instance.runtime) {\n          return; // misc update\n        } else {\n          dispose();\n          resolve(instance.runtime);\n        }\n      };\n      const dispose = this.subscribe(callback);\n      callback();\n    });\n  }\n\n  public getThreadRuntimeCore(threadId: string) {\n    const instance = this.instances.get(threadId);\n    if (!instance) return undefined;\n    return instance.runtime;\n  }\n\n  public stopThreadRuntime(threadId: string) {\n    this.instances.delete(threadId);\n    this.useAliveThreadsKeysChanged.setState({}, true);\n    this._notifySubscribers();\n  }\n\n  public setRuntimeHook(newRuntimeHook: RemoteThreadListHook) {\n    const prevRuntimeHook = this.useRuntimeHook.getState().useRuntime;\n    if (prevRuntimeHook !== newRuntimeHook) {\n      this.useRuntimeHook.setState({ useRuntime: newRuntimeHook }, true);\n    }\n  }\n\n  // Rendered as a child of the user's Provider so the runtime hook can\n  // read context the Provider injects (e.g. RuntimeAdapterProvider).\n  private _RuntimeBinder: FC<PropsWithChildren<{ threadId: string }>> = ({\n    threadId,\n    children,\n  }) => {\n    const { useRuntime } = this.useRuntimeHook();\n    const runtime = useRuntime();\n\n    const threadBinding = (runtime.thread as ThreadRuntimeImpl)\n      .__internal_threadBinding;\n\n    const updateRuntime = useCallback(() => {\n      const aliveThread = this.instances.get(threadId);\n      if (!aliveThread)\n        throw new Error(\n          `Thread \"${threadId}\" runtime binding not found. This is a bug in assistant-ui.`,\n        );\n\n      aliveThread.runtime = threadBinding.getState();\n      this._notifySubscribers();\n    }, [threadId, threadBinding]);\n\n    const isMounted = useRef(false);\n    if (!isMounted.current) {\n      updateRuntime();\n    }\n\n    useEffect(() => {\n      isMounted.current = true;\n      updateRuntime();\n      return threadBinding.outerSubscribe(updateRuntime);\n    }, [threadBinding, updateRuntime]);\n\n    const aui = useAui();\n    const initPromiseRef = useRef<Promise<unknown> | undefined>(undefined);\n    const hasInitializedRef = useRef(false);\n\n    useEffect(() => {\n      const runtimeCore = threadBinding.getState();\n      const setGetInitializePromise = (runtimeCore as Record<string, unknown>)\n        .__internal_setGetInitializePromise;\n      if (typeof setGetInitializePromise === \"function\") {\n        setGetInitializePromise.call(runtimeCore, () => initPromiseRef.current);\n      }\n    }, [threadBinding]);\n\n    const handleInitialize = useEffectEvent(() => {\n      if (hasInitializedRef.current) return;\n\n      const state = aui.threadListItem.getState();\n      if (state.status !== \"new\") return;\n      hasInitializedRef.current = true;\n\n      initPromiseRef.current = aui.threadListItem.initialize();\n\n      const dispose = runtime.thread.unstable_on(\"runEnd\", () => {\n        dispose();\n        aui.threadListItem.generateTitle();\n      });\n    });\n\n    useEffect(() => {\n      hasInitializedRef.current = false;\n      return runtime.threads.main.unstable_on(\"initialize\", handleInitialize);\n    }, [runtime]);\n\n    return <>{children}</>;\n  };\n\n  private _OuterActiveThreadProvider: FC<{\n    threadId: string;\n    provider: ComponentType<PropsWithChildren>;\n  }> = memo(({ threadId, provider: Provider }) => {\n    const runtime = useMemo(\n      () => new ThreadListRuntimeImpl(this.parent).getItemById(threadId),\n      [threadId],\n    );\n\n    const detectorRef = useRef(false);\n    useEffect(() => {\n      if (process.env.NODE_ENV !== \"production\" && Provider !== Fragment) {\n        const id = setTimeout(() => {\n          if (!detectorRef.current) {\n            console.warn(\n              \"RemoteThreadListAdapter.unstable_Provider did not render its `children` synchronously. \" +\n                \"Render `children` on first commit; deferring them behind a loading state, Suspense boundary, \" +\n                \"or `useEffect` gate strands the runtime binder and leaves the thread without context.\",\n            );\n          }\n        }, 100);\n        return () => clearTimeout(id);\n      }\n      return undefined;\n    }, [Provider]);\n\n    return (\n      <ThreadListItemRuntimeProvider runtime={runtime}>\n        <Provider>\n          <this._RuntimeBinder threadId={threadId}>\n            <ProviderRenderDetector detectorRef={detectorRef} />\n          </this._RuntimeBinder>\n        </Provider>\n      </ThreadListItemRuntimeProvider>\n    );\n  });\n\n  public __internal_RenderThreadRuntimes: FC<{\n    provider: ComponentType<PropsWithChildren>;\n  }> = ({ provider }) => {\n    this.useAliveThreadsKeysChanged(); // trigger re-render on alive threads change\n\n    return Array.from(this.instances.keys()).map((threadId) => (\n      <this._OuterActiveThreadProvider\n        key={threadId}\n        threadId={threadId}\n        provider={provider}\n      />\n    ));\n  };\n}\n"],"mappings":"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"}

package/dist/react/runtimes/RemoteThreadListThreadListRuntimeCore.d.ts

@@ -151,8 +151,11 @@ declare class RemoteThreadListThreadListRuntimeCore extends BaseSubscribable imp
   switchToThread(threadIdOrRemoteId: string, options?: {
     unarchive?: boolean;
   }): Promise<void>;
+  private _startSwitchToThread;
   private _switchToThread;
   switchToNewThread(): Promise<void>;
+  private _switchToThreadFromProp;
+  private _startSwitchToNewThread;
   private _switchToNewThread;
   initialize: (threadId: string) => Promise<{
     remoteId: string;

package/dist/react/runtimes/RemoteThreadListThreadListRuntimeCore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RemoteThreadListThreadListRuntimeCore.d.ts","names":[],"sources":["../../../src/react/runtimes/RemoteThreadListThreadListRuntimeCore.tsx"],"mappings":";;;;;;;;;;;;;;;;;cAoCa,8CACH,4BACG;UAEH;mBACS;UAET;UACA;UACA;UACA;UACA;UAEA;mBACS;MAWN,eAAW,SAAA,OAzBX,mBAyBW;EAIf,yBAAqB;EAsDrB,YAAY;mBAmDF;EAGf,YAAA,SAAS,yBACT,iBAAiB;UAoBX;UACA;EAED,sBAAsB,SAAS;EA0B/B;EAUA,UAAM;MAWF;MAIA;MAIA;MAIA;MAIA;MAIA;MAIA;cAMC;UAKJ;UAEA;EAOD,4BAAwB;;;eAvDlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6DN,qBAAqB,6BAA0B;;;eANvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBxB,YAAY,6BAA0B;EAItC,eACL,4BACA;IAAY;MACX;UAOW;EAsGP,qBAAqB;UAOd;EA0CP,aAAoB,qBAAgB;;;;EAwDpC,gBAAuB,qBAAgB;EAmCvC,OAAO,4BAA4B,mBAAmB;EA6BtD,aACL,4BACA,QAAQ,sCACP;UAiDW;EAsBD,QAAQ,6BAA0B;EAmBxC,UAAU,6BAA6B;EAsBjC,OAAO,6BAA0B;EAoBjC,OAAO,6BAA6B;UAUzC;EAED,4BAA4B"}
+{"version":3,"file":"RemoteThreadListThreadListRuntimeCore.d.ts","names":[],"sources":["../../../src/react/runtimes/RemoteThreadListThreadListRuntimeCore.tsx"],"mappings":";;;;;;;;;;;;;;;;;cAoCa,8CACH,4BACG;UAEH;mBACS;UAET;UACA;UACA;UACA;UACA;UAEA;mBACS;MAWN,eAAW,SAAA,OAzBX,mBAyBW;EAIf,yBAAqB;EAsDrB,YAAY;mBAmDF;EAGf,YAAA,SAAS,yBACT,iBAAiB;UAoBX;UACA;EAED,sBAAsB,SAAS;EAkC/B;EAgBA,UAAM;MAWF;MAIA;MAIA;MAIA;MAIA;MAIA;MAIA;cAMC;UAKJ;UAEA;EASD,4BAAwB;;;eAzDlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+DN,qBAAqB,6BAA0B;;;eANvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBxB,YAAY,6BAA0B;EAItC,eACL,4BACA;IAAY;MACX;UAIK;UAgBM;EAuGP,qBAAqB;UAIpB;UAMA;UAOM;EA6CP,aAAoB,qBAAgB;;;;EAwDpC,gBAAuB,qBAAgB;EAmCvC,OAAO,4BAA4B,mBAAmB;EA6BtD,aACL,4BACA,QAAQ,sCACP;UAiDW;EAsBD,QAAQ,6BAA0B;EAmBxC,UAAU,6BAA6B;EAsBjC,OAAO,6BAA0B;EAoBjC,OAAO,6BAA6B;UAUzC;EAED,4BAA4B"}

package/dist/react/runtimes/RemoteThreadListThreadListRuntimeCore.js

@@ -139,6 +139,7 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 	__internal_setOptions(options) {
 		if (this._options === options) return;
 		const adapterChanged = this._options !== void 0 && this._options.adapter !== options.adapter;
+		const controlledThreadIdChanged = this._initialThreadLoaded && this._options !== void 0 && this._options.threadId !== options.threadId;
 		this._options = options;
 		const Provider = options.adapter.unstable_Provider ?? Fragment;
 		if (Provider !== this.useProvider.getState().Provider) this.useProvider.setState({ Provider }, true);
@@ -152,14 +153,14 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 				cursor: void 0
 			});
 		}
+		if (controlledThreadIdChanged) this._switchToThreadFromProp(options.threadId).catch(() => {});
 	}
 	__internal_load() {
 		this.getLoadThreadsPromise();
+		if (this._initialThreadLoaded) return;
+		this._initialThreadLoaded = true;
 		const startThreadId = this._options.threadId ?? this._options.initialThreadId;
-		if (!this._initialThreadLoaded && startThreadId) {
-			this._initialThreadLoaded = true;
-			this.switchToThread(startThreadId).catch(() => {});
-		}
+		if (startThreadId !== void 0) (this._options.threadId !== void 0 ? this._switchToThreadFromProp(startThreadId) : this.switchToThread(startThreadId)).catch(() => {});
 	}
 	reload() {
 		this._loadGeneration++;
@@ -197,11 +198,11 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		return getThreadData(this._state.value, this._mainThreadId)?.remoteId;
 	}
 	_lastNotifiedThreadId = void 0;
-	_notifyThreadIdChange() {
+	_notifyThreadIdChange(emit = true) {
 		const threadId = this._mainThreadRemoteId;
 		if (this._lastNotifiedThreadId === threadId) return;
 		this._lastNotifiedThreadId = threadId;
-		this._options.onThreadIdChange?.(threadId);
+		if (emit) this._options.onThreadIdChange?.(threadId);
 	}
 	getMainThreadRuntimeCore() {
 		const result = this._hookManager.getThreadRuntimeCore(this._mainThreadId);
@@ -219,12 +220,15 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		return getThreadData(this._state.value, threadIdOrRemoteId);
 	}
 	switchToThread(threadIdOrRemoteId, options) {
+		return this._startSwitchToThread(threadIdOrRemoteId, options, true);
+	}
+	_startSwitchToThread(threadIdOrRemoteId, options, emitThreadIdChange) {
 		const generation = ++this._switchGeneration;
-		const task = this._switchToThread(threadIdOrRemoteId, options, generation);
+		const task = this._switchToThread(threadIdOrRemoteId, options, generation, emitThreadIdChange);
 		this._switchTask = task;
 		return task;
 	}
-	async _switchToThread(threadIdOrRemoteId, options, generation) {
+	async _switchToThread(threadIdOrRemoteId, options, generation, emitThreadIdChange) {
 		let data = this.getItemById(threadIdOrRemoteId);
 		if (!data) {
 			const remoteMetadata = await this._options.adapter.fetch(threadIdOrRemoteId);
@@ -278,15 +282,21 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		}
 		this._mainThreadId = data.id;
 		this._notifySubscribers();
-		this._notifyThreadIdChange();
+		this._notifyThreadIdChange(emitThreadIdChange);
 	}
 	switchToNewThread() {
+		return this._startSwitchToNewThread(true);
+	}
+	_switchToThreadFromProp(threadId) {
+		return threadId !== void 0 ? this._startSwitchToThread(threadId, void 0, false) : this._startSwitchToNewThread(false);
+	}
+	_startSwitchToNewThread(emitThreadIdChange) {
 		const generation = ++this._switchGeneration;
-		const task = this._switchToNewThread(generation);
+		const task = this._switchToNewThread(generation, emitThreadIdChange);
 		this._switchTask = task;
 		return task;
 	}
-	async _switchToNewThread(generation) {
+	async _switchToNewThread(generation, emitThreadIdChange) {
 		while (this._state.baseValue.newThreadId !== void 0 && this._state.value.newThreadId === void 0) {
 			await this._state.waitForUpdate();
 			if (generation !== this._switchGeneration) return;
@@ -318,7 +328,7 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 				}
 			});
 		}
-		return this._switchToThread(id, void 0, generation);
+		return this._switchToThread(id, void 0, generation, emitThreadIdChange);
 	}
 	initialize = async (threadId) => {
 		if (this._state.value.newThreadId !== threadId) {