@assistant-ui/core 0.2.9 → 0.2.10

package/dist/react/model-context/makeAssistantToolUI.js.map

@@ -1 +1 @@
-{"version":3,"file":"makeAssistantToolUI.js","names":[],"sources":["../../../src/react/model-context/makeAssistantToolUI.ts"],"sourcesContent":["import type { FC } from \"react\";\nimport {\n  type AssistantToolUIProps,\n  useAssistantToolUI,\n} from \"./useAssistantToolUI\";\n\n/**\n * Component returned by {@link makeAssistantToolUI}.\n *\n * Rendering the component registers a renderer for matching tool-call message\n * parts.\n */\nexport type AssistantToolUI = FC & {\n  /** Tool renderer registered by this component. */\n  unstable_tool: AssistantToolUIProps<any, any>;\n};\n\n/**\n * Creates a React component that registers a tool-call renderer when rendered.\n *\n * Use this to package reusable display components for tools whose definitions\n * are registered elsewhere.\n *\n * @param tool - Tool renderer registration.\n */\nexport const makeAssistantToolUI = <TArgs, TResult>(\n  tool: AssistantToolUIProps<TArgs, TResult>,\n) => {\n  const ToolUI: AssistantToolUI = () => {\n    useAssistantToolUI(tool);\n    return null;\n  };\n  ToolUI.unstable_tool = tool;\n  return ToolUI;\n};\n"],"mappings":";;;;;;;;;;AAyBA,MAAa,uBACX,SACG;CACH,MAAM,eAAgC;EACpC,mBAAmB,IAAI;EACvB,OAAO;CACT;CACA,OAAO,gBAAgB;CACvB,OAAO;AACT"}
+{"version":3,"file":"makeAssistantToolUI.js","names":[],"sources":["../../../src/react/model-context/makeAssistantToolUI.ts"],"sourcesContent":["import type { FC } from \"react\";\nimport {\n  type AssistantToolUIProps,\n  useAssistantToolUI,\n} from \"./useAssistantToolUI\";\n\n/**\n * Component returned by {@link makeAssistantToolUI}.\n *\n * Rendering the component registers a renderer for matching tool-call message\n * parts.\n *\n * @deprecated Put `render`/`renderText` on the matching toolkit entry, or use\n * `MessagePrimitive.Parts` inline tool render overrides for per-message UI.\n * See https://assistant-ui.com/docs/migrations/toolkit-tools.\n */\nexport type AssistantToolUI = FC & {\n  /** Tool renderer registered by this component. */\n  unstable_tool: AssistantToolUIProps<any, any>;\n};\n\n/**\n * Creates a React component that registers a tool-call renderer when rendered.\n *\n * Use this to package reusable display components for tools whose definitions\n * are registered elsewhere.\n *\n * @param tool - Tool renderer registration.\n *\n * @deprecated Put `render`/`renderText` on the matching toolkit entry, or use\n * `MessagePrimitive.Parts` inline tool render overrides for per-message UI.\n * See https://assistant-ui.com/docs/migrations/toolkit-tools.\n */\nexport const makeAssistantToolUI = <TArgs, TResult>(\n  tool: AssistantToolUIProps<TArgs, TResult>,\n) => {\n  const ToolUI: AssistantToolUI = () => {\n    useAssistantToolUI(tool);\n    return null;\n  };\n  ToolUI.unstable_tool = tool;\n  return ToolUI;\n};\n"],"mappings":";;;;;;;;;;;;;;AAiCA,MAAa,uBACX,SACG;CACH,MAAM,eAAgC;EACpC,mBAAmB,IAAI;EACvB,OAAO;CACT;CACA,OAAO,gBAAgB;CACvB,OAAO;AACT"}

package/dist/react/model-context/provider-tool.d.ts

@@ -0,0 +1,15 @@
+import { Tool } from "assistant-stream";
+
+//#region src/react/model-context/provider-tool.d.ts
+type ProviderToolDefinition<TArgs extends Record<string, unknown>> = Extract<Tool<TArgs, unknown>, {
+  type: "provider";
+}>;
+type ProviderToolConfig<TArgs extends Record<string, unknown> = Record<string, unknown>> = Pick<ProviderToolDefinition<TArgs>, "providerId" | "args" | "parameters" | "providerOptions" | "supportsDeferredResults">;
+/**
+ * Marks a tool as provider-executed. The use-generative compiler converts
+ * `execute: providerTool(...)` into a `type: "provider"` tool entry.
+ */
+declare function providerTool(_config: ProviderToolConfig): never;
+//#endregion
+export { ProviderToolConfig, providerTool };
+//# sourceMappingURL=provider-tool.d.ts.map

package/dist/react/model-context/provider-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-tool.d.ts","names":[],"sources":["../../../src/react/model-context/provider-tool.ts"],"mappings":";;;KAEK,sBAAA,eAAqC,MAAA,qBAA2B,OAAA,CACnE,IAAA,CAAK,KAAA;EACH,IAAA;AAAA;AAAA,KAGQ,kBAAA,eACI,MAAA,oBAA0B,MAAA,qBACtC,IAAA,CACF,sBAAA,CAAuB,KAAA;;;;;iBAYT,YAAA,CAAa,OAA2B,EAAlB,kBAAkB"}

package/dist/react/model-context/provider-tool.js

@@ -0,0 +1,12 @@
+//#region src/react/model-context/provider-tool.ts
+/**
+* Marks a tool as provider-executed. The use-generative compiler converts
+* `execute: providerTool(...)` into a `type: "provider"` tool entry.
+*/
+function providerTool(_config) {
+	throw new Error("[assistant-ui] providerTool() has no runtime implementation — it marks a provider-executed tool and is stripped at build time by the use-generative compiler. Reaching it means this module was not compiled (e.g. providerTool() used outside a \"use generative\" file).");
+}
+//#endregion
+export { providerTool };
+
+//# sourceMappingURL=provider-tool.js.map

package/dist/react/model-context/provider-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-tool.js","names":[],"sources":["../../../src/react/model-context/provider-tool.ts"],"sourcesContent":["import type { Tool } from \"assistant-stream\";\n\ntype ProviderToolDefinition<TArgs extends Record<string, unknown>> = Extract<\n  Tool<TArgs, unknown>,\n  { type: \"provider\" }\n>;\n\nexport type ProviderToolConfig<\n  TArgs extends Record<string, unknown> = Record<string, unknown>,\n> = Pick<\n  ProviderToolDefinition<TArgs>,\n  | \"providerId\"\n  | \"args\"\n  | \"parameters\"\n  | \"providerOptions\"\n  | \"supportsDeferredResults\"\n>;\n\n/**\n * Marks a tool as provider-executed. The use-generative compiler converts\n * `execute: providerTool(...)` into a `type: \"provider\"` tool entry.\n */\nexport function providerTool(_config: ProviderToolConfig): never {\n  throw new Error(\n    \"[assistant-ui] providerTool() has no runtime implementation — it marks a \" +\n      \"provider-executed tool and is stripped at build time by the \" +\n      \"use-generative compiler. Reaching it means this module was not compiled \" +\n      '(e.g. providerTool() used outside a \"use generative\" file).',\n  );\n}\n"],"mappings":";;;;;AAsBA,SAAgB,aAAa,SAAoC;CAC/D,MAAM,IAAI,MACR,4QAIF;AACF"}

package/dist/react/model-context/stub-tool.d.ts

@@ -0,0 +1,12 @@
+//#region src/react/model-context/stub-tool.d.ts
+/**
+ * Marks a generative toolkit entry as a frontend tool whose executor will be
+ * supplied by `useAuiToolOverrides(...)`.
+ *
+ * `stubTool()` has no runtime implementation. It must be used inside a
+ * `"use generative"` toolkit file so the compiler can strip it.
+ */
+declare function stubTool(): never;
+//#endregion
+export { stubTool };
+//# sourceMappingURL=stub-tool.d.ts.map

package/dist/react/model-context/stub-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stub-tool.d.ts","names":[],"sources":["../../../src/react/model-context/stub-tool.ts"],"mappings":";;AAOA;;;;AAAwB;;iBAAR,QAAA"}

package/dist/react/model-context/stub-tool.js

@@ -0,0 +1,15 @@
+//#region src/react/model-context/stub-tool.ts
+/**
+* Marks a generative toolkit entry as a frontend tool whose executor will be
+* supplied by `useAuiToolOverrides(...)`.
+*
+* `stubTool()` has no runtime implementation. It must be used inside a
+* `"use generative"` toolkit file so the compiler can strip it.
+*/
+function stubTool() {
+	throw new Error("[assistant-ui] stubTool() has no runtime implementation - it marks a tool executor that must be supplied via useAuiToolOverrides(...). Make sure this module is compiled as \"use generative\".");
+}
+//#endregion
+export { stubTool };
+
+//# sourceMappingURL=stub-tool.js.map

