@assistant-ui/core 0.3.18 → 0.3.20

package/dist/react/utils/getMessageQuote.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getMessageQuote.d.ts","names":[],"sources":["../../../src/react/utils/getMessageQuote.ts"],"mappings":";;KAEK;EACH;IACE;;;cAIS,kBACX,OAAO,sBACN"}
+{"version":3,"file":"getMessageQuote.d.ts","names":[],"sources":["../../../src/react/utils/getMessageQuote.ts"],"mappings":";;KAEK;EACH;IACE;;;qBAIS,kBACX,OAAO,sBACN"}

package/dist/react/utils/groupParts.d.ts

@@ -7,7 +7,7 @@ import { ToolsState } from "../types/scopes/tools.js";
  * `groupBy` can resolve registry-driven grouping (e.g. standalone tool calls)
  * without the part itself having to carry that information.
  */
-type GroupByContext = {
+export type GroupByContext = {
   /** Tool UIs registered in the tool-UI registry, keyed by tool name. */
   readonly toolUIs?: ToolsState["toolUIs"];
 };
@@ -29,7 +29,7 @@ type GroupByContext = {
  * `[parts, memoKey]` across renders — even when the helper call site
  * reconstructs the function each render.
  */
-declare const GROUPBY_MEMO_KEY: unique symbol;
+export declare const GROUPBY_MEMO_KEY: unique symbol;
 /**
  * Synthetic part-type keys recognized by {@link groupPartByType}, in
  * addition to real {@link PartState} types:
@@ -41,8 +41,10 @@ declare const GROUPBY_MEMO_KEY: unique symbol;
  *   `display: "standalone"`). Resolving the registry-driven cases reads the
  *   {@link GroupByContext} passed to the `groupBy` function. Takes precedence
  *   over the `"tool-call"` entry.
+ *
+ * A `"tool-call:<name>"` entry matches tool calls by tool name and takes precedence over the plain `"tool-call"` entry, while `"standalone-tool-call"` still wins first.
  */
-type GroupPartType = PartState["type"] | "standalone-tool-call";
+type GroupPartType = PartState["type"] | "standalone-tool-call" | `tool-call:${string}`;
 /**
  * Build a `groupBy` from a `part.type → group-key path` lookup.
  * Parts whose type isn't in the map are left ungrouped. The returned
@@ -56,11 +58,14 @@ type GroupPartType = PartState["type"] | "standalone-tool-call";
  * {@link GroupByContext} that `<MessagePrimitive.GroupedParts>` passes to the
  * `groupBy` function — the helper needs nothing threaded into it.
  *
+ * A `"tool-call:<name>"` entry matches tool calls by tool name and takes precedence over the plain `"tool-call"` entry, while `"standalone-tool-call"` still wins first.
+ *
  * @example
  * ```tsx
  * <MessagePrimitive.GroupedParts
  *   groupBy={groupPartByType({
  *     reasoning: ["group-thought", "group-reasoning"],
+ *     "tool-call:task": ["group-subagents"],
  *     "tool-call": ["group-thought", "group-tool"],
  *     "standalone-tool-call": [],
  *   })}
@@ -69,9 +74,9 @@ type GroupPartType = PartState["type"] | "standalone-tool-call";
  * </MessagePrimitive.GroupedParts>
  * ```
  */
-declare const groupPartByType: <TKey extends `group-${string}`>(map: Partial<Readonly<Record<GroupPartType, readonly TKey[]>>>) => ((part: PartState, context?: GroupByContext) => readonly TKey[]);
-type GroupNode = GroupNodeGroup | GroupNodePart;
-interface GroupNodeGroup {
+export declare const groupPartByType: <TKey extends `group-${string}`>(map: Partial<Readonly<Record<GroupPartType, readonly TKey[]>>>) => ((part: PartState, context?: GroupByContext) => readonly TKey[]);
+export type GroupNode = GroupNodeGroup | GroupNodePart;
+export interface GroupNodeGroup {
   readonly type: "group";
   /** Current-level group key (last segment of the path). */
   readonly key: string;
@@ -86,7 +91,7 @@ interface GroupNodeGroup {
   readonly indices: readonly number[];
   readonly children: readonly GroupNode[];
 }
-interface GroupNodePart {
+export interface GroupNodePart {
   readonly type: "part";
   /** Index of the part in the message. */
   readonly index: number;
@@ -105,7 +110,6 @@ interface GroupNodePart {
  * `partIds[i]` optionally carries a stable identity for part `i` (e.g. a
  * tool call id), from which nodes derive an `idKey`.
  */
-declare const buildGroupTree: (paths: readonly (readonly string[])[], partIds?: readonly (string | undefined)[]) => readonly GroupNode[];
+export declare const buildGroupTree: (paths: readonly (readonly string[])[], partIds?: readonly (string | undefined)[]) => readonly GroupNode[];
 //#endregion
-export { GROUPBY_MEMO_KEY, GroupByContext, GroupNode, GroupNodeGroup, GroupNodePart, buildGroupTree, groupPartByType };
 //# sourceMappingURL=groupParts.d.ts.map

package/dist/react/utils/groupParts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"groupParts.d.ts","names":[],"sources":["../../../src/react/utils/groupParts.ts"],"mappings":";;;;;;;;;KAUY;;WAED,UAAU;;;;;;;;;;;;;;;;;;;;cAsBR;;;;;;;;;;;;;KAgBR,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4BR,kBAAmB,gCAC9B,KAAK,QAAQ,SAAS,OAAO,wBAAwB,gBAClD,MAAM,WAAW,UAAU,4BAA4B;KA2BhD,YAAY,iBAAiB;UAExB;WACN;;WAEA;;WAEA;;;;;WAKA;;WAEA;WACA,mBAAmB;;UAGb;WACN;;WAEA;;WAEA;;;;;WAKA;;;;;;;;;cAiCE,iBACX,uCACA,uDACU"}
+{"version":3,"file":"groupParts.d.ts","names":[],"sources":["../../../src/react/utils/groupParts.ts"],"mappings":";;;;;;;;;YAUY;;WAED,UAAU;;;;;;;;;;;;;;;;;;;;qBAsBR;;;;;;;;;;;;;;;KAkBR,gBACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAiCS,kBAAmB,gCAC9B,KAAK,QAAQ,SAAS,OAAO,wBAAwB,gBAClD,MAAM,WAAW,UAAU,4BAA4B;YA8BhD,YAAY,iBAAiB;iBAExB;WACN;;WAEA;;WAEA;;;;;WAKA;;WAEA;WACA,mBAAmB;;iBAGb;WACN;;WAEA;;WAEA;;;;;WAKA;;;;;;;;;qBAiCE,iBACX,uCACA,uDACU"}

package/dist/react/utils/groupParts.js

@@ -32,11 +32,14 @@ const GROUPBY_MEMO_KEY = Symbol.for("@assistant-ui/groupBy.memoKey");
 * {@link GroupByContext} that `<MessagePrimitive.GroupedParts>` passes to the
 * `groupBy` function — the helper needs nothing threaded into it.
 *
+* A `"tool-call:<name>"` entry matches tool calls by tool name and takes precedence over the plain `"tool-call"` entry, while `"standalone-tool-call"` still wins first.
+*
 * @example
 * ```tsx
 * <MessagePrimitive.GroupedParts
 *   groupBy={groupPartByType({
 *     reasoning: ["group-thought", "group-reasoning"],
+*     "tool-call:task": ["group-subagents"],
 *     "tool-call": ["group-thought", "group-tool"],
 *     "standalone-tool-call": [],
 *   })}
@@ -50,6 +53,9 @@ const groupPartByType = (map) => {
 	const fn = ((part, context) => {
 		if (part.type === "tool-call") {
 			if ((isMcpAppUri(part.mcp?.app?.resourceUri) || (context?.toolUIs?.[part.toolName]?.[0]?.standalone ?? false)) && lookup["standalone-tool-call"] !== void 0) return lookup["standalone-tool-call"];
+			const toolCallPath = lookup[`tool-call:${part.toolName}`];
+			if (toolCallPath !== void 0) return toolCallPath;
+			return lookup["tool-call"] ?? [];
 		}
 		return lookup[part.type] ?? [];
 	});

package/dist/react/utils/groupParts.js.map

@@ -1 +1 @@
-{"version":3,"file":"groupParts.js","names":["isMcpAppUri","PartState","ToolsState","GroupByContext","toolUIs","GROUPBY_MEMO_KEY","Symbol","for","GroupPartType","groupPartByType","map","Partial","Readonly","Record","TKey","part","context","lookup","fn","type","isMcpApp","mcp","app","resourceUri","isStandalone","toolName","standalone","undefined","sortedKeys","Object","keys","sort","sortedEntries","k","JSON","stringify","GroupNode","GroupNodeGroup","GroupNodePart","key","nodeKey","idKey","indices","children","index","BuildFrame","nextChildIdx","claimed","Set","makeChildNodeKey","parent","idx","String","claimIdKey","frame","id","has","add","buildGroupTree","paths","partIds","root","stack","closeTop","closing","pop","length","push","i","path","common","top","s"],"sources":["../../../src/react/utils/groupParts.ts"],"sourcesContent":["import { isMcpAppUri } from \"../../types/message\";\nimport type { PartState } from \"../../store/scopes/part\";\nimport type { ToolsState } from \"../types/scopes/tools\";\n\n/**\n * Registry context passed to a `groupBy` function as its second argument by\n * `<MessagePrimitive.GroupedParts>`. Carries the live tool-UI registry so a\n * `groupBy` can resolve registry-driven grouping (e.g. standalone tool calls)\n * without the part itself having to carry that information.\n */\nexport type GroupByContext = {\n  /** Tool UIs registered in the tool-UI registry, keyed by tool name. */\n  readonly toolUIs?: ToolsState[\"toolUIs\"];\n};\n\n/**\n * Hierarchical adjacent-coalescing grouping for message parts.\n *\n * Given a group path per part (from `groupBy`), builds a tree of group\n * nodes wrapping individual parts. Adjacent parts sharing a path prefix\n * coalesce into the same group; ungrouped parts are direct children of\n * the root.\n *\n * Each node gets a structural `nodeKey` built from sibling indices\n * (`\"0.1.0\"`), stable under append-only streaming.\n */\n\n/**\n * Symbol attached to memoizable `groupBy` functions (e.g. those returned\n * by {@link groupPartByType}). Carries a string fingerprint of the config\n * so `MessagePrimitive.GroupedParts` can memo the tree on\n * `[parts, memoKey]` across renders — even when the helper call site\n * reconstructs the function each render.\n */\nexport const GROUPBY_MEMO_KEY: unique symbol = Symbol.for(\n  \"@assistant-ui/groupBy.memoKey\",\n);\n\n/**\n * Synthetic part-type keys recognized by {@link groupPartByType}, in\n * addition to real {@link PartState} types:\n *\n * - `\"standalone-tool-call\"` — a tool-call whose UI should be presented on its\n *   own, outside the chain-of-thought grouping. Matches MCP-app tool calls plus\n *   any tool-call whose registered UI opts into standalone display (human\n *   tools, the built-in generative-UI tool, and tools that set\n *   `display: \"standalone\"`). Resolving the registry-driven cases reads the\n *   {@link GroupByContext} passed to the `groupBy` function. Takes precedence\n *   over the `\"tool-call\"` entry.\n */\ntype GroupPartType = PartState[\"type\"] | \"standalone-tool-call\";\n\n/**\n * Build a `groupBy` from a `part.type → group-key path` lookup.\n * Parts whose type isn't in the map are left ungrouped. The returned\n * function carries a stable {@link GROUPBY_MEMO_KEY} fingerprint so\n * `<MessagePrimitive.GroupedParts>` can memoize its tree across renders.\n *\n * The synthetic `\"standalone-tool-call\"` key matches tool calls that should\n * render outside the chain-of-thought grouping. MCP-app calls are detected from\n * the part alone; the registry-driven cases (human tools, the generative-UI\n * tool, `display: \"standalone\"` opt-ins) are resolved from the\n * {@link GroupByContext} that `<MessagePrimitive.GroupedParts>` passes to the\n * `groupBy` function — the helper needs nothing threaded into it.\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 *     \"standalone-tool-call\": [],\n *   })}\n * >\n *   {({ part, children }) => { ... }}\n * </MessagePrimitive.GroupedParts>\n * ```\n */\nexport const groupPartByType = <TKey extends `group-${string}`>(\n  map: Partial<Readonly<Record<GroupPartType, readonly TKey[]>>>,\n): ((part: PartState, context?: GroupByContext) => readonly TKey[]) => {\n  const lookup = map as Readonly<Record<string, readonly TKey[] | undefined>>;\n  const fn = ((part, context) => {\n    if (part.type === \"tool-call\") {\n      const isMcpApp = isMcpAppUri(part.mcp?.app?.resourceUri);\n      // Read the first registration's flag — the same one `resolveToolRender`\n      // renders — so grouping and rendering never disagree for a tool name.\n      const isStandalone =\n        isMcpApp ||\n        (context?.toolUIs?.[part.toolName]?.[0]?.standalone ?? false);\n      if (isStandalone && lookup[\"standalone-tool-call\"] !== undefined) {\n        return lookup[\"standalone-tool-call\"]!;\n      }\n    }\n    return lookup[part.type] ?? [];\n  }) as ((part: PartState, context?: GroupByContext) => readonly TKey[]) & {\n    [GROUPBY_MEMO_KEY]?: string;\n  };\n  // Sort keys so the fingerprint is insensitive to map insertion order —\n  // two maps with the same key/value pairs but different declaration order\n  // would otherwise hash differently and invalidate the memo unnecessarily.\n  const sortedKeys = Object.keys(map).sort();\n  const sortedEntries = sortedKeys.map((k) => [k, map[k as keyof typeof map]]);\n  fn[GROUPBY_MEMO_KEY] = `groupPartByType:${JSON.stringify(sortedEntries)}`;\n  return fn;\n};\n\nexport type GroupNode = GroupNodeGroup | GroupNodePart;\n\nexport interface GroupNodeGroup {\n  readonly type: \"group\";\n  /** Current-level group key (last segment of the path). */\n  readonly key: string;\n  /** Structural React key: sibling-index path, e.g. `\"0.1.0\"`. */\n  readonly nodeKey: string;\n  /**\n   * Identity key (`\"id:<partId>\"`) from the group's first part; undefined\n   * when absent or already claimed by an earlier sibling.\n   */\n  readonly idKey: string | undefined;\n  /** Indices of parts in this subtree, in order. */\n  readonly indices: readonly number[];\n  readonly children: readonly GroupNode[];\n}\n\nexport interface GroupNodePart {\n  readonly type: \"part\";\n  /** Index of the part in the message. */\n  readonly index: number;\n  /** Structural React key: sibling-index path within parent. */\n  readonly nodeKey: string;\n  /**\n   * Identity key (`\"id:<partId>\"`); undefined when absent or already\n   * claimed by an earlier sibling.\n   */\n  readonly idKey: string | undefined;\n}\n\ninterface BuildFrame {\n  key: string;\n  nodeKey: string;\n  indices: number[];\n  children: GroupNode[];\n  nextChildIdx: number;\n  claimed: Set<string>;\n}\n\nconst makeChildNodeKey = (parent: BuildFrame): string => {\n  const idx = parent.nextChildIdx++;\n  return parent.nodeKey === \"\" ? String(idx) : `${parent.nodeKey}.${idx}`;\n};\n\nconst claimIdKey = (\n  frame: BuildFrame,\n  id: string | undefined,\n): string | undefined => {\n  if (id === undefined || frame.claimed.has(id)) return undefined;\n  frame.claimed.add(id);\n  return `id:${id}`;\n};\n\n/**\n * Build the group tree from an array of normalized group paths.\n * `paths[i]` is the path for part `i`. The output tree contains one\n * `part` node per part and one `group` node per coalesced run.\n * `partIds[i]` optionally carries a stable identity for part `i` (e.g. a\n * tool call id), from which nodes derive an `idKey`.\n */\nexport const buildGroupTree = (\n  paths: readonly (readonly string[])[],\n  partIds?: readonly (string | undefined)[],\n): readonly GroupNode[] => {\n  const root: BuildFrame = {\n    key: \"\",\n    nodeKey: \"\",\n    indices: [],\n    children: [],\n    nextChildIdx: 0,\n    claimed: new Set(),\n  };\n  const stack: BuildFrame[] = [root];\n\n  const closeTop = (): void => {\n    const closing = stack.pop()!;\n    const parent = stack[stack.length - 1]!;\n    parent.children.push({\n      type: \"group\",\n      key: closing.key,\n      nodeKey: closing.nodeKey,\n      idKey: claimIdKey(parent, partIds?.[closing.indices[0]!]),\n      indices: closing.indices,\n      children: closing.children,\n    });\n  };\n\n  for (let i = 0; i < paths.length; i++) {\n    const path = paths[i]!;\n\n    // Find the longest prefix shared between currently-open groups\n    // (excluding root) and this part's path.\n    let common = 0;\n    while (\n      common < stack.length - 1 &&\n      common < path.length &&\n      stack[common + 1]!.key === path[common]\n    ) {\n      common++;\n    }\n\n    // Close groups not on this path.\n    while (stack.length - 1 > common) {\n      closeTop();\n    }\n\n    // Open new groups down to the part's depth.\n    while (stack.length - 1 < path.length) {\n      const parent = stack[stack.length - 1]!;\n      stack.push({\n        key: path[stack.length - 1]!,\n        nodeKey: makeChildNodeKey(parent),\n        indices: [],\n        children: [],\n        nextChildIdx: 0,\n        claimed: new Set(),\n      });\n    }\n\n    // Push this part as a leaf in the deepest open group (or root).\n    const top = stack[stack.length - 1]!;\n    top.children.push({\n      type: \"part\",\n      index: i,\n      nodeKey: makeChildNodeKey(top),\n      idKey: claimIdKey(top, partIds?.[i]),\n    });\n\n    // Record the part index in every open ancestor group.\n    for (let s = 1; s < stack.length; s++) {\n      stack[s]!.indices.push(i);\n    }\n  }\n\n  // Close any still-open groups.\n  while (stack.length > 1) {\n    closeTop();\n  }\n\n  return root.children;\n};\n"],"mappings":"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"}
+{"version":3,"file":"groupParts.js","names":["isMcpAppUri","PartState","ToolsState","GroupByContext","toolUIs","GROUPBY_MEMO_KEY","Symbol","for","GroupPartType","groupPartByType","map","Partial","Readonly","Record","TKey","part","context","lookup","fn","type","isMcpApp","mcp","app","resourceUri","isStandalone","toolName","standalone","undefined","toolCallPath","sortedKeys","Object","keys","sort","sortedEntries","k","JSON","stringify","GroupNode","GroupNodeGroup","GroupNodePart","key","nodeKey","idKey","indices","children","index","BuildFrame","nextChildIdx","claimed","Set","makeChildNodeKey","parent","idx","String","claimIdKey","frame","id","has","add","buildGroupTree","paths","partIds","root","stack","closeTop","closing","pop","length","push","i","path","common","top","s"],"sources":["../../../src/react/utils/groupParts.ts"],"sourcesContent":["import { isMcpAppUri } from \"../../types/message\";\nimport type { PartState } from \"../../store/scopes/part\";\nimport type { ToolsState } from \"../types/scopes/tools\";\n\n/**\n * Registry context passed to a `groupBy` function as its second argument by\n * `<MessagePrimitive.GroupedParts>`. Carries the live tool-UI registry so a\n * `groupBy` can resolve registry-driven grouping (e.g. standalone tool calls)\n * without the part itself having to carry that information.\n */\nexport type GroupByContext = {\n  /** Tool UIs registered in the tool-UI registry, keyed by tool name. */\n  readonly toolUIs?: ToolsState[\"toolUIs\"];\n};\n\n/**\n * Hierarchical adjacent-coalescing grouping for message parts.\n *\n * Given a group path per part (from `groupBy`), builds a tree of group\n * nodes wrapping individual parts. Adjacent parts sharing a path prefix\n * coalesce into the same group; ungrouped parts are direct children of\n * the root.\n *\n * Each node gets a structural `nodeKey` built from sibling indices\n * (`\"0.1.0\"`), stable under append-only streaming.\n */\n\n/**\n * Symbol attached to memoizable `groupBy` functions (e.g. those returned\n * by {@link groupPartByType}). Carries a string fingerprint of the config\n * so `MessagePrimitive.GroupedParts` can memo the tree on\n * `[parts, memoKey]` across renders — even when the helper call site\n * reconstructs the function each render.\n */\nexport const GROUPBY_MEMO_KEY: unique symbol = Symbol.for(\n  \"@assistant-ui/groupBy.memoKey\",\n);\n\n/**\n * Synthetic part-type keys recognized by {@link groupPartByType}, in\n * addition to real {@link PartState} types:\n *\n * - `\"standalone-tool-call\"` — a tool-call whose UI should be presented on its\n *   own, outside the chain-of-thought grouping. Matches MCP-app tool calls plus\n *   any tool-call whose registered UI opts into standalone display (human\n *   tools, the built-in generative-UI tool, and tools that set\n *   `display: \"standalone\"`). Resolving the registry-driven cases reads the\n *   {@link GroupByContext} passed to the `groupBy` function. Takes precedence\n *   over the `\"tool-call\"` entry.\n *\n * A `\"tool-call:<name>\"` entry matches tool calls by tool name and takes precedence over the plain `\"tool-call\"` entry, while `\"standalone-tool-call\"` still wins first.\n */\ntype GroupPartType =\n  | PartState[\"type\"]\n  | \"standalone-tool-call\"\n  | `tool-call:${string}`;\n\n/**\n * Build a `groupBy` from a `part.type → group-key path` lookup.\n * Parts whose type isn't in the map are left ungrouped. The returned\n * function carries a stable {@link GROUPBY_MEMO_KEY} fingerprint so\n * `<MessagePrimitive.GroupedParts>` can memoize its tree across renders.\n *\n * The synthetic `\"standalone-tool-call\"` key matches tool calls that should\n * render outside the chain-of-thought grouping. MCP-app calls are detected from\n * the part alone; the registry-driven cases (human tools, the generative-UI\n * tool, `display: \"standalone\"` opt-ins) are resolved from the\n * {@link GroupByContext} that `<MessagePrimitive.GroupedParts>` passes to the\n * `groupBy` function — the helper needs nothing threaded into it.\n *\n * A `\"tool-call:<name>\"` entry matches tool calls by tool name and takes precedence over the plain `\"tool-call\"` entry, while `\"standalone-tool-call\"` still wins first.\n *\n * @example\n * ```tsx\n * <MessagePrimitive.GroupedParts\n *   groupBy={groupPartByType({\n *     reasoning: [\"group-thought\", \"group-reasoning\"],\n *     \"tool-call:task\": [\"group-subagents\"],\n *     \"tool-call\": [\"group-thought\", \"group-tool\"],\n *     \"standalone-tool-call\": [],\n *   })}\n * >\n *   {({ part, children }) => { ... }}\n * </MessagePrimitive.GroupedParts>\n * ```\n */\nexport const groupPartByType = <TKey extends `group-${string}`>(\n  map: Partial<Readonly<Record<GroupPartType, readonly TKey[]>>>,\n): ((part: PartState, context?: GroupByContext) => readonly TKey[]) => {\n  const lookup = map as Readonly<Record<string, readonly TKey[] | undefined>>;\n  const fn = ((part, context) => {\n    if (part.type === \"tool-call\") {\n      const isMcpApp = isMcpAppUri(part.mcp?.app?.resourceUri);\n      // Read the first registration's flag — the same one `resolveToolRender`\n      // renders — so grouping and rendering never disagree for a tool name.\n      const isStandalone =\n        isMcpApp ||\n        (context?.toolUIs?.[part.toolName]?.[0]?.standalone ?? false);\n      if (isStandalone && lookup[\"standalone-tool-call\"] !== undefined) {\n        return lookup[\"standalone-tool-call\"]!;\n      }\n      const toolCallPath = lookup[`tool-call:${part.toolName}`];\n      if (toolCallPath !== undefined) return toolCallPath;\n      return lookup[\"tool-call\"] ?? [];\n    }\n    return lookup[part.type] ?? [];\n  }) as ((part: PartState, context?: GroupByContext) => readonly TKey[]) & {\n    [GROUPBY_MEMO_KEY]?: string;\n  };\n  // Sort keys so the fingerprint is insensitive to map insertion order —\n  // two maps with the same key/value pairs but different declaration order\n  // would otherwise hash differently and invalidate the memo unnecessarily.\n  const sortedKeys = Object.keys(map).sort();\n  const sortedEntries = sortedKeys.map((k) => [k, map[k as keyof typeof map]]);\n  fn[GROUPBY_MEMO_KEY] = `groupPartByType:${JSON.stringify(sortedEntries)}`;\n  return fn;\n};\n\nexport type GroupNode = GroupNodeGroup | GroupNodePart;\n\nexport interface GroupNodeGroup {\n  readonly type: \"group\";\n  /** Current-level group key (last segment of the path). */\n  readonly key: string;\n  /** Structural React key: sibling-index path, e.g. `\"0.1.0\"`. */\n  readonly nodeKey: string;\n  /**\n   * Identity key (`\"id:<partId>\"`) from the group's first part; undefined\n   * when absent or already claimed by an earlier sibling.\n   */\n  readonly idKey: string | undefined;\n  /** Indices of parts in this subtree, in order. */\n  readonly indices: readonly number[];\n  readonly children: readonly GroupNode[];\n}\n\nexport interface GroupNodePart {\n  readonly type: \"part\";\n  /** Index of the part in the message. */\n  readonly index: number;\n  /** Structural React key: sibling-index path within parent. */\n  readonly nodeKey: string;\n  /**\n   * Identity key (`\"id:<partId>\"`); undefined when absent or already\n   * claimed by an earlier sibling.\n   */\n  readonly idKey: string | undefined;\n}\n\ninterface BuildFrame {\n  key: string;\n  nodeKey: string;\n  indices: number[];\n  children: GroupNode[];\n  nextChildIdx: number;\n  claimed: Set<string>;\n}\n\nconst makeChildNodeKey = (parent: BuildFrame): string => {\n  const idx = parent.nextChildIdx++;\n  return parent.nodeKey === \"\" ? String(idx) : `${parent.nodeKey}.${idx}`;\n};\n\nconst claimIdKey = (\n  frame: BuildFrame,\n  id: string | undefined,\n): string | undefined => {\n  if (id === undefined || frame.claimed.has(id)) return undefined;\n  frame.claimed.add(id);\n  return `id:${id}`;\n};\n\n/**\n * Build the group tree from an array of normalized group paths.\n * `paths[i]` is the path for part `i`. The output tree contains one\n * `part` node per part and one `group` node per coalesced run.\n * `partIds[i]` optionally carries a stable identity for part `i` (e.g. a\n * tool call id), from which nodes derive an `idKey`.\n */\nexport const buildGroupTree = (\n  paths: readonly (readonly string[])[],\n  partIds?: readonly (string | undefined)[],\n): readonly GroupNode[] => {\n  const root: BuildFrame = {\n    key: \"\",\n    nodeKey: \"\",\n    indices: [],\n    children: [],\n    nextChildIdx: 0,\n    claimed: new Set(),\n  };\n  const stack: BuildFrame[] = [root];\n\n  const closeTop = (): void => {\n    const closing = stack.pop()!;\n    const parent = stack[stack.length - 1]!;\n    parent.children.push({\n      type: \"group\",\n      key: closing.key,\n      nodeKey: closing.nodeKey,\n      idKey: claimIdKey(parent, partIds?.[closing.indices[0]!]),\n      indices: closing.indices,\n      children: closing.children,\n    });\n  };\n\n  for (let i = 0; i < paths.length; i++) {\n    const path = paths[i]!;\n\n    // Find the longest prefix shared between currently-open groups\n    // (excluding root) and this part's path.\n    let common = 0;\n    while (\n      common < stack.length - 1 &&\n      common < path.length &&\n      stack[common + 1]!.key === path[common]\n    ) {\n      common++;\n    }\n\n    // Close groups not on this path.\n    while (stack.length - 1 > common) {\n      closeTop();\n    }\n\n    // Open new groups down to the part's depth.\n    while (stack.length - 1 < path.length) {\n      const parent = stack[stack.length - 1]!;\n      stack.push({\n        key: path[stack.length - 1]!,\n        nodeKey: makeChildNodeKey(parent),\n        indices: [],\n        children: [],\n        nextChildIdx: 0,\n        claimed: new Set(),\n      });\n    }\n\n    // Push this part as a leaf in the deepest open group (or root).\n    const top = stack[stack.length - 1]!;\n    top.children.push({\n      type: \"part\",\n      index: i,\n      nodeKey: makeChildNodeKey(top),\n      idKey: claimIdKey(top, partIds?.[i]),\n    });\n\n    // Record the part index in every open ancestor group.\n    for (let s = 1; s < stack.length; s++) {\n      stack[s]!.indices.push(i);\n    }\n  }\n\n  // Close any still-open groups.\n  while (stack.length > 1) {\n    closeTop();\n  }\n\n  return root.children;\n};\n"],"mappings":"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"}

package/dist/react/utils/useJSONEqual.d.ts

@@ -1,11 +1,12 @@
+import { ReadonlyJSONValue } from "assistant-stream/utils";
 //#region src/react/utils/useJSONEqual.d.ts
+export declare function useJSONEqualValue<T extends ReadonlyJSONValue>(value: T): T;
 /**
  * Like `useShallow`, but with JSON deep-equality. Use when a selector derives an
  * equal-but-fresh value on every store update — e.g. folding over
  * `thread.messages`, whose identity changes on every streaming token — where a
  * shallow compare would re-render regardless.
  */
-declare function useJSONEqual<S, U>(selector: (state: S) => U): (state: S) => U;
+export declare function useJSONEqual<S, U>(selector: (state: S) => U): (state: S) => U;
 //#endregion
-export { useJSONEqual };
 //# sourceMappingURL=useJSONEqual.d.ts.map

package/dist/react/utils/useJSONEqual.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useJSONEqual.d.ts","names":[],"sources":["../../../src/react/utils/useJSONEqual.ts"],"mappings":";;;;;;;iBASgB,aAAa,GAAG,GAAG,WAAW,OAAO,MAAM,KAAK,OAAO,MAAM"}
+{"version":3,"file":"useJSONEqual.d.ts","names":[],"sources":["../../../src/react/utils/useJSONEqual.ts"],"mappings":";;wBAIgB,kBAAkB,UAAU,mBAAmB,OAAO,IAAI;;;;;;;wBAc1D,aAAa,GAAG,GAAG,WAAW,OAAO,MAAM,KAAK,OAAO,MAAM"}

package/dist/react/utils/useJSONEqual.js

@@ -2,6 +2,11 @@ import { isJSONValueEqual } from "../../utils/json/is-json-equal.js";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
 import { useRef } from "@assistant-ui/tap/react-shim";
 //#region src/react/utils/useJSONEqual.ts
+function useJSONEqualValue(value) {
+	const prev = useRef(value);
+	if (prev.current !== value && !isJSONValueEqual(prev.current, value)) prev.current = value;
+	return prev.current;
+}
 /**
 * Like `useShallow`, but with JSON deep-equality. Use when a selector derives an
 * equal-but-fresh value on every store update — e.g. folding over
@@ -25,6 +30,6 @@ function useJSONEqual(selector) {
 	return t0;
 }
 //#endregion
-export { useJSONEqual };
+export { useJSONEqual, useJSONEqualValue };
 
 //# sourceMappingURL=useJSONEqual.js.map

package/dist/react/utils/useJSONEqual.js.map

@@ -1 +1 @@
-{"version":3,"file":"useJSONEqual.js","names":["useRef","isJSONValueEqual","useJSONEqual","selector","$","_c","prev","undefined","t0","state","next","current"],"sources":["../../../src/react/utils/useJSONEqual.ts"],"sourcesContent":["import { useRef } from \"react\";\nimport { isJSONValueEqual } from \"../../utils/json/is-json-equal\";\n\n/**\n * Like `useShallow`, but with JSON deep-equality. Use when a selector derives an\n * equal-but-fresh value on every store update — e.g. folding over\n * `thread.messages`, whose identity changes on every streaming token — where a\n * shallow compare would re-render regardless.\n */\nexport function useJSONEqual<S, U>(selector: (state: S) => U): (state: S) => U {\n  const prev = useRef<U | undefined>(undefined);\n  return (state) => {\n    const next = selector(state);\n    if (prev.current !== undefined && isJSONValueEqual(prev.current, next)) {\n      return prev.current;\n    }\n    prev.current = next;\n    return next;\n  };\n}\n"],"mappings":";;;;;;;;;;AASA,SAAOE,aAAAC,UAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CACL,MAAAC,OAAaN,OAAsBO,KAAAA,CAAS;CAAE,IAAAC;CAAA,IAAAJ,EAAA,OAAAD,UAAA;EACvCK,MAAAC,UAAA;GACL,MAAAC,OAAaP,SAASM,KAAK;GAC3B,IAAIH,KAAIK,YAAaJ,KAAAA,KAAaN,iBAAiBK,KAAIK,SAAUD,IAAI,GAAC,OAC7DJ,KAAIK;GAEbL,KAAIK,UAAWD;GAAH,OACLA;EAAI;EACZN,EAAA,KAAAD;EAAAC,EAAA,KAAAI;CAAA,OAAAA,KAAAJ,EAAA;CAAA,OAPMI;AAON"}
+{"version":3,"file":"useJSONEqual.js","names":["useRef","ReadonlyJSONValue","isJSONValueEqual","useJSONEqualValue","value","T","prev","current","useJSONEqual","selector","$","_c","undefined","t0","state","next"],"sources":["../../../src/react/utils/useJSONEqual.ts"],"sourcesContent":["import { useRef } from \"react\";\nimport type { ReadonlyJSONValue } from \"assistant-stream/utils\";\nimport { isJSONValueEqual } from \"../../utils/json/is-json-equal\";\n\nexport function useJSONEqualValue<T extends ReadonlyJSONValue>(value: T): T {\n  const prev = useRef(value);\n  if (prev.current !== value && !isJSONValueEqual(prev.current, value)) {\n    prev.current = value;\n  }\n  return prev.current;\n}\n\n/**\n * Like `useShallow`, but with JSON deep-equality. Use when a selector derives an\n * equal-but-fresh value on every store update — e.g. folding over\n * `thread.messages`, whose identity changes on every streaming token — where a\n * shallow compare would re-render regardless.\n */\nexport function useJSONEqual<S, U>(selector: (state: S) => U): (state: S) => U {\n  const prev = useRef<U | undefined>(undefined);\n  return (state) => {\n    const next = selector(state);\n    if (prev.current !== undefined && isJSONValueEqual(prev.current, next)) {\n      return prev.current;\n    }\n    prev.current = next;\n    return next;\n  };\n}\n"],"mappings":";;;;AAIA,SAAgBG,kBAA+CC,OAAa;CAC1E,MAAME,OAAON,OAAOI,KAAK;CACzB,IAAIE,KAAKC,YAAYH,SAAS,CAACF,iBAAiBI,KAAKC,SAASH,KAAK,GACjEE,KAAKC,UAAUH;CAEjB,OAAOE,KAAKC;AACd;;;;;;;AAQA,SAAOC,aAAAC,UAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CACL,MAAAL,OAAaN,OAAsBY,KAAAA,CAAS;CAAE,IAAAC;CAAA,IAAAH,EAAA,OAAAD,UAAA;EACvCI,MAAAC,UAAA;GACL,MAAAC,OAAaN,SAASK,KAAK;GAC3B,IAAIR,KAAIC,YAAaK,KAAAA,KAAaV,iBAAiBI,KAAIC,SAAUQ,IAAI,GAAC,OAC7DT,KAAIC;GAEbD,KAAIC,UAAWQ;GAAH,OACLA;EAAI;EACZL,EAAA,KAAAD;EAAAC,EAAA,KAAAG;CAAA,OAAAA,KAAAH,EAAA;CAAA,OAPMG;AAON"}

package/dist/react/utils/useJSONSchemaDependency.d.ts

@@ -0,0 +1,6 @@
+import { Unstable_InteractableStateSchema } from "../types/scopes/interactables.js";
+import { ReadonlyJSONValue } from "assistant-stream/utils";
+//#region src/react/utils/useJSONSchemaDependency.d.ts
+export declare function useJSONSchemaDependency(schema: Unstable_InteractableStateSchema): ReadonlyJSONValue;
+//#endregion
+//# sourceMappingURL=useJSONSchemaDependency.d.ts.map

package/dist/react/utils/useJSONSchemaDependency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useJSONSchemaDependency.d.ts","names":[],"sources":["../../../src/react/utils/useJSONSchemaDependency.ts"],"mappings":";;;wBAOgB,wBACd,QAAQ,mCACP"}

package/dist/react/utils/useJSONSchemaDependency.js

@@ -0,0 +1,20 @@
+import { isJSONValue } from "../../utils/json/is-json.js";
+import { useJSONEqualValue } from "./useJSONEqual.js";
+import { toJSONSchema } from "assistant-stream";
+import { useMemo } from "@assistant-ui/tap/react-shim";
+//#region src/react/utils/useJSONSchemaDependency.ts
+function useJSONSchemaDependency(schema) {
+	const normalizedSchema = useMemo(() => {
+		try {
+			const jsonSchema = toJSONSchema(schema);
+			return isJSONValue(jsonSchema) ? jsonSchema : null;
+		} catch {
+			return null;
+		}
+	}, [schema]);
+	return useJSONEqualValue(normalizedSchema);
+}
+//#endregion
+export { useJSONSchemaDependency };
+
+//# sourceMappingURL=useJSONSchemaDependency.js.map

package/dist/react/utils/useJSONSchemaDependency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useJSONSchemaDependency.js","names":["useMemo","toJSONSchema","ReadonlyJSONValue","isJSONValue","Unstable_InteractableStateSchema","useJSONEqualValue","useJSONSchemaDependency","schema","normalizedSchema","jsonSchema"],"sources":["../../../src/react/utils/useJSONSchemaDependency.ts"],"sourcesContent":["import { useMemo } from \"react\";\nimport { toJSONSchema } from \"assistant-stream\";\nimport type { ReadonlyJSONValue } from \"assistant-stream/utils\";\nimport { isJSONValue } from \"../../utils/json/is-json\";\nimport type { Unstable_InteractableStateSchema } from \"../types/scopes/interactables\";\nimport { useJSONEqualValue } from \"./useJSONEqual\";\n\nexport function useJSONSchemaDependency(\n  schema: Unstable_InteractableStateSchema,\n): ReadonlyJSONValue {\n  const normalizedSchema = useMemo(() => {\n    try {\n      const jsonSchema = toJSONSchema(schema);\n      return isJSONValue(jsonSchema) ? jsonSchema : null;\n    } catch {\n      // Opaque schemas share one fallback so rebuilt instances do not churn registration.\n      return null;\n    }\n  }, [schema]);\n\n  return useJSONEqualValue(normalizedSchema);\n}\n"],"mappings":";;;;;AAOA,SAAgBM,wBACdC,QACmB;CACnB,MAAMC,mBAAmBR,cAAc;EACrC,IAAI;GACF,MAAMS,aAAaR,aAAaM,MAAM;GACtC,OAAOJ,YAAYM,UAAU,IAAIA,aAAa;EAChD,QAAQ;GAEN,OAAO;EACT;CACF,GAAG,CAACF,MAAM,CAAC;CAEX,OAAOF,kBAAkBG,gBAAgB;AAC3C"}

package/dist/runtime/api/assistant-runtime.d.ts

@@ -4,7 +4,7 @@ import { AssistantRuntimeCore } from "../interfaces/assistant-runtime-core.js";
 import { ThreadListRuntime, ThreadListRuntimeImpl } from "./thread-list-runtime.js";
 import { ThreadRuntime } from "./thread-runtime.js";
 //#region src/runtime/api/assistant-runtime.d.ts
-type AssistantRuntime = {
+export type AssistantRuntime = {
   /**
    * The threads in this assistant.
    */
@@ -20,7 +20,7 @@ type AssistantRuntime = {
    */
   registerModelContextProvider(provider: ModelContextProvider): Unsubscribe;
 };
-declare class AssistantRuntimeImpl implements AssistantRuntime {
+export declare class AssistantRuntimeImpl implements AssistantRuntime {
   readonly threads: ThreadListRuntimeImpl;
   readonly _thread: ThreadRuntime;
   private readonly _core;
@@ -30,5 +30,4 @@ declare class AssistantRuntimeImpl implements AssistantRuntime {
   registerModelContextProvider(provider: ModelContextProvider): Unsubscribe;
 }
 //#endregion
-export { AssistantRuntime, AssistantRuntimeImpl };
 //# sourceMappingURL=assistant-runtime.d.ts.map

package/dist/runtime/api/assistant-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assistant-runtime.d.ts","names":[],"sources":["../../../src/runtime/api/assistant-runtime.ts"],"mappings":";;;;;;KASY;;;;WAID,SAAS;;;;WAKT,QAAQ;;;;;;EAOjB,6BAA6B,UAAU,uBAAuB;;cAGnD,gCAAgC;WAC3B,SAAO;WAEP,SAAS;mBAER;EAEL,YAAA,OAAO;YAQT;MAKC,UAAM;EAIV,6BAA6B,UAAU,uBAAoB"}
+{"version":3,"file":"assistant-runtime.d.ts","names":[],"sources":["../../../src/runtime/api/assistant-runtime.ts"],"mappings":";;;;;;YASY;;;;WAID,SAAS;;;;WAKT,QAAQ;;;;;;EAOjB,6BAA6B,UAAU,uBAAuB;;qBAGnD,gCAAgC;WAC3B,SAAO;WAEP,SAAS;mBAER;EAEL,YAAA,OAAO;YAQT;MAKC,UAAM;EAIV,6BAA6B,UAAU,uBAAoB"}

package/dist/runtime/api/attachment-runtime.d.ts

@@ -13,14 +13,14 @@ type ThreadComposerAttachmentState = Attachment & {
 type EditComposerAttachmentState = Attachment & {
   readonly source: "edit-composer";
 };
-type AttachmentState = ThreadComposerAttachmentState | EditComposerAttachmentState | MessageAttachmentState;
+export type AttachmentState = ThreadComposerAttachmentState | EditComposerAttachmentState | MessageAttachmentState;
 type AttachmentSnapshotBinding<Source extends AttachmentRuntimeSource> = SubscribableWithState<AttachmentState & {
   source: Source;
 }, AttachmentRuntimePath & {
   attachmentSource: Source;
 }>;
 type AttachmentRuntimeSource = AttachmentState["source"];
-type AttachmentRuntime<TSource extends AttachmentRuntimeSource = AttachmentRuntimeSource> = {
+export type AttachmentRuntime<TSource extends AttachmentRuntimeSource = AttachmentRuntimeSource> = {
   readonly path: AttachmentRuntimePath & {
     attachmentSource: TSource;
   };
@@ -31,7 +31,7 @@ type AttachmentRuntime<TSource extends AttachmentRuntimeSource = AttachmentRunti
   remove(): Promise<void>;
   subscribe(callback: () => void): Unsubscribe;
 };
-declare abstract class AttachmentRuntimeImpl<Source extends AttachmentRuntimeSource = AttachmentRuntimeSource> implements AttachmentRuntime {
+export declare abstract class AttachmentRuntimeImpl<Source extends AttachmentRuntimeSource = AttachmentRuntimeSource> implements AttachmentRuntime {
   get path(): AttachmentRuntimePath & {
     attachmentSource: Source;
   };
@@ -50,16 +50,15 @@ declare abstract class ComposerAttachmentRuntime<Source extends "thread-composer
   constructor(core: AttachmentSnapshotBinding<Source>, _composerApi: ComposerRuntimeCoreBinding);
   remove(): Promise<void>;
 }
-declare class ThreadComposerAttachmentRuntimeImpl extends ComposerAttachmentRuntime<"thread-composer"> {
+export declare class ThreadComposerAttachmentRuntimeImpl extends ComposerAttachmentRuntime<"thread-composer"> {
   get source(): "thread-composer";
 }
-declare class EditComposerAttachmentRuntimeImpl extends ComposerAttachmentRuntime<"edit-composer"> {
+export declare class EditComposerAttachmentRuntimeImpl extends ComposerAttachmentRuntime<"edit-composer"> {
   get source(): "edit-composer";
 }
-declare class MessageAttachmentRuntimeImpl extends AttachmentRuntimeImpl<"message"> {
+export declare class MessageAttachmentRuntimeImpl extends AttachmentRuntimeImpl<"message"> {
   get source(): "message";
   remove(): never;
 }
 //#endregion
-export { AttachmentRuntime, AttachmentRuntimeImpl, AttachmentState, EditComposerAttachmentRuntimeImpl, MessageAttachmentRuntimeImpl, ThreadComposerAttachmentRuntimeImpl };
 //# sourceMappingURL=attachment-runtime.d.ts.map

package/dist/runtime/api/attachment-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attachment-runtime.d.ts","names":[],"sources":["../../../src/runtime/api/attachment-runtime.ts"],"mappings":";;;;;;KAOK,yBAAyB;WACnB;;KAGN,gCAAgC;WAC1B;;KAGN,8BAA8B;WACxB;;KAGC,kBACR,gCACA,8BACA;KAEC,0BAA0B,eAAe,2BAC5C,sBACE;EAAoB,QAAQ;GAC5B;EAA0B,kBAAkB;;KAG3C,0BAA0B;KAEnB,kBACV,gBAAgB,0BAA0B;WAEjC,MAAM;IAA0B,kBAAkB;;WAClD,QAAQ;EACjB,YAAY;IAAoB,QAAQ;;EACxC,UAAU;EACV,UAAU,uBAAuB;;uBAGb,sBACpB,eAAe,0BAA0B,oCAC9B;MACA,QAAI;;;eAIK,UAAU;UAEtB;EAEI,YAAA,OAAO,0BAA0B;YAKnC;EAMH,YAAY;IAAoB,QAAQ;;WAI/B,UAAU;EAEnB,UAAU,uBAAoB;;uBAKxB,0BACb,4DACQ,sBAAsB;UACtB;EAGN,YAAA,MAAM,0BAA0B,SAChC,cAAc;EAMT,UAAM;;cAOF,4CAA4C;MAC5C;;cAKA,0CAA0C;MAC1C;;cAKA,qCAAqC;MACrC;EAIJ"}
+{"version":3,"file":"attachment-runtime.d.ts","names":[],"sources":["../../../src/runtime/api/attachment-runtime.ts"],"mappings":";;;;;;KAOK,yBAAyB;WACnB;;KAGN,gCAAgC;WAC1B;;KAGN,8BAA8B;WACxB;;YAGC,kBACR,gCACA,8BACA;KAEC,0BAA0B,eAAe,2BAC5C,sBACE;EAAoB,QAAQ;GAC5B;EAA0B,kBAAkB;;KAG3C,0BAA0B;YAEnB,kBACV,gBAAgB,0BAA0B;WAEjC,MAAM;IAA0B,kBAAkB;;WAClD,QAAQ;EACjB,YAAY;IAAoB,QAAQ;;EACxC,UAAU;EACV,UAAU,uBAAuB;;8BAGb,sBACpB,eAAe,0BAA0B,oCAC9B;MACA,QAAI;;;eAIK,UAAU;UAEtB;EAEI,YAAA,OAAO,0BAA0B;YAKnC;EAMH,YAAY;IAAoB,QAAQ;;WAI/B,UAAU;EAEnB,UAAU,uBAAoB;;uBAKxB,0BACb,4DACQ,sBAAsB;UACtB;EAGN,YAAA,MAAM,0BAA0B,SAChC,cAAc;EAMT,UAAM;;qBAOF,4CAA4C;MAC5C;;qBAKA,0CAA0C;MAC1C;;qBAKA,qCAAqC;MACrC;EAIJ"}

package/dist/runtime/api/bindings.d.ts

@@ -5,14 +5,14 @@ import { ComposerRuntimePath, MessageRuntimePath } from "./paths.js";
 import { ThreadListItemStatus } from "../interfaces/thread-list-runtime-core.js";
 import { SubscribableWithState } from "../../subscribable/subscribable.js";
 //#region src/runtime/api/bindings.d.ts
-type ComposerRuntimeCoreBinding = SubscribableWithState<ComposerRuntimeCore | undefined, ComposerRuntimePath>;
-type ThreadComposerRuntimeCoreBinding = SubscribableWithState<ThreadComposerRuntimeCore | undefined, ComposerRuntimePath & {
+export type ComposerRuntimeCoreBinding = SubscribableWithState<ComposerRuntimeCore | undefined, ComposerRuntimePath>;
+export type ThreadComposerRuntimeCoreBinding = SubscribableWithState<ThreadComposerRuntimeCore | undefined, ComposerRuntimePath & {
   composerSource: "thread";
 }>;
-type EditComposerRuntimeCoreBinding = SubscribableWithState<EditComposerRuntimeCore | undefined, ComposerRuntimePath & {
+export type EditComposerRuntimeCoreBinding = SubscribableWithState<EditComposerRuntimeCore | undefined, ComposerRuntimePath & {
   composerSource: "edit";
 }>;
-type MessageStateBinding = SubscribableWithState<ThreadMessage & {
+export type MessageStateBinding = SubscribableWithState<ThreadMessage & {
   readonly parentId: string | null;
   readonly index: number;
   readonly isLast: boolean;
@@ -20,7 +20,7 @@ type MessageStateBinding = SubscribableWithState<ThreadMessage & {
   readonly branchCount: number;
   readonly speech: SpeechState | undefined;
 }, MessageRuntimePath>;
-type ThreadListItemState = {
+export type ThreadListItemState = {
   readonly isMain: boolean;
   /**
    * Whether this thread has a run in progress, including a run that continues
@@ -36,5 +36,4 @@ type ThreadListItemState = {
   readonly custom?: Record<string, unknown> | undefined;
 };
 //#endregion
-export { ComposerRuntimeCoreBinding, EditComposerRuntimeCoreBinding, MessageStateBinding, ThreadComposerRuntimeCoreBinding, ThreadListItemState };
 //# sourceMappingURL=bindings.d.ts.map

package/dist/runtime/api/bindings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bindings.d.ts","names":[],"sources":["../../../src/runtime/api/bindings.ts"],"mappings":";;;;;;;KAUY,6BAA6B,sBACvC,iCACA;KAGU,mCAAmC,sBAC7C,uCACA;EAAwB;;KAGd,iCAAiC,sBAC3C,qCACA;EAAwB;;KAGd,sBAAsB,sBAChC;WACW;WACA;WACA;WACA;WACA;WACA,QAAQ;GAEnB;KAGU;WACD;;;;;WAKA;WACA;WACA;WACA;WACA,QAVC;WAWD;WACA,gBAAgB;WAChB,SAAS"}
+{"version":3,"file":"bindings.d.ts","names":[],"sources":["../../../src/runtime/api/bindings.ts"],"mappings":";;;;;;;YAUY,6BAA6B,sBACvC,iCACA;YAGU,mCAAmC,sBAC7C,uCACA;EAAwB;;YAGd,iCAAiC,sBAC3C,qCACA;EAAwB;;YAGd,sBAAsB,sBAChC;WACW;WACA;WACA;WACA;WACA;WACA,QAAQ;GAEnB;YAGU;WACD;;;;;WAKA;WACA;WACA;WACA;WACA,QAVC;WAWD;WACA,gBAAgB;WAChB,SAAS"}

package/dist/runtime/api/composer-runtime.d.ts

@@ -37,16 +37,16 @@ type BaseComposerState = {
   /** Messages waiting to be processed. Empty unless the `queue` capability is set. */
   readonly queue: readonly QueueItemState[];
 };
-type ThreadComposerState = BaseComposerState & {
+export type ThreadComposerState = BaseComposerState & {
   readonly type: "thread";
 };
-type EditComposerState = BaseComposerState & {
+export type EditComposerState = BaseComposerState & {
   readonly type: "edit";
   readonly parentId: string | null;
   readonly sourceId: string | null;
 };
-type ComposerState = ThreadComposerState | EditComposerState;
-type ComposerRuntime = {
+export type ComposerState = ThreadComposerState | EditComposerState;
+export type ComposerRuntime = {
   readonly path: ComposerRuntimePath;
   readonly type: "edit" | "thread";
   /**
@@ -137,7 +137,7 @@ type ComposerRuntime = {
    */
   unstable_on<E extends ComposerRuntimeEventType>(event: E, callback: ComposerRuntimeEventCallback<E>): Unsubscribe;
 };
-declare abstract class ComposerRuntimeImpl implements ComposerRuntime {
+export declare abstract class ComposerRuntimeImpl implements ComposerRuntime {
   get path(): ComposerRuntimePath;
   abstract get type(): "edit" | "thread";
   protected _core: ComposerRuntimeCoreBinding;
@@ -163,7 +163,7 @@ declare abstract class ComposerRuntimeImpl implements ComposerRuntime {
   unstable_on<E extends ComposerRuntimeEventType>(event: E, callback: ComposerRuntimeEventCallback<E>): Unsubscribe;
   abstract getAttachmentByIndex(idx: number): AttachmentRuntime;
 }
-type ThreadComposerRuntime = Omit<ComposerRuntime, "getState" | "getAttachmentByIndex"> & {
+export type ThreadComposerRuntime = Omit<ComposerRuntime, "getState" | "getAttachmentByIndex"> & {
   readonly path: ComposerRuntimePath & {
     composerSource: "thread";
   };
@@ -173,7 +173,7 @@ type ThreadComposerRuntime = Omit<ComposerRuntime, "getState" | "getAttachmentBy
     source: "thread-composer";
   };
 };
-declare class ThreadComposerRuntimeImpl extends ComposerRuntimeImpl implements ThreadComposerRuntime {
+export declare class ThreadComposerRuntimeImpl extends ComposerRuntimeImpl implements ThreadComposerRuntime {
   get path(): ComposerRuntimePath & {
     composerSource: "thread";
   };
@@ -183,7 +183,7 @@ declare class ThreadComposerRuntimeImpl extends ComposerRuntimeImpl implements T
   getState(): ThreadComposerState;
   getAttachmentByIndex(idx: number): ThreadComposerAttachmentRuntimeImpl;
 }
-type EditComposerRuntime = Omit<ComposerRuntime, "getState" | "getAttachmentByIndex"> & {
+export type EditComposerRuntime = Omit<ComposerRuntime, "getState" | "getAttachmentByIndex"> & {
   readonly path: ComposerRuntimePath & {
     composerSource: "edit";
   };
@@ -194,7 +194,7 @@ type EditComposerRuntime = Omit<ComposerRuntime, "getState" | "getAttachmentByIn
     source: "edit-composer";
   };
 };
-declare class EditComposerRuntimeImpl extends ComposerRuntimeImpl implements EditComposerRuntime {
+export declare class EditComposerRuntimeImpl extends ComposerRuntimeImpl implements EditComposerRuntime {
   get path(): ComposerRuntimePath & {
     composerSource: "edit";
   };
@@ -208,5 +208,5 @@ declare class EditComposerRuntimeImpl extends ComposerRuntimeImpl implements Edi
   getAttachmentByIndex(idx: number): EditComposerAttachmentRuntimeImpl;
 }
 //#endregion
-export { ComposerRuntime, type ComposerRuntimeCoreBinding, ComposerRuntimeImpl, ComposerState, EditComposerRuntime, type EditComposerRuntimeCoreBinding, EditComposerRuntimeImpl, EditComposerState, ThreadComposerRuntime, type ThreadComposerRuntimeCoreBinding, ThreadComposerRuntimeImpl, ThreadComposerState };
+export type { ComposerRuntimeCoreBinding, EditComposerRuntimeCoreBinding, ThreadComposerRuntimeCoreBinding };
 //# sourceMappingURL=composer-runtime.d.ts.map

package/dist/runtime/api/composer-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"composer-runtime.d.ts","names":[],"sources":["../../../src/runtime/api/composer-runtime.ts"],"mappings":";;;;;;;;;;;KA2CK;;;;;;WAMM;WACA;WACA;WACA;WAEA;WACA,MAAM;WACN,sBAAsB;WACtB,WAAW;WAEX;;;;;WAMA,WAAW;;;;;WAMX,OAAO;;WAGP,gBAAgB;;KAGf,sBAAsB;WACvB;;KAGC,oBAAoB;WACrB;WACA;WACA;;KAGC,gBAAgB,sBAAsB;KAuDtC;WACD,MAAM;WACN;;;;EAKT,YAAY;;;;;;;;;;EAWZ,cAAc,kBAAkB,OAAO,mBAAmB;;;;;EAM1D,QAAQ;;;;;EAMR,QAAQ,MAAM;;;;;;;;;;;;EAad,aAAa,WAAW;;;;EAKxB,SAAS;;;;EAKT,oBAAoB;;;;;EAMpB,KAAK,UAAU;;;;EAKf;;EAGA,eAAe;;EAGf,cAAc,qBAAqB,WAAW;;EAG9C,gBAAgB;;;;;EAMhB,UAAU,uBAAuB;;;;;EAMjC,qBAAqB,cAAc;;;;;EAMnC;;;;EAKA;;;;;EAMA,SAAS,OAAO;;;;EAKhB,YAAY,UAAU,0BACpB,OAAO,GACP,UAAU,6BAA6B,KACtC;;uBAGiB,+BAA+B;MACxC,QAAI;eAIK;YAEV,OAAO;EAEL,YAAA,OAAO;YAIT;WAqBM,YAAY;EAErB,QAAQ;EAMR,aAAa,WAAW;EAMxB,cAAc,kBAAkB,OAAO,mBAAgB;EAMvD,SAAK;EAML,oBAAgB;EAMhB,KAAK,UAAU;EAMf;EAMA,eAAe;EAIf,cAAc,qBAAqB,WAAW;EAM9C,gBAAgB;EAMhB,QAAQ,MAAM;EAMd;EAMA;EAMA,SAAS,OAAO;EAMhB,UAAU,uBAAoB;UAI7B;EAKD,YAAY,UAAU,0BAC3B,OAAO,GACP,UAAU,6BAA6B,KACtC;WAYa,qBAAqB,cAAc;;KAGzC,wBAAwB,KAClC;WAGS,MAAM;IAAwB;;WAC9B;EACT,YAAY;EAEZ,qBACE,cACC;IAAsB;;;cAGd,kCACH,+BACG;MAES,QACQ;IACxB;;MAIO;UAIH;EAEI,YAAA,MAAM;EAgBF,YAAY;EAIrB,qBAAqB,cAAW;;KA0B7B,sBAAsB,KAChC;WAGS,MAAM;IAAwB;;WAC9B;EAET,YAAY;EACZ;EAEA,qBACE,cACC;IAAsB;;;cAGd,gCACH,+BACG;MAES,QACQ;IAAwB;;MAGzC;UAIH;UACA;EAEI,YAAA,MAAM,gCAAgC;EAmBlC;EAKA,YAAY;EAIrB;EAIA,qBAAqB,cAAW"}
+{"version":3,"file":"composer-runtime.d.ts","names":[],"sources":["../../../src/runtime/api/composer-runtime.ts"],"mappings":";;;;;;;;;;;KA2CK;;;;;;WAMM;WACA;WACA;WACA;WAEA;WACA,MAAM;WACN,sBAAsB;WACtB,WAAW;WAEX;;;;;WAMA,WAAW;;;;;WAMX,OAAO;;WAGP,gBAAgB;;YAGf,sBAAsB;WACvB;;YAGC,oBAAoB;WACrB;WACA;WACA;;YAGC,gBAAgB,sBAAsB;YAuDtC;WACD,MAAM;WACN;;;;EAKT,YAAY;;;;;;;;;;EAWZ,cAAc,kBAAkB,OAAO,mBAAmB;;;;;EAM1D,QAAQ;;;;;EAMR,QAAQ,MAAM;;;;;;;;;;;;EAad,aAAa,WAAW;;;;EAKxB,SAAS;;;;EAKT,oBAAoB;;;;;EAMpB,KAAK,UAAU;;;;EAKf;;EAGA,eAAe;;EAGf,cAAc,qBAAqB,WAAW;;EAG9C,gBAAgB;;;;;EAMhB,UAAU,uBAAuB;;;;;EAMjC,qBAAqB,cAAc;;;;;EAMnC;;;;EAKA;;;;;EAMA,SAAS,OAAO;;;;EAKhB,YAAY,UAAU,0BACpB,OAAO,GACP,UAAU,6BAA6B,KACtC;;8BAGiB,+BAA+B;MACxC,QAAI;eAIK;YAEV,OAAO;EAEL,YAAA,OAAO;YAIT;WAqBM,YAAY;EAErB,QAAQ;EAMR,aAAa,WAAW;EAMxB,cAAc,kBAAkB,OAAO,mBAAgB;EAMvD,SAAK;EAML,oBAAgB;EAMhB,KAAK,UAAU;EAMf;EAMA,eAAe;EAIf,cAAc,qBAAqB,WAAW;EAM9C,gBAAgB;EAMhB,QAAQ,MAAM;EAMd;EAMA;EAMA,SAAS,OAAO;EAMhB,UAAU,uBAAoB;UAI7B;EAKD,YAAY,UAAU,0BAC3B,OAAO,GACP,UAAU,6BAA6B,KACtC;WAYa,qBAAqB,cAAc;;YAGzC,wBAAwB,KAClC;WAGS,MAAM;IAAwB;;WAC9B;EACT,YAAY;EAEZ,qBACE,cACC;IAAsB;;;qBAGd,kCACH,+BACG;MAES,QACQ;IACxB;;MAIO;UAIH;EAEI,YAAA,MAAM;EAgBF,YAAY;EAIrB,qBAAqB,cAAW;;YA0B7B,sBAAsB,KAChC;WAGS,MAAM;IAAwB;;WAC9B;EAET,YAAY;EACZ;EAEA,qBACE,cACC;IAAsB;;;qBAGd,gCACH,+BACG;MAES,QACQ;IAAwB;;MAGzC;UAIH;UACA;EAEI,YAAA,MAAM,gCAAgC;EAmBlC;EAKA,YAAY;EAIrB;EAIA,qBAAqB,cAAW"}

package/dist/runtime/api/message-part-runtime.d.ts

@@ -6,11 +6,11 @@ import { MessageStateBinding } from "./bindings.js";
 import { ThreadRuntimeCoreBinding } from "./thread-runtime.js";
 import { ToolResponse } from "assistant-stream";
 //#region src/runtime/api/message-part-runtime.d.ts
-type MessagePartState = (ThreadUserMessagePart | ThreadAssistantMessagePart) & {
+export type MessagePartState = (ThreadUserMessagePart | ThreadAssistantMessagePart) & {
   readonly status: MessagePartStatus | ToolCallMessagePartStatus;
 };
 type MessagePartSnapshotBinding = SubscribableWithState<MessagePartState, MessagePartRuntimePath>;
-type MessagePartRuntime = {
+export type MessagePartRuntime = {
   addToolResult(result: any | ToolResponse<any>): void;
   resumeToolCall(payload: unknown): void;
   respondToToolApproval(response: ToolApprovalResponse): Promise<void>;
@@ -18,7 +18,7 @@ type MessagePartRuntime = {
   getState(): MessagePartState;
   subscribe(callback: () => void): Unsubscribe;
 };
-declare class MessagePartRuntimeImpl implements MessagePartRuntime {
+export declare class MessagePartRuntimeImpl implements MessagePartRuntime {
   get path(): MessagePartRuntimePath;
   private contentBinding;
   private messageApi;
@@ -32,5 +32,4 @@ declare class MessagePartRuntimeImpl implements MessagePartRuntime {
   subscribe(callback: () => void): Unsubscribe;
 }
 //#endregion
-export { MessagePartRuntime, MessagePartRuntimeImpl, MessagePartState };
 //# sourceMappingURL=message-part-runtime.d.ts.map

package/dist/runtime/api/message-part-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"message-part-runtime.d.ts","names":[],"sources":["../../../src/runtime/api/message-part-runtime.ts"],"mappings":";;;;;;;;KAeY,oBACR,wBACA;WAEO,QAAQ,oBAAoB;;KAGlC,6BAA6B,sBAChC,kBACA;KAGU;EACV,cAAc,cAAc;EAC5B,eAAe;EACf,sBAAsB,UAAU,uBAAuB;WAE9C,MAAM;EACf,YAAY;EACZ,UAAU,uBAAuB;;cAGtB,kCAAkC;MAClC,QAAI;UAIP;UACA;UACA;EAGN,YAAA,gBAAgB,4BAChB,aAAa,qBACb,YAAY;YAQJ;EAQH,YAAQ;EAIR,cAAc,cAAc;EA8B5B,eAAe;EAgBf,sBAAsB,UAAU,uBAAuB;EAyBvD,UAAU,uBAAoB"}
+{"version":3,"file":"message-part-runtime.d.ts","names":[],"sources":["../../../src/runtime/api/message-part-runtime.ts"],"mappings":";;;;;;;;YAeY,oBACR,wBACA;WAEO,QAAQ,oBAAoB;;KAGlC,6BAA6B,sBAChC,kBACA;YAGU;EACV,cAAc,cAAc;EAC5B,eAAe;EACf,sBAAsB,UAAU,uBAAuB;WAE9C,MAAM;EACf,YAAY;EACZ,UAAU,uBAAuB;;qBAGtB,kCAAkC;MAClC,QAAI;UAIP;UACA;UACA;EAGN,YAAA,gBAAgB,4BAChB,aAAa,qBACb,YAAY;YAQJ;EAQH,YAAQ;EAIR,cAAc,cAAc;EAiC5B,eAAe;EAgBf,sBAAsB,UAAU,uBAAuB;EAyBvD,UAAU,uBAAoB"}

package/dist/runtime/api/message-part-runtime.js

@@ -40,8 +40,9 @@ var MessagePartRuntimeImpl = class {
 			toolName,
 			toolCallId,
 			result: response.result,
-			artifact: response.artifact,
-			isError: response.isError
+			isError: response.isError,
+			...response.artifact !== void 0 && { artifact: response.artifact },
+			...response.modelContent !== void 0 && { modelContent: response.modelContent }
 		});
 	}
 	resumeToolCall(payload) {

package/dist/runtime/api/message-part-runtime.js.map

@@ -1 +1 @@
-{"version":3,"file":"message-part-runtime.js","names":["ThreadAssistantMessagePart","ThreadUserMessagePart","ToolApprovalResponse","ToolCallMessagePartStatus","resolveToolApprovalResponse","Unsubscribe","MessagePartStatus","SubscribableWithState","ThreadRuntimeCoreBinding","MessageStateBinding","MessagePartRuntimePath","ToolResponse","MessagePartState","status","MessagePartSnapshotBinding","MessagePartRuntime","addToolResult","result","resumeToolCall","payload","respondToToolApproval","response","Promise","path","getState","subscribe","callback","MessagePartRuntimeImpl","contentBinding","messageApi","threadApi","constructor","__internal_bindMethods","bind","state","Error","type","message","toolName","toolCallId","toResponse","messageId","id","artifact","isError","approval","approved","undefined","resolution"],"sources":["../../../src/runtime/api/message-part-runtime.ts"],"sourcesContent":["import type {\n  ThreadAssistantMessagePart,\n  ThreadUserMessagePart,\n  ToolApprovalResponse,\n  ToolCallMessagePartStatus,\n} from \"../../types/message\";\nimport { resolveToolApprovalResponse } from \"../utils/resolveToolApprovalResponse\";\nimport type { Unsubscribe } from \"../../types/unsubscribe\";\nimport type { MessagePartStatus } from \"../../types/message\";\nimport type { SubscribableWithState } from \"../../subscribable/subscribable\";\nimport type { ThreadRuntimeCoreBinding } from \"./thread-runtime\";\nimport type { MessageStateBinding } from \"./bindings\";\nimport type { MessagePartRuntimePath } from \"./paths\";\nimport { ToolResponse } from \"assistant-stream\";\n\nexport type MessagePartState = (\n  | ThreadUserMessagePart\n  | ThreadAssistantMessagePart\n) & {\n  readonly status: MessagePartStatus | ToolCallMessagePartStatus;\n};\n\ntype MessagePartSnapshotBinding = SubscribableWithState<\n  MessagePartState,\n  MessagePartRuntimePath\n>;\n\nexport type MessagePartRuntime = {\n  addToolResult(result: any | ToolResponse<any>): void;\n  resumeToolCall(payload: unknown): void;\n  respondToToolApproval(response: ToolApprovalResponse): Promise<void>;\n\n  readonly path: MessagePartRuntimePath;\n  getState(): MessagePartState;\n  subscribe(callback: () => void): Unsubscribe;\n};\n\nexport class MessagePartRuntimeImpl implements MessagePartRuntime {\n  public get path() {\n    return this.contentBinding.path;\n  }\n\n  private contentBinding: MessagePartSnapshotBinding;\n  private messageApi: MessageStateBinding | undefined;\n  private threadApi: ThreadRuntimeCoreBinding | undefined;\n\n  constructor(\n    contentBinding: MessagePartSnapshotBinding,\n    messageApi?: MessageStateBinding,\n    threadApi?: ThreadRuntimeCoreBinding,\n  ) {\n    this.contentBinding = contentBinding;\n    this.messageApi = messageApi;\n    this.threadApi = threadApi;\n    this.__internal_bindMethods();\n  }\n\n  protected __internal_bindMethods() {\n    this.addToolResult = this.addToolResult.bind(this);\n    this.resumeToolCall = this.resumeToolCall.bind(this);\n    this.respondToToolApproval = this.respondToToolApproval.bind(this);\n    this.getState = this.getState.bind(this);\n    this.subscribe = this.subscribe.bind(this);\n  }\n\n  public getState() {\n    return this.contentBinding.getState();\n  }\n\n  public addToolResult(result: any | ToolResponse<any>) {\n    const state = this.contentBinding.getState();\n    if (!state) throw new Error(\"Message part is not available\");\n\n    if (state.type !== \"tool-call\")\n      throw new Error(\"Tried to add tool result to non-tool message part\");\n\n    if (!this.messageApi)\n      throw new Error(\n        \"Message API is not available. This is likely a bug in assistant-ui.\",\n      );\n    if (!this.threadApi) throw new Error(\"Thread API is not available\");\n\n    const message = this.messageApi.getState();\n    if (!message) throw new Error(\"Message is not available\");\n\n    const toolName = state.toolName;\n    const toolCallId = state.toolCallId;\n\n    const response = ToolResponse.toResponse(result);\n    this.threadApi.getState().addToolResult({\n      messageId: message.id,\n      toolName,\n      toolCallId,\n      result: response.result,\n      artifact: response.artifact,\n      isError: response.isError,\n    });\n  }\n\n  public resumeToolCall(payload: unknown) {\n    const state = this.contentBinding.getState();\n    if (!state) throw new Error(\"Message part is not available\");\n\n    if (state.type !== \"tool-call\")\n      throw new Error(\"Tried to resume tool call on non-tool message part\");\n\n    if (!this.threadApi) throw new Error(\"Thread API is not available\");\n\n    const toolCallId = state.toolCallId;\n    this.threadApi.getState().resumeToolCall({\n      toolCallId,\n      payload,\n    });\n  }\n\n  public respondToToolApproval(response: ToolApprovalResponse): Promise<void> {\n    const state = this.contentBinding.getState();\n    if (!state) throw new Error(\"Message part is not available\");\n\n    if (state.type !== \"tool-call\")\n      throw new Error(\n        \"Tried to respond to tool approval on non-tool message part\",\n      );\n\n    if (\n      !state.approval ||\n      state.approval.approved !== undefined ||\n      state.approval.resolution !== undefined\n    )\n      throw new Error(\"Tool call has no pending approval\");\n\n    if (!this.threadApi) throw new Error(\"Thread API is not available\");\n\n    return this.threadApi\n      .getState()\n      .respondToToolApproval(\n        resolveToolApprovalResponse(state.approval, response),\n      );\n  }\n\n  public subscribe(callback: () => void) {\n    return this.contentBinding.subscribe(callback);\n  }\n}\n"],"mappings":";;;AAqCA,IAAa2B,yBAAb,MAAkE;CAChE,IAAWJ,OAAO;EAChB,OAAO,KAAKK,eAAeL;CAC7B;CAEA;CACA;CACA;CAEAQ,YACEH,gBACAC,YACAC,WACA;EACA,KAAKF,iBAAiBA;EACtB,KAAKC,aAAaA;EAClB,KAAKC,YAAYA;EACjB,KAAKE,uBAAuB;CAC9B;CAEA,yBAAmC;EACjC,KAAKhB,gBAAgB,KAAKA,cAAciB,KAAK,IAAI;EACjD,KAAKf,iBAAiB,KAAKA,eAAee,KAAK,IAAI;EACnD,KAAKb,wBAAwB,KAAKA,sBAAsBa,KAAK,IAAI;EACjE,KAAKT,WAAW,KAAKA,SAASS,KAAK,IAAI;EACvC,KAAKR,YAAY,KAAKA,UAAUQ,KAAK,IAAI;CAC3C;CAEA,WAAkB;EAChB,OAAO,KAAKL,eAAeJ,SAAS;CACtC;CAEA,cAAqBP,QAAiC;EACpD,MAAMiB,QAAQ,KAAKN,eAAeJ,SAAS;EAC3C,IAAI,CAACU,OAAO,MAAM,IAAIC,MAAM,+BAA+B;EAE3D,IAAID,MAAME,SAAS,aACjB,MAAM,IAAID,MAAM,mDAAmD;EAErE,IAAI,CAAC,KAAKN,YACR,MAAM,IAAIM,MACR,qEACF;EACF,IAAI,CAAC,KAAKL,WAAW,MAAM,IAAIK,MAAM,6BAA6B;EAElE,MAAME,UAAU,KAAKR,WAAWL,SAAS;EACzC,IAAI,CAACa,SAAS,MAAM,IAAIF,MAAM,0BAA0B;EAExD,MAAMG,WAAWJ,MAAMI;EACvB,MAAMC,aAAaL,MAAMK;EAEzB,MAAMlB,WAAWV,aAAa6B,WAAWvB,MAAM;EAC/C,KAAKa,UAAUN,SAAS,CAAC,CAACR,cAAc;GACtCyB,WAAWJ,QAAQK;GACnBJ;GACAC;GACAtB,QAAQI,SAASJ;GACjB0B,UAAUtB,SAASsB;GACnBC,SAASvB,SAASuB;EACpB,CAAC;CACH;CAEA,eAAsBzB,SAAkB;EACtC,MAAMe,QAAQ,KAAKN,eAAeJ,SAAS;EAC3C,IAAI,CAACU,OAAO,MAAM,IAAIC,MAAM,+BAA+B;EAE3D,IAAID,MAAME,SAAS,aACjB,MAAM,IAAID,MAAM,oDAAoD;EAEtE,IAAI,CAAC,KAAKL,WAAW,MAAM,IAAIK,MAAM,6BAA6B;EAElE,MAAMI,aAAaL,MAAMK;EACzB,KAAKT,UAAUN,SAAS,CAAC,CAACN,eAAe;GACvCqB;GACApB;EACF,CAAC;CACH;CAEA,sBAA6BE,UAA+C;EAC1E,MAAMa,QAAQ,KAAKN,eAAeJ,SAAS;EAC3C,IAAI,CAACU,OAAO,MAAM,IAAIC,MAAM,+BAA+B;EAE3D,IAAID,MAAME,SAAS,aACjB,MAAM,IAAID,MACR,4DACF;EAEF,IACE,CAACD,MAAMW,YACPX,MAAMW,SAASC,aAAaC,KAAAA,KAC5Bb,MAAMW,SAASG,eAAeD,KAAAA,GAE9B,MAAM,IAAIZ,MAAM,mCAAmC;EAErD,IAAI,CAAC,KAAKL,WAAW,MAAM,IAAIK,MAAM,6BAA6B;EAElE,OAAO,KAAKL,UACTN,SAAS,CAAC,CACVJ,sBACChB,4BAA4B8B,MAAMW,UAAUxB,QAAQ,CACtD;CACJ;CAEA,UAAiBK,UAAsB;EACrC,OAAO,KAAKE,eAAeH,UAAUC,QAAQ;CAC/C;AACF"}
+{"version":3,"file":"message-part-runtime.js","names":["ThreadAssistantMessagePart","ThreadUserMessagePart","ToolApprovalResponse","ToolCallMessagePartStatus","resolveToolApprovalResponse","Unsubscribe","MessagePartStatus","SubscribableWithState","ThreadRuntimeCoreBinding","MessageStateBinding","MessagePartRuntimePath","ToolResponse","MessagePartState","status","MessagePartSnapshotBinding","MessagePartRuntime","addToolResult","result","resumeToolCall","payload","respondToToolApproval","response","Promise","path","getState","subscribe","callback","MessagePartRuntimeImpl","contentBinding","messageApi","threadApi","constructor","__internal_bindMethods","bind","state","Error","type","message","toolName","toolCallId","toResponse","messageId","id","isError","artifact","undefined","modelContent","approval","approved","resolution"],"sources":["../../../src/runtime/api/message-part-runtime.ts"],"sourcesContent":["import type {\n  ThreadAssistantMessagePart,\n  ThreadUserMessagePart,\n  ToolApprovalResponse,\n  ToolCallMessagePartStatus,\n} from \"../../types/message\";\nimport { resolveToolApprovalResponse } from \"../utils/resolveToolApprovalResponse\";\nimport type { Unsubscribe } from \"../../types/unsubscribe\";\nimport type { MessagePartStatus } from \"../../types/message\";\nimport type { SubscribableWithState } from \"../../subscribable/subscribable\";\nimport type { ThreadRuntimeCoreBinding } from \"./thread-runtime\";\nimport type { MessageStateBinding } from \"./bindings\";\nimport type { MessagePartRuntimePath } from \"./paths\";\nimport { ToolResponse } from \"assistant-stream\";\n\nexport type MessagePartState = (\n  | ThreadUserMessagePart\n  | ThreadAssistantMessagePart\n) & {\n  readonly status: MessagePartStatus | ToolCallMessagePartStatus;\n};\n\ntype MessagePartSnapshotBinding = SubscribableWithState<\n  MessagePartState,\n  MessagePartRuntimePath\n>;\n\nexport type MessagePartRuntime = {\n  addToolResult(result: any | ToolResponse<any>): void;\n  resumeToolCall(payload: unknown): void;\n  respondToToolApproval(response: ToolApprovalResponse): Promise<void>;\n\n  readonly path: MessagePartRuntimePath;\n  getState(): MessagePartState;\n  subscribe(callback: () => void): Unsubscribe;\n};\n\nexport class MessagePartRuntimeImpl implements MessagePartRuntime {\n  public get path() {\n    return this.contentBinding.path;\n  }\n\n  private contentBinding: MessagePartSnapshotBinding;\n  private messageApi: MessageStateBinding | undefined;\n  private threadApi: ThreadRuntimeCoreBinding | undefined;\n\n  constructor(\n    contentBinding: MessagePartSnapshotBinding,\n    messageApi?: MessageStateBinding,\n    threadApi?: ThreadRuntimeCoreBinding,\n  ) {\n    this.contentBinding = contentBinding;\n    this.messageApi = messageApi;\n    this.threadApi = threadApi;\n    this.__internal_bindMethods();\n  }\n\n  protected __internal_bindMethods() {\n    this.addToolResult = this.addToolResult.bind(this);\n    this.resumeToolCall = this.resumeToolCall.bind(this);\n    this.respondToToolApproval = this.respondToToolApproval.bind(this);\n    this.getState = this.getState.bind(this);\n    this.subscribe = this.subscribe.bind(this);\n  }\n\n  public getState() {\n    return this.contentBinding.getState();\n  }\n\n  public addToolResult(result: any | ToolResponse<any>) {\n    const state = this.contentBinding.getState();\n    if (!state) throw new Error(\"Message part is not available\");\n\n    if (state.type !== \"tool-call\")\n      throw new Error(\"Tried to add tool result to non-tool message part\");\n\n    if (!this.messageApi)\n      throw new Error(\n        \"Message API is not available. This is likely a bug in assistant-ui.\",\n      );\n    if (!this.threadApi) throw new Error(\"Thread API is not available\");\n\n    const message = this.messageApi.getState();\n    if (!message) throw new Error(\"Message is not available\");\n\n    const toolName = state.toolName;\n    const toolCallId = state.toolCallId;\n\n    const response = ToolResponse.toResponse(result);\n    this.threadApi.getState().addToolResult({\n      messageId: message.id,\n      toolName,\n      toolCallId,\n      result: response.result,\n      isError: response.isError,\n      ...(response.artifact !== undefined && { artifact: response.artifact }),\n      ...(response.modelContent !== undefined && {\n        modelContent: response.modelContent,\n      }),\n    });\n  }\n\n  public resumeToolCall(payload: unknown) {\n    const state = this.contentBinding.getState();\n    if (!state) throw new Error(\"Message part is not available\");\n\n    if (state.type !== \"tool-call\")\n      throw new Error(\"Tried to resume tool call on non-tool message part\");\n\n    if (!this.threadApi) throw new Error(\"Thread API is not available\");\n\n    const toolCallId = state.toolCallId;\n    this.threadApi.getState().resumeToolCall({\n      toolCallId,\n      payload,\n    });\n  }\n\n  public respondToToolApproval(response: ToolApprovalResponse): Promise<void> {\n    const state = this.contentBinding.getState();\n    if (!state) throw new Error(\"Message part is not available\");\n\n    if (state.type !== \"tool-call\")\n      throw new Error(\n        \"Tried to respond to tool approval on non-tool message part\",\n      );\n\n    if (\n      !state.approval ||\n      state.approval.approved !== undefined ||\n      state.approval.resolution !== undefined\n    )\n      throw new Error(\"Tool call has no pending approval\");\n\n    if (!this.threadApi) throw new Error(\"Thread API is not available\");\n\n    return this.threadApi\n      .getState()\n      .respondToToolApproval(\n        resolveToolApprovalResponse(state.approval, response),\n      );\n  }\n\n  public subscribe(callback: () => void) {\n    return this.contentBinding.subscribe(callback);\n  }\n}\n"],"mappings":";;;AAqCA,IAAa2B,yBAAb,MAAkE;CAChE,IAAWJ,OAAO;EAChB,OAAO,KAAKK,eAAeL;CAC7B;CAEA;CACA;CACA;CAEAQ,YACEH,gBACAC,YACAC,WACA;EACA,KAAKF,iBAAiBA;EACtB,KAAKC,aAAaA;EAClB,KAAKC,YAAYA;EACjB,KAAKE,uBAAuB;CAC9B;CAEA,yBAAmC;EACjC,KAAKhB,gBAAgB,KAAKA,cAAciB,KAAK,IAAI;EACjD,KAAKf,iBAAiB,KAAKA,eAAee,KAAK,IAAI;EACnD,KAAKb,wBAAwB,KAAKA,sBAAsBa,KAAK,IAAI;EACjE,KAAKT,WAAW,KAAKA,SAASS,KAAK,IAAI;EACvC,KAAKR,YAAY,KAAKA,UAAUQ,KAAK,IAAI;CAC3C;CAEA,WAAkB;EAChB,OAAO,KAAKL,eAAeJ,SAAS;CACtC;CAEA,cAAqBP,QAAiC;EACpD,MAAMiB,QAAQ,KAAKN,eAAeJ,SAAS;EAC3C,IAAI,CAACU,OAAO,MAAM,IAAIC,MAAM,+BAA+B;EAE3D,IAAID,MAAME,SAAS,aACjB,MAAM,IAAID,MAAM,mDAAmD;EAErE,IAAI,CAAC,KAAKN,YACR,MAAM,IAAIM,MACR,qEACF;EACF,IAAI,CAAC,KAAKL,WAAW,MAAM,IAAIK,MAAM,6BAA6B;EAElE,MAAME,UAAU,KAAKR,WAAWL,SAAS;EACzC,IAAI,CAACa,SAAS,MAAM,IAAIF,MAAM,0BAA0B;EAExD,MAAMG,WAAWJ,MAAMI;EACvB,MAAMC,aAAaL,MAAMK;EAEzB,MAAMlB,WAAWV,aAAa6B,WAAWvB,MAAM;EAC/C,KAAKa,UAAUN,SAAS,CAAC,CAACR,cAAc;GACtCyB,WAAWJ,QAAQK;GACnBJ;GACAC;GACAtB,QAAQI,SAASJ;GACjB0B,SAAStB,SAASsB;GAClB,GAAItB,SAASuB,aAAaC,KAAAA,KAAa,EAAED,UAAUvB,SAASuB,SAAS;GACrE,GAAIvB,SAASyB,iBAAiBD,KAAAA,KAAa,EACzCC,cAAczB,SAASyB,aACzB;EACF,CAAC;CACH;CAEA,eAAsB3B,SAAkB;EACtC,MAAMe,QAAQ,KAAKN,eAAeJ,SAAS;EAC3C,IAAI,CAACU,OAAO,MAAM,IAAIC,MAAM,+BAA+B;EAE3D,IAAID,MAAME,SAAS,aACjB,MAAM,IAAID,MAAM,oDAAoD;EAEtE,IAAI,CAAC,KAAKL,WAAW,MAAM,IAAIK,MAAM,6BAA6B;EAElE,MAAMI,aAAaL,MAAMK;EACzB,KAAKT,UAAUN,SAAS,CAAC,CAACN,eAAe;GACvCqB;GACApB;EACF,CAAC;CACH;CAEA,sBAA6BE,UAA+C;EAC1E,MAAMa,QAAQ,KAAKN,eAAeJ,SAAS;EAC3C,IAAI,CAACU,OAAO,MAAM,IAAIC,MAAM,+BAA+B;EAE3D,IAAID,MAAME,SAAS,aACjB,MAAM,IAAID,MACR,4DACF;EAEF,IACE,CAACD,MAAMa,YACPb,MAAMa,SAASC,aAAaH,KAAAA,KAC5BX,MAAMa,SAASE,eAAeJ,KAAAA,GAE9B,MAAM,IAAIV,MAAM,mCAAmC;EAErD,IAAI,CAAC,KAAKL,WAAW,MAAM,IAAIK,MAAM,6BAA6B;EAElE,OAAO,KAAKL,UACTN,SAAS,CAAC,CACVJ,sBACChB,4BAA4B8B,MAAMa,UAAU1B,QAAQ,CACtD;CACJ;CAEA,UAAiBK,UAAsB;EACrC,OAAO,KAAKE,eAAeH,UAAUC,QAAQ;CAC/C;AACF"}