package/dist/react/model-context/stub-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stub-tool.js","names":[],"sources":["../../../src/react/model-context/stub-tool.ts"],"sourcesContent":["/**\n * Marks a generative toolkit entry as a frontend tool whose executor will be\n * supplied by `useAuiToolOverrides(...)`.\n *\n * `stubTool()` has no runtime implementation. It must be used inside a\n * `\"use generative\"` toolkit file so the compiler can strip it.\n */\nexport function stubTool(): never {\n  throw new Error(\n    \"[assistant-ui] stubTool() has no runtime implementation - it marks a \" +\n      \"tool executor that must be supplied via useAuiToolOverrides(...). Make \" +\n      'sure this module is compiled as \"use generative\".',\n  );\n}\n"],"mappings":";;;;;;;;AAOA,SAAgB,WAAkB;CAChC,MAAM,IAAI,MACR,iMAGF;AACF"}

package/dist/react/model-context/toolbox.d.ts

@@ -1,5 +1,6 @@
 import { ToolCallMessagePartComponent } from "../types/MessagePartComponentTypes.js";
-import { Tool, ToolDeclaration } from "assistant-stream";
+import { Tool, ToolCallReader, ToolDeclaration, ToolModelOutputFunction } from "assistant-stream";
+import { ReactNode } from "react";
 
 //#region src/react/model-context/toolbox.d.ts
 /**
@@ -14,21 +15,47 @@ import { Tool, ToolDeclaration } from "assistant-stream";
 declare const isStandaloneToolDisplay: (tool: Pick<Tool<any, any>, "type" | "display">) => boolean;
 type WithRender<T, TArgs extends Record<string, unknown>, TResult> = T extends {
   type: "frontend" | "human";
-} ? T & {
+} ? T & (T extends {
+  type: "frontend";
+} ? {
   render: ToolCallMessagePartComponent<TArgs, TResult>;
-} : T & {
+} | {
+  render?: ToolCallMessagePartComponent<TArgs, TResult>;
+  renderText: ToolCallText<TArgs, TResult>;
+} : {
+  render: ToolCallMessagePartComponent<TArgs, TResult>;
+}) : T & {
   render?: ToolCallMessagePartComponent<TArgs, TResult> | undefined;
+  renderText?: ToolCallText<TArgs, TResult> | undefined;
+};
+type ToolParameters<TArgs extends Record<string, unknown>> = ToolDeclaration<TArgs>["parameters"];
+type ToolExecuteContext = Parameters<NonNullable<ToolDeclaration["execute"]>>[1];
+type ToolExecute<TArgs extends Record<string, unknown>, TResult> = (args: TArgs, context: ToolExecuteContext) => TResult | Promise<TResult>;
+type ToolStreamCall<TArgs extends Record<string, unknown>, TResult> = (reader: ToolCallReader<TArgs, TResult>, context: ToolExecuteContext) => void;
+type ToolCallRunningText<TArgs extends Record<string, unknown>> = ReactNode | ((options: {
+  args: TArgs;
+}) => ReactNode);
+type ToolCallCompleteText<TArgs extends Record<string, unknown>, TResult> = ReactNode | ((options: {
+  args: TArgs;
+  result: TResult | undefined;
+}) => ReactNode);
+type ToolCallText<TArgs extends Record<string, unknown>, TResult> = {
+  running: ToolCallRunningText<TArgs>;
+  complete?: ToolCallCompleteText<TArgs, TResult> | undefined;
+} | {
+  running?: ToolCallRunningText<TArgs> | undefined;
+  complete: ToolCallCompleteText<TArgs, TResult>;
 };
+declare const makeToolCallTextComponent: <TArgs extends Record<string, unknown>, TResult>(text: ToolCallText<TArgs, TResult>) => ToolCallMessagePartComponent<TArgs, TResult>;
 /**
  * Tool definition accepted by the React tool registry.
  *
- * Extends the core tool contract with a render component. Human tools rely on
- * the renderer to collect input from the user. Frontend tools execute in the
- * browser and require a UI surface for their progress and result. Backend
- * tools execute server-side and may omit a renderer. The `render` component is
- * required for frontend and human tools and optional for backend tools.
+ * Extends the core tool contract with tool-call display options. Human tools
+ * rely on `render` to collect input from the user. Frontend tools execute in
+ * the browser and require either `render` or `renderText` for their progress
+ * and result. Backend tools execute server-side and may omit a renderer.
  */
-type ToolDefinition<TArgs extends Record<string, unknown>, TResult> = WithRender<Tool<TArgs, TResult>, TArgs, TResult>;
+type ToolDefinition<TArgs extends Record<string, unknown> = Record<string, unknown>, TResult = unknown> = WithRender<Tool<TArgs, TResult>, TArgs, TResult>;
 /**
  * Named collection of tools exposed to the assistant model.
  *
@@ -52,23 +79,43 @@ type Toolkit = Record<string, ToolDefinition<any, any>>;
  * A tool as authored, before the build splits it: like {@link ToolDefinition}
  * but it may declare `description`, `parameters`, and a server-side `execute`
  * alongside its `render`. The `type` field is **not** authored — the
- * `"use generative"` compiler infers it (`execute: hitl()` → human; `execute`
- * with a `"use client"` directive → frontend; otherwise backend) and writes it
- * back — so declaring it here is a type error.
+ * `"use generative"` compiler infers it (`execute: hitlTool()` → human;
+ * `execute: providerTool(...)` → provider; `execute` with a `"use client"`
+ * directive → frontend; otherwise backend) and writes it back — so declaring it
+ * here is a type error.
  */
-type ToolkitDeclarationDefinition<TArgs extends Record<string, unknown>, TResult> = WithRender<Omit<ToolDeclaration<TArgs, TResult>, "type">, TArgs, TResult> & {
+type OverrideOptionalField<T, TKey extends keyof T, TValue> = undefined extends T[TKey] ? Exclude<T[TKey], undefined> extends never ? { [K in TKey]?: undefined } : { [K in TKey]?: TValue | undefined } : { [K in TKey]: TValue };
+type OverrideToolDeclarationCallbacks<T extends {
+  streamCall?: unknown;
+}, TArgs extends Record<string, unknown>, TResult> = Omit<T, "type" | "execute" | "toModelOutput" | "experimental_onSchemaValidationError" | "streamCall"> & {
   type?: never;
+} & ("execute" extends keyof T ? OverrideOptionalField<T, "execute", ToolExecute<NoInfer<TArgs>, TResult>> : {}) & ("toModelOutput" extends keyof T ? OverrideOptionalField<T, "toModelOutput", ToolModelOutputFunction<NoInfer<TArgs>, NoInfer<TResult>>> : {}) & ("experimental_onSchemaValidationError" extends keyof T ? OverrideOptionalField<T, "experimental_onSchemaValidationError", (args: unknown, context: ToolExecuteContext) => NoInfer<TResult> | Promise<NoInfer<TResult>>> : {}) & OverrideOptionalField<T, "streamCall", ToolStreamCall<TArgs, NoInfer<TResult>>>;
+type ToolkitDefinitionInput<TArgs extends Record<string, unknown>, TResult> = WithRender<ToolDeclaration<TArgs, TResult> extends infer T ? T extends {
+  streamCall?: unknown;
+} ? OverrideToolDeclarationCallbacks<T, TArgs, TResult> : never : never, TArgs, TResult>;
+/**
+ * A single entry in a {@link ToolkitDefinition}.
+ *
+ * Either authored inline (whose `type` the compiler infers) or an already-formed
+ * {@link ToolDefinition} produced by a factory whose own build splits it across
+ * targets — e.g. `new JSONGenerativeUI({ library }).present()`. The factory case
+ * carries a `type`, so it can only match the {@link ToolDefinition} arm of this
+ * union.
+ */
+type ToolkitDefinitionEntry<TArgs extends Record<string, unknown> = Record<string, unknown>, TResult = unknown> = ToolkitDefinitionInput<TArgs, TResult> | ToolDefinition<any, any>;
+type ToolkitDefinitionEntryWithParameters<TArgs extends Record<string, unknown> = Record<string, unknown>, TResult = unknown> = ToolkitDefinitionInput<TArgs, TResult> & {
+  parameters: NonNullable<ToolParameters<TArgs>>;
 };
 /**
  * The permissive, authoring-time counterpart to {@link Toolkit} — the input to
  * {@link defineToolkit}. Backend entries may carry their server `execute` here;
  * the canonical {@link Toolkit} keeps those fields `undefined`.
  */
-type ToolkitDeclaration = Record<string, ToolkitDeclarationDefinition<any, any>>;
+type ToolkitDefinition<TArgsByName extends { [K in keyof TArgsByName]: Record<string, unknown> } = Record<string, any>, TResultByName extends { [K in keyof TArgsByName]: unknown } = { [K in keyof TArgsByName]: any }> = { [K in keyof TArgsByName]: ToolkitDefinitionEntry<TArgsByName[K], TResultByName[K]> };
 /** Configuration for the {@link Tools} resource. */
 type ToolsConfig = {
   /** Tools to register with model context and, when provided, message renderers. */toolkit: Toolkit;
 };
 //#endregion
-export { ToolDefinition, Toolkit, ToolkitDeclaration, ToolkitDeclarationDefinition, ToolsConfig, isStandaloneToolDisplay };
+export { ToolCallText, ToolDefinition, Toolkit, ToolkitDefinition, ToolkitDefinitionEntry, ToolkitDefinitionEntryWithParameters, ToolsConfig, isStandaloneToolDisplay, makeToolCallTextComponent };
 //# sourceMappingURL=toolbox.d.ts.map

package/dist/react/model-context/toolbox.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolbox.d.ts","names":[],"sources":["../../../src/react/model-context/toolbox.ts"],"mappings":";;;;;;AAYA;;;;;;;cAAa,uBAAA,GACX,IAAA,EAAM,IAAI,CAAC,IAAA;AAAA,KAMR,UAAA,kBAA4B,MAAA,8BAAoC,CAAA;EACnE,IAAA;AAAA,IAEE,CAAA;EAAM,MAAA,EAAQ,4BAAA,CAA6B,KAAA,EAAO,OAAA;AAAA,IAClD,CAAA;EACE,MAAA,GAAS,4BAAA,CAA6B,KAAA,EAAO,OAAA;AAAA;;;;;;;;;;KAYvC,cAAA,eACI,MAAA,8BAEZ,UAAA,CAAW,IAAA,CAAK,KAAA,EAAO,OAAA,GAAU,KAAA,EAAO,OAAA;;;;;;;;;;;;;;;;;AAfc;AAY1D;KAuBY,OAAA,GAAU,MAAM,SAAS,cAAA;;;;;;;;;KAUzB,4BAAA,eACI,MAAA,8BAEZ,UAAA,CACF,IAAA,CAAK,eAAA,CAAgB,KAAA,EAAO,OAAA,YAC5B,KAAA,EACA,OAAA;EAEA,IAAA;AAAA;;;;;;KAQU,kBAAA,GAAqB,MAAM,SAErC,4BAAA;;KAIU,WAAA;EApDuC,kFAsDjD,OAAA,EAAS,OAAO;AAAA"}
+{"version":3,"file":"toolbox.d.ts","names":[],"sources":["../../../src/react/model-context/toolbox.ts"],"mappings":"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"}

package/dist/react/model-context/toolbox.js

@@ -12,7 +12,25 @@ const isStandaloneToolDisplay = (tool) => {
 	if (tool.display !== void 0) return tool.display === "standalone";
 	return tool.type === "human";
 };
+const resolveToolCallText = (text, part) => {
+	if (!(part.status?.type === "running" || part.status?.type === "requires-action")) {
+		const value = text.complete;
+		if (typeof value !== "function") return value ?? null;
+		return value({
+			args: part.args,
+			result: part.result
+		});
+	}
+	const value = text.running;
+	if (typeof value !== "function") return value ?? null;
+	return value({ args: part.args });
+};
+const makeToolCallTextComponent = (text) => {
+	return function ToolCallTextComponent(part) {
+		return resolveToolCallText(text, part);
+	};
+};
 //#endregion
-export { isStandaloneToolDisplay };
+export { isStandaloneToolDisplay, makeToolCallTextComponent };
 
 //# sourceMappingURL=toolbox.js.map

package/dist/react/model-context/toolbox.js.map

@@ -1 +1 @@
-{"version":3,"file":"toolbox.js","names":[],"sources":["../../../src/react/model-context/toolbox.ts"],"sourcesContent":["import type { Tool, ToolDeclaration } from \"assistant-stream\";\nimport type { ToolCallMessagePartComponent } from \"../types/MessagePartComponentTypes\";\n\n/**\n * Resolves whether a tool's UI should be presented standalone (outside the\n * chain-of-thought grouping), applying the type-based defaults.\n *\n * An explicit `display` wins. Otherwise `human` tools default to standalone\n * (they prompt the user), and every other tool defaults to inline (a trace of\n * what the model is doing). MCP-app tool calls are detected separately from\n * the part itself and are not resolved here.\n */\nexport const isStandaloneToolDisplay = (\n  tool: Pick<Tool<any, any>, \"type\" | \"display\">,\n): boolean => {\n  if (tool.display !== undefined) return tool.display === \"standalone\";\n  return tool.type === \"human\";\n};\n\ntype WithRender<T, TArgs extends Record<string, unknown>, TResult> = T extends {\n  type: \"frontend\" | \"human\";\n}\n  ? T & { render: ToolCallMessagePartComponent<TArgs, TResult> }\n  : T & {\n      render?: ToolCallMessagePartComponent<TArgs, TResult> | undefined;\n    };\n\n/**\n * Tool definition accepted by the React tool registry.\n *\n * Extends the core tool contract with a render component. Human tools rely on\n * the renderer to collect input from the user. Frontend tools execute in the\n * browser and require a UI surface for their progress and result. Backend\n * tools execute server-side and may omit a renderer. The `render` component is\n * required for frontend and human tools and optional for backend tools.\n */\nexport type ToolDefinition<\n  TArgs extends Record<string, unknown>,\n  TResult,\n> = WithRender<Tool<TArgs, TResult>, TArgs, TResult>;\n\n/**\n * Named collection of tools exposed to the assistant model.\n *\n * Keys are the tool names the model receives and uses in tool calls.\n *\n * @example\n * ```tsx\n * const toolkit = {\n *   get_weather: {\n *     type: \"frontend\",\n *     description: \"Get the weather for a city.\",\n *     parameters: weatherSchema,\n *     execute: async ({ city }: { city: string }) => fetchWeather(city),\n *     render: WeatherToolUI,\n *   },\n * } satisfies Toolkit;\n * ```\n */\nexport type Toolkit = Record<string, ToolDefinition<any, any>>;\n\n/**\n * A tool as authored, before the build splits it: like {@link ToolDefinition}\n * but it may declare `description`, `parameters`, and a server-side `execute`\n * alongside its `render`. The `type` field is **not** authored — the\n * `\"use generative\"` compiler infers it (`execute: hitl()` → human; `execute`\n * with a `\"use client\"` directive → frontend; otherwise backend) and writes it\n * back — so declaring it here is a type error.\n */\nexport type ToolkitDeclarationDefinition<\n  TArgs extends Record<string, unknown>,\n  TResult,\n> = WithRender<\n  Omit<ToolDeclaration<TArgs, TResult>, \"type\">,\n  TArgs,\n  TResult\n> & {\n  type?: never;\n};\n\n/**\n * The permissive, authoring-time counterpart to {@link Toolkit} — the input to\n * {@link defineToolkit}. Backend entries may carry their server `execute` here;\n * the canonical {@link Toolkit} keeps those fields `undefined`.\n */\nexport type ToolkitDeclaration = Record<\n  string,\n  ToolkitDeclarationDefinition<any, any>\n>;\n\n/** Configuration for the {@link Tools} resource. */\nexport type ToolsConfig = {\n  /** Tools to register with model context and, when provided, message renderers. */\n  toolkit: Toolkit;\n};\n"],"mappings":";;;;;;;;;;AAYA,MAAa,2BACX,SACY;CACZ,IAAI,KAAK,YAAY,KAAA,GAAW,OAAO,KAAK,YAAY;CACxD,OAAO,KAAK,SAAS;AACvB"}
+{"version":3,"file":"toolbox.js","names":[],"sources":["../../../src/react/model-context/toolbox.ts"],"sourcesContent":["import type {\n  Tool,\n  ToolCallReader,\n  ToolDeclaration,\n  ToolModelOutputFunction,\n} from \"assistant-stream\";\nimport type { ReactNode } from \"react\";\nimport type {\n  ToolCallMessagePartComponent,\n  ToolCallMessagePartProps,\n} from \"../types/MessagePartComponentTypes\";\n\n/**\n * Resolves whether a tool's UI should be presented standalone (outside the\n * chain-of-thought grouping), applying the type-based defaults.\n *\n * An explicit `display` wins. Otherwise `human` tools default to standalone\n * (they prompt the user), and every other tool defaults to inline (a trace of\n * what the model is doing). MCP-app tool calls are detected separately from\n * the part itself and are not resolved here.\n */\nexport const isStandaloneToolDisplay = (\n  tool: Pick<Tool<any, any>, \"type\" | \"display\">,\n): boolean => {\n  if (tool.display !== undefined) return tool.display === \"standalone\";\n  return tool.type === \"human\";\n};\n\ntype WithRender<T, TArgs extends Record<string, unknown>, TResult> = T extends {\n  type: \"frontend\" | \"human\";\n}\n  ? T &\n      (T extends { type: \"frontend\" }\n        ?\n            | { render: ToolCallMessagePartComponent<TArgs, TResult> }\n            | {\n                render?: ToolCallMessagePartComponent<TArgs, TResult>;\n                renderText: ToolCallText<TArgs, TResult>;\n              }\n        : { render: ToolCallMessagePartComponent<TArgs, TResult> })\n  : T & {\n      render?: ToolCallMessagePartComponent<TArgs, TResult> | undefined;\n      renderText?: ToolCallText<TArgs, TResult> | undefined;\n    };\n\ntype ToolParameters<TArgs extends Record<string, unknown>> =\n  ToolDeclaration<TArgs>[\"parameters\"];\n\n// ToolExecutionContext is not re-exported from assistant-stream's public entry.\ntype ToolExecuteContext = Parameters<\n  NonNullable<ToolDeclaration[\"execute\"]>\n>[1];\n\ntype ToolExecute<TArgs extends Record<string, unknown>, TResult> = (\n  args: TArgs,\n  context: ToolExecuteContext,\n) => TResult | Promise<TResult>;\n\ntype ToolStreamCall<TArgs extends Record<string, unknown>, TResult> = (\n  reader: ToolCallReader<TArgs, TResult>,\n  context: ToolExecuteContext,\n) => void;\n\ntype ToolCallRunningText<TArgs extends Record<string, unknown>> =\n  | ReactNode\n  | ((options: { args: TArgs }) => ReactNode);\n\ntype ToolCallCompleteText<TArgs extends Record<string, unknown>, TResult> =\n  | ReactNode\n  | ((options: { args: TArgs; result: TResult | undefined }) => ReactNode);\n\nexport type ToolCallText<TArgs extends Record<string, unknown>, TResult> =\n  | {\n      running: ToolCallRunningText<TArgs>;\n      complete?: ToolCallCompleteText<TArgs, TResult> | undefined;\n    }\n  | {\n      running?: ToolCallRunningText<TArgs> | undefined;\n      complete: ToolCallCompleteText<TArgs, TResult>;\n    };\n\nconst resolveToolCallText = <TArgs extends Record<string, unknown>, TResult>(\n  text: ToolCallText<TArgs, TResult>,\n  part: ToolCallMessagePartProps<TArgs, TResult>,\n): ReactNode => {\n  const isRunning =\n    part.status?.type === \"running\" || part.status?.type === \"requires-action\";\n\n  if (!isRunning) {\n    const value = text.complete;\n    if (typeof value !== \"function\") return value ?? null;\n    return value({ args: part.args, result: part.result });\n  }\n\n  const value = text.running;\n  if (typeof value !== \"function\") return value ?? null;\n  return value({ args: part.args });\n};\n\nexport const makeToolCallTextComponent = <\n  TArgs extends Record<string, unknown>,\n  TResult,\n>(\n  text: ToolCallText<TArgs, TResult>,\n): ToolCallMessagePartComponent<TArgs, TResult> => {\n  return function ToolCallTextComponent(part) {\n    return resolveToolCallText(text, part);\n  };\n};\n\n/**\n * Tool definition accepted by the React tool registry.\n *\n * Extends the core tool contract with tool-call display options. Human tools\n * rely on `render` to collect input from the user. Frontend tools execute in\n * the browser and require either `render` or `renderText` for their progress\n * and result. Backend tools execute server-side and may omit a renderer.\n */\nexport type ToolDefinition<\n  TArgs extends Record<string, unknown> = Record<string, unknown>,\n  TResult = unknown,\n> = WithRender<Tool<TArgs, TResult>, TArgs, TResult>;\n\n/**\n * Named collection of tools exposed to the assistant model.\n *\n * Keys are the tool names the model receives and uses in tool calls.\n *\n * @example\n * ```tsx\n * const toolkit = {\n *   get_weather: {\n *     type: \"frontend\",\n *     description: \"Get the weather for a city.\",\n *     parameters: weatherSchema,\n *     execute: async ({ city }: { city: string }) => fetchWeather(city),\n *     render: WeatherToolUI,\n *   },\n * } satisfies Toolkit;\n * ```\n */\nexport type Toolkit = Record<string, ToolDefinition<any, any>>;\n\n/**\n * A tool as authored, before the build splits it: like {@link ToolDefinition}\n * but it may declare `description`, `parameters`, and a server-side `execute`\n * alongside its `render`. The `type` field is **not** authored — the\n * `\"use generative\"` compiler infers it (`execute: hitlTool()` → human;\n * `execute: providerTool(...)` → provider; `execute` with a `\"use client\"`\n * directive → frontend; otherwise backend) and writes it back — so declaring it\n * here is a type error.\n */\ntype OverrideOptionalField<\n  T,\n  TKey extends keyof T,\n  TValue,\n> = undefined extends T[TKey]\n  ? // Preserve `?: undefined` fields (for variants that explicitly disallow a\n    // callback) instead of widening them to accept the override value.\n    Exclude<T[TKey], undefined> extends never\n    ? { [K in TKey]?: undefined }\n    : { [K in TKey]?: TValue | undefined }\n  : { [K in TKey]: TValue };\n\ntype OverrideToolDeclarationCallbacks<\n  T extends { streamCall?: unknown },\n  TArgs extends Record<string, unknown>,\n  TResult,\n> = Omit<\n  T,\n  | \"type\"\n  | \"execute\"\n  | \"toModelOutput\"\n  | \"experimental_onSchemaValidationError\"\n  | \"streamCall\"\n> & {\n  type?: never;\n} & (\"execute\" extends keyof T\n    ? OverrideOptionalField<T, \"execute\", ToolExecute<NoInfer<TArgs>, TResult>>\n    : {}) &\n  (\"toModelOutput\" extends keyof T\n    ? OverrideOptionalField<\n        T,\n        \"toModelOutput\",\n        ToolModelOutputFunction<NoInfer<TArgs>, NoInfer<TResult>>\n      >\n    : {}) &\n  (\"experimental_onSchemaValidationError\" extends keyof T\n    ? OverrideOptionalField<\n        T,\n        \"experimental_onSchemaValidationError\",\n        (\n          args: unknown,\n          context: ToolExecuteContext,\n        ) => NoInfer<TResult> | Promise<NoInfer<TResult>>\n      >\n    : {}) &\n  OverrideOptionalField<\n    T,\n    \"streamCall\",\n    ToolStreamCall<TArgs, NoInfer<TResult>>\n  >;\n\n// Keep the authored shape tied to ToolDeclaration's union variants while\n// overriding callback fields to avoid inference pollution.\ntype ToolkitDefinitionInput<\n  TArgs extends Record<string, unknown>,\n  TResult,\n> = WithRender<\n  ToolDeclaration<TArgs, TResult> extends infer T\n    ? T extends { streamCall?: unknown }\n      ? OverrideToolDeclarationCallbacks<T, TArgs, TResult>\n      : never\n    : never,\n  TArgs,\n  TResult\n>;\n\n/**\n * A single entry in a {@link ToolkitDefinition}.\n *\n * Either authored inline (whose `type` the compiler infers) or an already-formed\n * {@link ToolDefinition} produced by a factory whose own build splits it across\n * targets — e.g. `new JSONGenerativeUI({ library }).present()`. The factory case\n * carries a `type`, so it can only match the {@link ToolDefinition} arm of this\n * union.\n */\nexport type ToolkitDefinitionEntry<\n  TArgs extends Record<string, unknown> = Record<string, unknown>,\n  TResult = unknown,\n> = ToolkitDefinitionInput<TArgs, TResult> | ToolDefinition<any, any>;\n\nexport type ToolkitDefinitionEntryWithParameters<\n  TArgs extends Record<string, unknown> = Record<string, unknown>,\n  TResult = unknown,\n> = ToolkitDefinitionInput<TArgs, TResult> & {\n  parameters: NonNullable<ToolParameters<TArgs>>;\n};\n\n/**\n * The permissive, authoring-time counterpart to {@link Toolkit} — the input to\n * {@link defineToolkit}. Backend entries may carry their server `execute` here;\n * the canonical {@link Toolkit} keeps those fields `undefined`.\n */\nexport type ToolkitDefinition<\n  TArgsByName extends {\n    [K in keyof TArgsByName]: Record<string, unknown>;\n  } = Record<string, any>,\n  TResultByName extends { [K in keyof TArgsByName]: unknown } = {\n    [K in keyof TArgsByName]: any;\n  },\n> = {\n  [K in keyof TArgsByName]: ToolkitDefinitionEntry<\n    TArgsByName[K],\n    TResultByName[K]\n  >;\n};\n\n/** Configuration for the {@link Tools} resource. */\nexport type ToolsConfig = {\n  /** Tools to register with model context and, when provided, message renderers. */\n  toolkit: Toolkit;\n};\n"],"mappings":";;;;;;;;;;AAqBA,MAAa,2BACX,SACY;CACZ,IAAI,KAAK,YAAY,KAAA,GAAW,OAAO,KAAK,YAAY;CACxD,OAAO,KAAK,SAAS;AACvB;AAuDA,MAAM,uBACJ,MACA,SACc;CAId,IAAI,EAFF,KAAK,QAAQ,SAAS,aAAa,KAAK,QAAQ,SAAS,oBAE3C;EACd,MAAM,QAAQ,KAAK;EACnB,IAAI,OAAO,UAAU,YAAY,OAAO,SAAS;EACjD,OAAO,MAAM;GAAE,MAAM,KAAK;GAAM,QAAQ,KAAK;EAAO,CAAC;CACvD;CAEA,MAAM,QAAQ,KAAK;CACnB,IAAI,OAAO,UAAU,YAAY,OAAO,SAAS;CACjD,OAAO,MAAM,EAAE,MAAM,KAAK,KAAK,CAAC;AAClC;AAEA,MAAa,6BAIX,SACiD;CACjD,OAAO,SAAS,sBAAsB,MAAM;EAC1C,OAAO,oBAAoB,MAAM,IAAI;CACvC;AACF"}

package/dist/react/model-context/useAssistantTool.d.ts

@@ -1,12 +1,18 @@
 import { AssistantToolProps as AssistantToolProps$1 } from "../../model-context/types.js";
 import { ToolCallMessagePartComponent } from "../types/MessagePartComponentTypes.js";
+import { ToolCallText } from "./toolbox.js";
 
 //#region src/react/model-context/useAssistantTool.d.ts
 /**
  * Props used to register a tool from React.
+ *
+ * @deprecated Use a toolkit with `Tools({ toolkit })` and register it via
+ * `useAui({ tools: Tools({ toolkit }) })` instead. See
+ * https://assistant-ui.com/docs/migrations/toolkit-tools.
  */
 type AssistantToolProps<TArgs extends Record<string, unknown>, TResult> = AssistantToolProps$1<TArgs, TResult> & {
-  /** Component used to render calls to this tool in assistant messages. */render?: ToolCallMessagePartComponent<TArgs, TResult> | undefined;
+  /** Component used to render calls to this tool in assistant messages. */render?: ToolCallMessagePartComponent<TArgs, TResult> | undefined; /** Lightweight text rendered while a tool call is running or complete. */
+  renderText?: ToolCallText<TArgs, TResult> | undefined;
 };
 /**
  * Registers a tool with the assistant model context while the component is
@@ -21,6 +27,10 @@ type AssistantToolProps<TArgs extends Record<string, unknown>, TResult> = Assist
  *
  * @param tool - Tool definition and name to register.
  *
+ * @deprecated Use a toolkit with `Tools({ toolkit })` and register it via
+ * `useAui({ tools: Tools({ toolkit }) })` instead. See
+ * https://assistant-ui.com/docs/migrations/toolkit-tools.
+ *
  * @example
  * ```tsx
  * const weatherTool = {

package/dist/react/model-context/useAssistantTool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAssistantTool.d.ts","names":[],"sources":["../../../src/react/model-context/useAssistantTool.ts"],"mappings":";;;;;;;KASY,kBAAA,eACI,MAAA,8BAEZ,oBAAA,CAAuB,KAAA,EAAO,OAAA;EAHJ,yEAK5B,MAAA,GAAS,4BAAA,CAA6B,KAAA,EAAO,OAAA;AAAA;;;;;;;;;;;;;;;;;;;;AAAO;AAiCtD;;;;;;;;;;cAAa,gBAAA,iBACG,MAAA,4BAGd,IAAA,EAAM,kBAAA,CAAmB,KAAA,EAAO,OAAA"}
+{"version":3,"file":"useAssistantTool.d.ts","names":[],"sources":["../../../src/react/model-context/useAssistantTool.ts"],"mappings":";;;;;;;;AAiBA;;;;KAAY,kBAAA,eACI,MAAA,8BAEZ,oBAAA,CAAuB,KAAA,EAAO,OAAA;EAAA,yEAEhC,MAAA,GAAS,4BAAA,CAA6B,KAAA,EAAO,OAAA,eAAP;EAEtC,UAAA,GAAa,YAAA,CAAa,KAAA,EAAO,OAAA;AAAA;;;;;;;;;;;;;;;;;;;;;AAAO;AAqC1C;;;;;;;;;;;;;cAAa,gBAAA,iBACG,MAAA,4BAGd,IAAA,EAAM,kBAAA,CAAmB,KAAA,EAAO,OAAA"}

package/dist/react/model-context/useAssistantTool.js

@@ -1,5 +1,5 @@
-import { isStandaloneToolDisplay } from "./toolbox.js";
-import { useEffect } from "react";
+import { isStandaloneToolDisplay, makeToolCallTextComponent } from "./toolbox.js";
+import { useEffect, useMemo } from "react";
 import { useAui } from "@assistant-ui/store";
 //#region src/react/model-context/useAssistantTool.ts
 /**
@@ -15,6 +15,10 @@ import { useAui } from "@assistant-ui/store";
 *
 * @param tool - Tool definition and name to register.
 *
+* @deprecated Use a toolkit with `Tools({ toolkit })` and register it via
+* `useAui({ tools: Tools({ toolkit }) })` instead. See
+* https://assistant-ui.com/docs/migrations/toolkit-tools.
+*
 * @example
 * ```tsx
 * const weatherTool = {
@@ -35,17 +39,19 @@ import { useAui } from "@assistant-ui/store";
 const useAssistantTool = (tool) => {
 	const aui = useAui();
 	const standalone = isStandaloneToolDisplay(tool);
+	const renderTextComponent = useMemo(() => tool.renderText ? makeToolCallTextComponent(tool.renderText) : void 0, [tool.renderText]);
+	const render = tool.render ?? renderTextComponent;
 	useEffect(() => {
-		if (!tool.render) return void 0;
-		return aui.tools().setToolUI(tool.toolName, tool.render, { standalone });
+		if (!render) return void 0;
+		return aui.tools().setToolUI(tool.toolName, render, { standalone });
 	}, [
 		aui,
 		tool.toolName,
-		tool.render,
+		render,
 		standalone
 	]);
 	useEffect(() => {
-		const { toolName, render, display, ...rest } = tool;
+		const { toolName, render, renderText, display, ...rest } = tool;
 		const context = { tools: { [toolName]: rest } };
 		return aui.modelContext().register({ getModelContext: () => context });
 	}, [aui, tool]);

package/dist/react/model-context/useAssistantTool.js.map

@@ -1 +1 @@
-{"version":3,"file":"useAssistantTool.js","names":[],"sources":["../../../src/react/model-context/useAssistantTool.ts"],"sourcesContent":["import { useEffect } from \"react\";\nimport { useAui } from \"@assistant-ui/store\";\nimport type { ToolCallMessagePartComponent } from \"../types/MessagePartComponentTypes\";\nimport type { AssistantToolProps as CoreAssistantToolProps } from \"../..\";\nimport { isStandaloneToolDisplay } from \"./toolbox\";\n\n/**\n * Props used to register a tool from React.\n */\nexport type AssistantToolProps<\n  TArgs extends Record<string, unknown>,\n  TResult,\n> = CoreAssistantToolProps<TArgs, TResult> & {\n  /** Component used to render calls to this tool in assistant messages. */\n  render?: ToolCallMessagePartComponent<TArgs, TResult> | undefined;\n};\n\n/**\n * Registers a tool with the assistant model context while the component is\n * mounted.\n *\n * If `render` is provided, it is also installed as the renderer for matching\n * tool-call message parts. The registration is removed automatically when the\n * component unmounts or the tool definition changes.\n *\n * Pass a referentially stable tool object, such as one declared at module\n * scope or memoized with `useMemo`, to avoid re-registering on every render.\n *\n * @param tool - Tool definition and name to register.\n *\n * @example\n * ```tsx\n * const weatherTool = {\n *   toolName: \"get_weather\",\n *   type: \"frontend\",\n *   description: \"Get the weather for a city.\",\n *   parameters: weatherSchema,\n *   execute: async ({ city }: { city: string }) => fetchWeather(city),\n *   render: WeatherToolUI,\n * } satisfies AssistantToolProps<{ city: string }, Weather>;\n *\n * function WeatherToolRegistration() {\n *   useAssistantTool(weatherTool);\n *   return null;\n * }\n * ```\n */\nexport const useAssistantTool = <\n  TArgs extends Record<string, unknown>,\n  TResult,\n>(\n  tool: AssistantToolProps<TArgs, TResult>,\n) => {\n  const aui = useAui();\n\n  const standalone = isStandaloneToolDisplay(tool);\n\n  useEffect(() => {\n    if (!tool.render) return undefined;\n    return aui.tools().setToolUI(tool.toolName, tool.render, { standalone });\n  }, [aui, tool.toolName, tool.render, standalone]);\n\n  useEffect(() => {\n    // `render` and `display` are client-only presentation concerns and never\n    // reach the model.\n    const { toolName, render, display, ...rest } = tool;\n    const context = {\n      tools: {\n        [toolName]: rest,\n      },\n    };\n    return aui.modelContext().register({\n      getModelContext: () => context,\n    });\n  }, [aui, tool]);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,MAAa,oBAIX,SACG;CACH,MAAM,MAAM,OAAO;CAEnB,MAAM,aAAa,wBAAwB,IAAI;CAE/C,gBAAgB;EACd,IAAI,CAAC,KAAK,QAAQ,OAAO,KAAA;EACzB,OAAO,IAAI,MAAM,EAAE,UAAU,KAAK,UAAU,KAAK,QAAQ,EAAE,WAAW,CAAC;CACzE,GAAG;EAAC;EAAK,KAAK;EAAU,KAAK;EAAQ;CAAU,CAAC;CAEhD,gBAAgB;EAGd,MAAM,EAAE,UAAU,QAAQ,SAAS,GAAG,SAAS;EAC/C,MAAM,UAAU,EACd,OAAO,GACJ,WAAW,KACd,EACF;EACA,OAAO,IAAI,aAAa,EAAE,SAAS,EACjC,uBAAuB,QACzB,CAAC;CACH,GAAG,CAAC,KAAK,IAAI,CAAC;AAChB"}
+{"version":3,"file":"useAssistantTool.js","names":[],"sources":["../../../src/react/model-context/useAssistantTool.ts"],"sourcesContent":["import { useEffect, useMemo } from \"react\";\nimport { useAui } from \"@assistant-ui/store\";\nimport type { ToolCallMessagePartComponent } from \"../types/MessagePartComponentTypes\";\nimport type { AssistantToolProps as CoreAssistantToolProps } from \"../..\";\nimport {\n  isStandaloneToolDisplay,\n  makeToolCallTextComponent,\n  type ToolCallText,\n} from \"./toolbox\";\n\n/**\n * Props used to register a tool from React.\n *\n * @deprecated Use a toolkit with `Tools({ toolkit })` and register it via\n * `useAui({ tools: Tools({ toolkit }) })` instead. See\n * https://assistant-ui.com/docs/migrations/toolkit-tools.\n */\nexport type AssistantToolProps<\n  TArgs extends Record<string, unknown>,\n  TResult,\n> = CoreAssistantToolProps<TArgs, TResult> & {\n  /** Component used to render calls to this tool in assistant messages. */\n  render?: ToolCallMessagePartComponent<TArgs, TResult> | undefined;\n  /** Lightweight text rendered while a tool call is running or complete. */\n  renderText?: ToolCallText<TArgs, TResult> | undefined;\n};\n\n/**\n * Registers a tool with the assistant model context while the component is\n * mounted.\n *\n * If `render` is provided, it is also installed as the renderer for matching\n * tool-call message parts. The registration is removed automatically when the\n * component unmounts or the tool definition changes.\n *\n * Pass a referentially stable tool object, such as one declared at module\n * scope or memoized with `useMemo`, to avoid re-registering on every render.\n *\n * @param tool - Tool definition and name to register.\n *\n * @deprecated Use a toolkit with `Tools({ toolkit })` and register it via\n * `useAui({ tools: Tools({ toolkit }) })` instead. See\n * https://assistant-ui.com/docs/migrations/toolkit-tools.\n *\n * @example\n * ```tsx\n * const weatherTool = {\n *   toolName: \"get_weather\",\n *   type: \"frontend\",\n *   description: \"Get the weather for a city.\",\n *   parameters: weatherSchema,\n *   execute: async ({ city }: { city: string }) => fetchWeather(city),\n *   render: WeatherToolUI,\n * } satisfies AssistantToolProps<{ city: string }, Weather>;\n *\n * function WeatherToolRegistration() {\n *   useAssistantTool(weatherTool);\n *   return null;\n * }\n * ```\n */\nexport const useAssistantTool = <\n  TArgs extends Record<string, unknown>,\n  TResult,\n>(\n  tool: AssistantToolProps<TArgs, TResult>,\n) => {\n  const aui = useAui();\n\n  const standalone = isStandaloneToolDisplay(tool);\n  const renderTextComponent = useMemo(\n    () =>\n      tool.renderText ? makeToolCallTextComponent(tool.renderText) : undefined,\n    [tool.renderText],\n  );\n  const render = tool.render ?? renderTextComponent;\n\n  useEffect(() => {\n    if (!render) return undefined;\n    return aui.tools().setToolUI(tool.toolName, render, { standalone });\n  }, [aui, tool.toolName, render, standalone]);\n\n  useEffect(() => {\n    // `render`, `renderText`, and `display` are client-only presentation\n    // concerns and never reach the model.\n    const { toolName, render, renderText, display, ...rest } = tool;\n    const context = {\n      tools: {\n        [toolName]: rest,\n      },\n    };\n    return aui.modelContext().register({\n      getModelContext: () => context,\n    });\n  }, [aui, tool]);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6DA,MAAa,oBAIX,SACG;CACH,MAAM,MAAM,OAAO;CAEnB,MAAM,aAAa,wBAAwB,IAAI;CAC/C,MAAM,sBAAsB,cAExB,KAAK,aAAa,0BAA0B,KAAK,UAAU,IAAI,KAAA,GACjE,CAAC,KAAK,UAAU,CAClB;CACA,MAAM,SAAS,KAAK,UAAU;CAE9B,gBAAgB;EACd,IAAI,CAAC,QAAQ,OAAO,KAAA;EACpB,OAAO,IAAI,MAAM,EAAE,UAAU,KAAK,UAAU,QAAQ,EAAE,WAAW,CAAC;CACpE,GAAG;EAAC;EAAK,KAAK;EAAU;EAAQ;CAAU,CAAC;CAE3C,gBAAgB;EAGd,MAAM,EAAE,UAAU,QAAQ,YAAY,SAAS,GAAG,SAAS;EAC3D,MAAM,UAAU,EACd,OAAO,GACJ,WAAW,KACd,EACF;EACA,OAAO,IAAI,aAAa,EAAE,SAAS,EACjC,uBAAuB,QACzB,CAAC;CACH,GAAG,CAAC,KAAK,IAAI,CAAC;AAChB"}

package/dist/react/model-context/useAssistantToolUI.d.ts

@@ -1,7 +1,13 @@
 import { ToolCallMessagePartComponent } from "../types/MessagePartComponentTypes.js";
 
 //#region src/react/model-context/useAssistantToolUI.d.ts
-/** Props used to register a renderer for tool-call message parts. */
+/**
+ * Props used to register a renderer for tool-call message parts.
+ *
+ * @deprecated Put `render`/`renderText` on the matching toolkit entry, or use
+ * `MessagePrimitive.Parts` inline tool render overrides for per-message UI.
+ * See https://assistant-ui.com/docs/migrations/toolkit-tools.
+ */
 type AssistantToolUIProps<TArgs, TResult> = {
   /** Name of the tool whose calls should use this renderer. */toolName: string; /** Component rendered for matching tool-call message parts. */
   render: ToolCallMessagePartComponent<TArgs, TResult>;
@@ -15,11 +21,14 @@ type AssistantToolUIProps<TArgs, TResult> = {
 /**
  * Registers a tool-call renderer while the component is mounted.
  *
- * This only affects rendering. Pair it with {@link useAssistantTool},
- * {@link Tools}, or a backend tool registry to expose the actual tool
- * definition to the model.
+ * This only affects rendering. Pair it with {@link Tools} or a backend tool
+ * registry to expose the actual tool definition to the model.
  *
  * @param tool - Tool renderer registration, or `null` to skip registration.
+ *
+ * @deprecated Put `render`/`renderText` on the matching toolkit entry, or use
+ * `MessagePrimitive.Parts` inline tool render overrides for per-message UI.
+ * See https://assistant-ui.com/docs/migrations/toolkit-tools.
  */
 declare const useAssistantToolUI: (tool: AssistantToolUIProps<any, any> | null) => void;
 //#endregion

package/dist/react/model-context/useAssistantToolUI.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAssistantToolUI.d.ts","names":[],"sources":["../../../src/react/model-context/useAssistantToolUI.ts"],"mappings":";;;;KAKY,oBAAA;EAAA,6DAEV,QAAA,UAF8B;EAI9B,MAAA,EAAQ,4BAAA,CAA6B,KAAA,EAAO,OAAA;EAAA;;;;;EAM5C,OAAA;AAAA;;;;;;;AAAO;AAYT;;cAAa,kBAAA,GACX,IAA2C,EAArC,oBAAoB"}
+{"version":3,"file":"useAssistantToolUI.d.ts","names":[],"sources":["../../../src/react/model-context/useAssistantToolUI.ts"],"mappings":";;;;;AAWA;;;;;KAAY,oBAAA;EAI0B,6DAFpC,QAAA,UAF+B;EAI/B,MAAA,EAAQ,4BAAA,CAA6B,KAAA,EAAO,OAAA;EAF5C;;;;;EAQA,OAAA;AAAA;AAAO;AAeT;;;;AAC6C;;;;;;;AAhBpC,cAeI,kBAAA,GACX,IAA2C,EAArC,oBAAoB"}

package/dist/react/model-context/useAssistantToolUI.js

@@ -4,11 +4,14 @@ import { useAui } from "@assistant-ui/store";
 /**
 * Registers a tool-call renderer while the component is mounted.
 *
-* This only affects rendering. Pair it with {@link useAssistantTool},
-* {@link Tools}, or a backend tool registry to expose the actual tool
-* definition to the model.
+* This only affects rendering. Pair it with {@link Tools} or a backend tool
+* registry to expose the actual tool definition to the model.
 *
 * @param tool - Tool renderer registration, or `null` to skip registration.
+*
+* @deprecated Put `render`/`renderText` on the matching toolkit entry, or use
+* `MessagePrimitive.Parts` inline tool render overrides for per-message UI.
+* See https://assistant-ui.com/docs/migrations/toolkit-tools.
 */
 const useAssistantToolUI = (tool) => {
 	const aui = useAui();

package/dist/react/model-context/useAssistantToolUI.js.map

@@ -1 +1 @@
-{"version":3,"file":"useAssistantToolUI.js","names":[],"sources":["../../../src/react/model-context/useAssistantToolUI.ts"],"sourcesContent":["import { useEffect } from \"react\";\nimport { useAui } from \"@assistant-ui/store\";\nimport type { ToolCallMessagePartComponent } from \"../types/MessagePartComponentTypes\";\n\n/** Props used to register a renderer for tool-call message parts. */\nexport type AssistantToolUIProps<TArgs, TResult> = {\n  /** Name of the tool whose calls should use this renderer. */\n  toolName: string;\n  /** Component rendered for matching tool-call message parts. */\n  render: ToolCallMessagePartComponent<TArgs, TResult>;\n  /**\n   * How the UI is presented relative to the chain-of-thought trace. Set\n   * `\"standalone\"` to surface it on its own (e.g. human-in-the-loop or\n   * generative UI for a backend/MCP tool). Defaults to `\"inline\"`.\n   */\n  display?: \"standalone\" | \"inline\";\n};\n\n/**\n * Registers a tool-call renderer while the component is mounted.\n *\n * This only affects rendering. Pair it with {@link useAssistantTool},\n * {@link Tools}, or a backend tool registry to expose the actual tool\n * definition to the model.\n *\n * @param tool - Tool renderer registration, or `null` to skip registration.\n */\nexport const useAssistantToolUI = (\n  tool: AssistantToolUIProps<any, any> | null,\n) => {\n  const aui = useAui();\n  const standalone = tool?.display === \"standalone\";\n  useEffect(() => {\n    if (!tool?.toolName || !tool?.render) return undefined;\n    return aui.tools().setToolUI(tool.toolName, tool.render, { standalone });\n  }, [aui, tool?.toolName, tool?.render, standalone]);\n};\n"],"mappings":";;;;;;;;;;;;AA2BA,MAAa,sBACX,SACG;CACH,MAAM,MAAM,OAAO;CACnB,MAAM,aAAa,MAAM,YAAY;CACrC,gBAAgB;EACd,IAAI,CAAC,MAAM,YAAY,CAAC,MAAM,QAAQ,OAAO,KAAA;EAC7C,OAAO,IAAI,MAAM,EAAE,UAAU,KAAK,UAAU,KAAK,QAAQ,EAAE,WAAW,CAAC;CACzE,GAAG;EAAC;EAAK,MAAM;EAAU,MAAM;EAAQ;CAAU,CAAC;AACpD"}
+{"version":3,"file":"useAssistantToolUI.js","names":[],"sources":["../../../src/react/model-context/useAssistantToolUI.ts"],"sourcesContent":["import { useEffect } from \"react\";\nimport { useAui } from \"@assistant-ui/store\";\nimport type { ToolCallMessagePartComponent } from \"../types/MessagePartComponentTypes\";\n\n/**\n * Props used to register a renderer for tool-call message parts.\n *\n * @deprecated Put `render`/`renderText` on the matching toolkit entry, or use\n * `MessagePrimitive.Parts` inline tool render overrides for per-message UI.\n * See https://assistant-ui.com/docs/migrations/toolkit-tools.\n */\nexport type AssistantToolUIProps<TArgs, TResult> = {\n  /** Name of the tool whose calls should use this renderer. */\n  toolName: string;\n  /** Component rendered for matching tool-call message parts. */\n  render: ToolCallMessagePartComponent<TArgs, TResult>;\n  /**\n   * How the UI is presented relative to the chain-of-thought trace. Set\n   * `\"standalone\"` to surface it on its own (e.g. human-in-the-loop or\n   * generative UI for a backend/MCP tool). Defaults to `\"inline\"`.\n   */\n  display?: \"standalone\" | \"inline\";\n};\n\n/**\n * Registers a tool-call renderer while the component is mounted.\n *\n * This only affects rendering. Pair it with {@link Tools} or a backend tool\n * registry to expose the actual tool definition to the model.\n *\n * @param tool - Tool renderer registration, or `null` to skip registration.\n *\n * @deprecated Put `render`/`renderText` on the matching toolkit entry, or use\n * `MessagePrimitive.Parts` inline tool render overrides for per-message UI.\n * See https://assistant-ui.com/docs/migrations/toolkit-tools.\n */\nexport const useAssistantToolUI = (\n  tool: AssistantToolUIProps<any, any> | null,\n) => {\n  const aui = useAui();\n  const standalone = tool?.display === \"standalone\";\n  useEffect(() => {\n    if (!tool?.toolName || !tool?.render) return undefined;\n    return aui.tools().setToolUI(tool.toolName, tool.render, { standalone });\n  }, [aui, tool?.toolName, tool?.render, standalone]);\n};\n"],"mappings":";;;;;;;;;;;;;;;AAoCA,MAAa,sBACX,SACG;CACH,MAAM,MAAM,OAAO;CACnB,MAAM,aAAa,MAAM,YAAY;CACrC,gBAAgB;EACd,IAAI,CAAC,MAAM,YAAY,CAAC,MAAM,QAAQ,OAAO,KAAA;EAC7C,OAAO,IAAI,MAAM,EAAE,UAAU,KAAK,UAAU,KAAK,QAAQ,EAAE,WAAW,CAAC;CACzE,GAAG;EAAC;EAAK,MAAM;EAAU,MAAM;EAAQ;CAAU,CAAC;AACpD"}

package/dist/react/model-context/useAuiToolOverrides.d.ts

@@ -0,0 +1,22 @@
+import { Tool } from "assistant-stream";
+
+//#region src/react/model-context/useAuiToolOverrides.d.ts
+type AuiToolOverride<TArgs extends Record<string, unknown> = Record<string, unknown>, TResult = unknown> = Partial<Tool<TArgs, TResult>>;
+type AuiToolOverrides = Record<string, AuiToolOverride<any, any>>;
+/**
+ * Overrides toolkit entries for the current assistant scope.
+ *
+ * This is intended for dynamic local-state tools whose model-facing contract is
+ * declared in a `"use generative"` toolkit file with `execute: stubTool()`, but
+ * whose actual executor must close over React state in the mounted component.
+ * Keep the override keys stable after mount; dynamic key addition/removal is not
+ * currently observed.
+ * Overrides are registered at priority 1000, above toolkit defaults. Only one
+ * mounted override provider may define a given tool name at a time.
+ *
+ * @deprecated Experimental, API may change.
+ */
+declare function useAuiToolOverrides(overrides: AuiToolOverrides): void;
+//#endregion
+export { useAuiToolOverrides };
+//# sourceMappingURL=useAuiToolOverrides.d.ts.map

package/dist/react/model-context/useAuiToolOverrides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAuiToolOverrides.d.ts","names":[],"sources":["../../../src/react/model-context/useAuiToolOverrides.ts"],"mappings":";;;KAIK,eAAA,eACW,MAAA,oBAA0B,MAAA,wCAEtC,OAAA,CAAQ,IAAA,CAAK,KAAA,EAAO,OAAA;AAAA,KAEnB,gBAAA,GAAmB,MAAM,SAAS,eAAA;AAPM;;;;;;;;;;;;;AAAA,iBAsB7B,mBAAA,CAAoB,SAA2B,EAAhB,gBAAgB"}

package/dist/react/model-context/useAuiToolOverrides.js

@@ -0,0 +1,31 @@
+import { useEffect, useRef } from "react";
+import { useAui } from "@assistant-ui/store";
+//#region src/react/model-context/useAuiToolOverrides.ts
+/**
+* Overrides toolkit entries for the current assistant scope.
+*
+* This is intended for dynamic local-state tools whose model-facing contract is
+* declared in a `"use generative"` toolkit file with `execute: stubTool()`, but
+* whose actual executor must close over React state in the mounted component.
+* Keep the override keys stable after mount; dynamic key addition/removal is not
+* currently observed.
+* Overrides are registered at priority 1000, above toolkit defaults. Only one
+* mounted override provider may define a given tool name at a time.
+*
+* @deprecated Experimental, API may change.
+*/
+function useAuiToolOverrides(overrides) {
+	const aui = useAui();
+	const overridesRef = useRef(overrides);
+	overridesRef.current = overrides;
+	useEffect(() => {
+		return aui.modelContext().register({ getModelContext: () => ({
+			priority: 1e3,
+			tools: overridesRef.current
+		}) });
+	}, [aui]);
+}
+//#endregion
+export { useAuiToolOverrides };
+
+//# sourceMappingURL=useAuiToolOverrides.js.map

package/dist/react/model-context/useAuiToolOverrides.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAuiToolOverrides.js","names":[],"sources":["../../../src/react/model-context/useAuiToolOverrides.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\nimport { useAui } from \"@assistant-ui/store\";\nimport type { Tool } from \"assistant-stream\";\n\ntype AuiToolOverride<\n  TArgs extends Record<string, unknown> = Record<string, unknown>,\n  TResult = unknown,\n> = Partial<Tool<TArgs, TResult>>;\n\ntype AuiToolOverrides = Record<string, AuiToolOverride<any, any>>;\n\n/**\n * Overrides toolkit entries for the current assistant scope.\n *\n * This is intended for dynamic local-state tools whose model-facing contract is\n * declared in a `\"use generative\"` toolkit file with `execute: stubTool()`, but\n * whose actual executor must close over React state in the mounted component.\n * Keep the override keys stable after mount; dynamic key addition/removal is not\n * currently observed.\n * Overrides are registered at priority 1000, above toolkit defaults. Only one\n * mounted override provider may define a given tool name at a time.\n *\n * @deprecated Experimental, API may change.\n */\nexport function useAuiToolOverrides(overrides: AuiToolOverrides): void {\n  const aui = useAui();\n  const overridesRef = useRef(overrides);\n  overridesRef.current = overrides;\n\n  useEffect(() => {\n    return aui.modelContext().register({\n      getModelContext: () => ({\n        priority: 1000,\n        tools: overridesRef.current as Record<string, Tool<any, any>>,\n      }),\n    });\n  }, [aui]);\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAwBA,SAAgB,oBAAoB,WAAmC;CACrE,MAAM,MAAM,OAAO;CACnB,MAAM,eAAe,OAAO,SAAS;CACrC,aAAa,UAAU;CAEvB,gBAAgB;EACd,OAAO,IAAI,aAAa,EAAE,SAAS,EACjC,wBAAwB;GACtB,UAAU;GACV,OAAO,aAAa;EACtB,GACF,CAAC;CACH,GAAG,CAAC,GAAG,CAAC;AACV"}

package/dist/react/primitives/part/PartMessages.d.ts

@@ -20,17 +20,19 @@ declare namespace PartPrimitiveMessages {
  *
  * @example
  * ```tsx
- * const SubAgentToolUI = makeAssistantToolUI({
- *   toolName: "invoke_sub_agent",
- *   render: () => (
- *     <PartPrimitive.Messages>
- *       {({ message }) => {
- *         if (message.role === "user") return <MyUserMessage />;
- *         return <MyAssistantMessage />;
- *       }}
- *     </PartPrimitive.Messages>
- *   ),
- * });
+ * const toolkit = {
+ *   invoke_sub_agent: {
+ *     type: "backend",
+ *     render: () => (
+ *       <PartPrimitive.Messages>
+ *         {({ message }) => {
+ *           if (message.role === "user") return <MyUserMessage />;
+ *           return <MyAssistantMessage />;
+ *         }}
+ *       </PartPrimitive.Messages>
+ *     ),
+ *   },
+ * } satisfies Toolkit;
  * ```
  */
 declare const PartPrimitiveMessagesImpl: FC<PartPrimitiveMessages.Props>;

package/dist/react/primitives/part/PartMessages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PartMessages.d.ts","names":[],"sources":["../../../../src/react/primitives/part/PartMessages.tsx"],"mappings":";;;;;kBASiB,qBAAA;EAAA,KACH,KAAA;IACV,UAAA,GAAa,uBAAA,CAAwB,KAAA,gBAFH;IAIlC,QAAA,IAAY,KAAA;MAAS,OAAA,EAAS,aAAA;IAAA,MAAoB,SAAA;EAAA;AAAA;;;;;;;;;;;;AAAS;AAoC/D;;;;;;;;AAAsE;AAyBtE;cAzBa,yBAAA,EAA2B,EAAE,CAAC,qBAAA,CAAsB,KAAA;AAAA,cAyBpD,qBAAA,kBAAqB,oBAAA,CAAA,qBAAA,CAAA,KAAA"}
+{"version":3,"file":"PartMessages.d.ts","names":[],"sources":["../../../../src/react/primitives/part/PartMessages.tsx"],"mappings":";;;;;kBASiB,qBAAA;EAAA,KACH,KAAA;IACV,UAAA,GAAa,uBAAA,CAAwB,KAAA,gBAFH;IAIlC,QAAA,IAAY,KAAA;MAAS,OAAA,EAAS,aAAA;IAAA,MAAoB,SAAA;EAAA;AAAA;;;;;;;;;;;;AAAS;AAsC/D;;;;;;;;AAAsE;AAyBtE;;;cAzBa,yBAAA,EAA2B,EAAE,CAAC,qBAAA,CAAsB,KAAA;AAAA,cAyBpD,qBAAA,kBAAqB,oBAAA,CAAA,qBAAA,CAAA,KAAA"}

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

@@ -20,17 +20,19 @@ const usePartMessages = () => {
 *
 * @example
 * ```tsx
-* const SubAgentToolUI = makeAssistantToolUI({
-*   toolName: "invoke_sub_agent",
-*   render: () => (
-*     <PartPrimitive.Messages>
-*       {({ message }) => {
-*         if (message.role === "user") return <MyUserMessage />;
-*         return <MyAssistantMessage />;
-*       }}
-*     </PartPrimitive.Messages>
-*   ),
-* });
+* const toolkit = {
+*   invoke_sub_agent: {
+*     type: "backend",
+*     render: () => (
+*       <PartPrimitive.Messages>
+*         {({ message }) => {
+*           if (message.role === "user") return <MyUserMessage />;
+*           return <MyAssistantMessage />;
+*         }}
+*       </PartPrimitive.Messages>
+*     ),
+*   },
+* } satisfies Toolkit;
 * ```
 */
 const PartPrimitiveMessagesImpl = ({ components, children }) => {