@assistant-ui/core 0.2.9 → 0.2.11

package/dist/react/model-context/define-mcp-toolkit.js

@@ -0,0 +1,14 @@
+//#region src/react/model-context/define-mcp-toolkit.ts
+/**
+* Defines MCP server tools as a spreadable toolkit fragment.
+*/
+function defineMcpToolkit(definition) {
+	return Object.fromEntries(Object.entries(definition).map(([name, server]) => [name, {
+		type: "mcp",
+		server
+	}]));
+}
+//#endregion
+export { defineMcpToolkit };
+
+//# sourceMappingURL=define-mcp-toolkit.js.map

package/dist/react/model-context/define-mcp-toolkit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-mcp-toolkit.js","names":[],"sources":["../../../src/react/model-context/define-mcp-toolkit.ts"],"sourcesContent":["import type { McpServerConfig } from \"assistant-stream\";\nimport type { Toolkit } from \"./toolbox\";\n\nexport type McpToolkitDefinition = Record<string, McpServerConfig>;\n\n/**\n * Defines MCP server tools as a spreadable toolkit fragment.\n */\nexport function defineMcpToolkit(definition: McpToolkitDefinition): Toolkit {\n  return Object.fromEntries(\n    Object.entries(definition).map(([name, server]) => [\n      name,\n      { type: \"mcp\", server },\n    ]),\n  ) as Toolkit;\n}\n"],"mappings":";;;;AAQA,SAAgB,iBAAiB,YAA2C;CAC1E,OAAO,OAAO,YACZ,OAAO,QAAQ,UAAU,CAAC,CAAC,KAAK,CAAC,MAAM,YAAY,CACjD,MACA;EAAE,MAAM;EAAO;CAAO,CACxB,CAAC,CACH;AACF"}

package/dist/react/model-context/define-toolkit.d.ts

@@ -1,20 +1,18 @@
-import { Toolkit, ToolkitDeclaration } from "./toolbox.js";
+import { Toolkit, ToolkitDefinition, ToolkitDefinitionEntryWithParameters } from "./toolbox.js";
 
 //#region src/react/model-context/define-toolkit.d.ts
 /**
- * Authoring helper for a `"use generative"` toolkit. Accepts the permissive
- * {@link ToolkitDeclaration} (a `backend` tool may carry its server `execute`)
- * and types the result as the canonical {@link Toolkit}.
+ * Toolkit authoring helper. Accepts the permissive {@link ToolkitDefinition}
+ * (a generative `backend` tool may carry its server `execute`) and types the
+ * result as the canonical {@link Toolkit}.
  *
- * It has **no runtime implementation**. A `"use generative"` compiler (e.g.
- * `@assistant-ui/next` or `@assistant-ui/vite`) strips the `defineToolkit(...)`
- * wrapper (and its import) per build, so a correctly compiled
- * `export default defineToolkit({...})` never calls this. If it *does* run, the
- * module was not compiled by a use-generative loader — e.g. `defineToolkit` used
- * outside a `"use generative"` file — which would ship a backend `execute` to the
- * client. So it throws instead of silently leaking.
+ * In a `"use generative"` file, the compiler strips the wrapper per build so it
+ * can split schemas, renderers, and executors across the client/server boundary.
+ * Outside generative compilation, it returns the toolkit unchanged and can be
+ * used for plain frontend/backend/human toolkit objects.
  */
-declare function defineToolkit(_declaration: ToolkitDeclaration): Toolkit;
+declare function defineToolkit<TArgsByName extends { [K in keyof TArgsByName]: Record<string, unknown> }, TResultByName extends { [K in keyof TArgsByName]: unknown } = { [K in keyof TArgsByName]: any }>(_definition: { [K in keyof TArgsByName]: ToolkitDefinitionEntryWithParameters<TArgsByName[K], TResultByName[K]> }): Toolkit & { [K in keyof TArgsByName]: ToolkitDefinitionEntryWithParameters<TArgsByName[K], TResultByName[K]> };
+declare function defineToolkit<const TDefinition extends ToolkitDefinition>(_definition: TDefinition): Toolkit & TDefinition;
 //#endregion
 export { defineToolkit };
 //# sourceMappingURL=define-toolkit.d.ts.map

package/dist/react/model-context/define-toolkit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"define-toolkit.d.ts","names":[],"sources":["../../../src/react/model-context/define-toolkit.ts"],"mappings":";;;;;AAeA;;;;;;;;AAAwE;;;iBAAxD,aAAA,CAAc,YAAA,EAAc,kBAAA,GAAqB,OAAO"}
+{"version":3,"file":"define-toolkit.d.ts","names":[],"sources":["../../../src/react/model-context/define-toolkit.ts"],"mappings":";;;;;AAgBA;;;;;;;;iBAAgB,aAAA,mCAEA,WAAA,GAAc,MAAA,yDAEQ,WAAA,6BACtB,WAAA,UAEd,WAAA,gBACY,WAAA,GAAc,oCAAA,CACxB,WAAA,CAAY,CAAA,GACZ,aAAA,CAAc,CAAA,OAEd,OAAA,iBACU,WAAA,GAAc,oCAAA,CACxB,WAAA,CAAY,CAAA,GACZ,aAAA,CAAc,CAAA;AAAA,iBAGF,aAAA,2BAAwC,iBAAA,EACtD,WAAA,EAAa,WAAA,GACZ,OAAA,GAAU,WAAA"}

package/dist/react/model-context/define-toolkit.js

@@ -1,19 +1,6 @@
 //#region src/react/model-context/define-toolkit.ts
-/**
-* Authoring helper for a `"use generative"` toolkit. Accepts the permissive
-* {@link ToolkitDeclaration} (a `backend` tool may carry its server `execute`)
-* and types the result as the canonical {@link Toolkit}.
-*
-* It has **no runtime implementation**. A `"use generative"` compiler (e.g.
-* `@assistant-ui/next` or `@assistant-ui/vite`) strips the `defineToolkit(...)`
-* wrapper (and its import) per build, so a correctly compiled
-* `export default defineToolkit({...})` never calls this. If it *does* run, the
-* module was not compiled by a use-generative loader — e.g. `defineToolkit` used
-* outside a `"use generative"` file — which would ship a backend `execute` to the
-* client. So it throws instead of silently leaking.
-*/
-function defineToolkit(_declaration) {
-	throw new Error("[assistant-ui] defineToolkit() has no runtime implementation — it is stripped at build time by the use-generative compiler. Reaching it means this module was not compiled (e.g. defineToolkit used outside a \"use generative\" file). Add the directive, or do not use defineToolkit here.");
+function defineToolkit(_definition) {
+	return _definition;
 }
 //#endregion
 export { defineToolkit };

package/dist/react/model-context/define-toolkit.js.map

@@ -1 +1 @@
-{"version":3,"file":"define-toolkit.js","names":[],"sources":["../../../src/react/model-context/define-toolkit.ts"],"sourcesContent":["import type { Toolkit, ToolkitDeclaration } from \"./toolbox\";\n\n/**\n * Authoring helper for a `\"use generative\"` toolkit. Accepts the permissive\n * {@link ToolkitDeclaration} (a `backend` tool may carry its server `execute`)\n * and types the result as the canonical {@link Toolkit}.\n *\n * It has **no runtime implementation**. A `\"use generative\"` compiler (e.g.\n * `@assistant-ui/next` or `@assistant-ui/vite`) strips the `defineToolkit(...)`\n * wrapper (and its import) per build, so a correctly compiled\n * `export default defineToolkit({...})` never calls this. If it *does* run, the\n * module was not compiled by a use-generative loader — e.g. `defineToolkit` used\n * outside a `\"use generative\"` file — which would ship a backend `execute` to the\n * client. So it throws instead of silently leaking.\n */\nexport function defineToolkit(_declaration: ToolkitDeclaration): Toolkit {\n  throw new Error(\n    \"[assistant-ui] defineToolkit() has no runtime implementation — it is \" +\n      \"stripped at build time by the use-generative compiler. Reaching it means \" +\n      'this module was not compiled (e.g. defineToolkit used outside a \"use ' +\n      'generative\" file). Add the directive, or do not use defineToolkit here.',\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;AAeA,SAAgB,cAAc,cAA2C;CACvE,MAAM,IAAI,MACR,8RAIF;AACF"}
+{"version":3,"file":"define-toolkit.js","names":[],"sources":["../../../src/react/model-context/define-toolkit.ts"],"sourcesContent":["import type {\n  Toolkit,\n  ToolkitDefinition,\n  ToolkitDefinitionEntryWithParameters,\n} from \"./toolbox\";\n\n/**\n * Toolkit authoring helper. Accepts the permissive {@link ToolkitDefinition}\n * (a generative `backend` tool may carry its server `execute`) and types the\n * result as the canonical {@link Toolkit}.\n *\n * In a `\"use generative\"` file, the compiler strips the wrapper per build so it\n * can split schemas, renderers, and executors across the client/server boundary.\n * Outside generative compilation, it returns the toolkit unchanged and can be\n * used for plain frontend/backend/human toolkit objects.\n */\nexport function defineToolkit<\n  TArgsByName extends {\n    [K in keyof TArgsByName]: Record<string, unknown>;\n  },\n  TResultByName extends { [K in keyof TArgsByName]: unknown } = {\n    [K in keyof TArgsByName]: any;\n  },\n>(_definition: {\n  [K in keyof TArgsByName]: ToolkitDefinitionEntryWithParameters<\n    TArgsByName[K],\n    TResultByName[K]\n  >;\n}): Toolkit & {\n  [K in keyof TArgsByName]: ToolkitDefinitionEntryWithParameters<\n    TArgsByName[K],\n    TResultByName[K]\n  >;\n};\nexport function defineToolkit<const TDefinition extends ToolkitDefinition>(\n  _definition: TDefinition,\n): Toolkit & TDefinition;\nexport function defineToolkit(_definition: ToolkitDefinition): Toolkit {\n  return _definition as Toolkit;\n}\n"],"mappings":";AAqCA,SAAgB,cAAc,aAAyC;CACrE,OAAO;AACT"}

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

@@ -0,0 +1,14 @@
+//#region src/react/model-context/external-tool.d.ts
+/**
+ * Marks a generative toolkit entry as an externally executed backend tool.
+ *
+ * Use this when another system (for example a backend route or LangGraph node)
+ * already defines and executes the tool, but assistant-ui should render its
+ * tool calls. The use-generative compiler omits `execute: externalTool()`
+ * entries from the server build and keeps a `type: "backend"` renderer on the
+ * client build.
+ */
+declare function externalTool(): never;
+//#endregion
+export { externalTool };
+//# sourceMappingURL=external-tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"external-tool.d.ts","names":[],"sources":["../../../src/react/model-context/external-tool.ts"],"mappings":";;AASA;;;;AAA4B;;;;iBAAZ,YAAA"}

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

@@ -0,0 +1,17 @@
+//#region src/react/model-context/external-tool.ts
+/**
+* Marks a generative toolkit entry as an externally executed backend tool.
+*
+* Use this when another system (for example a backend route or LangGraph node)
+* already defines and executes the tool, but assistant-ui should render its
+* tool calls. The use-generative compiler omits `execute: externalTool()`
+* entries from the server build and keeps a `type: "backend"` renderer on the
+* client build.
+*/
+function externalTool() {
+	throw new Error("[assistant-ui] externalTool() has no runtime implementation - it marks a tool that executes outside assistant-ui and is stripped at build time by the use-generative compiler. Make sure this module is compiled as \"use generative\".");
+}
+//#endregion
+export { externalTool };
+
+//# sourceMappingURL=external-tool.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"external-tool.js","names":[],"sources":["../../../src/react/model-context/external-tool.ts"],"sourcesContent":["/**\n * Marks a generative toolkit entry as an externally executed backend tool.\n *\n * Use this when another system (for example a backend route or LangGraph node)\n * already defines and executes the tool, but assistant-ui should render its\n * tool calls. The use-generative compiler omits `execute: externalTool()`\n * entries from the server build and keeps a `type: \"backend\"` renderer on the\n * client build.\n */\nexport function externalTool(): never {\n  throw new Error(\n    \"[assistant-ui] externalTool() has no runtime implementation - it marks a \" +\n      \"tool that executes outside assistant-ui and is stripped at build time \" +\n      'by the use-generative compiler. Make sure this module is compiled as \"use generative\".',\n  );\n}\n"],"mappings":";;;;;;;;;;AASA,SAAgB,eAAsB;CACpC,MAAM,IAAI,MACR,yOAGF;AACF"}

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

@@ -0,0 +1,27 @@
+//#region src/react/model-context/human-tool.d.ts
+/**
+ * Marks a tool as **human-in-the-loop**: the agent pauses and the UI (`render`)
+ * supplies the result instead of code. Use it as the tool's `execute`:
+ *
+ * ```tsx
+ * confirm: { execute: humanTool(), render: (props) => <Confirm {...props} /> }
+ * ```
+ *
+ * Unlike {@link defineToolkit}, it has **no runtime implementation**: a
+ * `"use generative"` compiler (e.g. `@assistant-ui/next` or `@assistant-ui/vite`)
+ * detects `execute: humanTool()`, drops it, and stamps the tool `type: "human"`.
+ * Reaching it at runtime means the module wasn't compiled (used outside a
+ * `"use generative"` file), so it throws.
+ */
+declare function humanTool(): never;
+/**
+ * @deprecated Use {@link humanTool}.
+ */
+declare const hitlTool: typeof humanTool;
+/**
+ * @deprecated Use {@link humanTool}.
+ */
+declare const hitl: typeof humanTool;
+//#endregion
+export { hitl, hitlTool, humanTool };
+//# sourceMappingURL=human-tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"human-tool.d.ts","names":[],"sources":["../../../src/react/model-context/human-tool.ts"],"mappings":";;AAcA;;;;AAAyB;AAYzB;;;;AAAiC;AAKjC;;;iBAjBgB,SAAA;AAiBa;;;AAAA,cALhB,QAAA,SAAQ,SAAY;;;;cAKpB,IAAA,SAAI,SAAY"}

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

@@ -0,0 +1,30 @@
+//#region src/react/model-context/human-tool.ts
+/**
+* Marks a tool as **human-in-the-loop**: the agent pauses and the UI (`render`)
+* supplies the result instead of code. Use it as the tool's `execute`:
+*
+* ```tsx
+* confirm: { execute: humanTool(), render: (props) => <Confirm {...props} /> }
+* ```
+*
+* Unlike {@link defineToolkit}, it has **no runtime implementation**: a
+* `"use generative"` compiler (e.g. `@assistant-ui/next` or `@assistant-ui/vite`)
+* detects `execute: humanTool()`, drops it, and stamps the tool `type: "human"`.
+* Reaching it at runtime means the module wasn't compiled (used outside a
+* `"use generative"` file), so it throws.
+*/
+function humanTool() {
+	throw new Error("[assistant-ui] humanTool() has no runtime implementation — it marks a human-in-the-loop tool and is stripped at build time by the use-generative compiler. Reaching it means this module was not compiled (e.g. humanTool() used outside a \"use generative\" file).");
+}
+/**
+* @deprecated Use {@link humanTool}.
+*/
+const hitlTool = humanTool;
+/**
+* @deprecated Use {@link humanTool}.
+*/
+const hitl = humanTool;
+//#endregion
+export { hitl, hitlTool, humanTool };
+
+//# sourceMappingURL=human-tool.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"human-tool.js","names":[],"sources":["../../../src/react/model-context/human-tool.ts"],"sourcesContent":["/**\n * Marks a tool as **human-in-the-loop**: the agent pauses and the UI (`render`)\n * supplies the result instead of code. Use it as the tool's `execute`:\n *\n * ```tsx\n * confirm: { execute: humanTool(), render: (props) => <Confirm {...props} /> }\n * ```\n *\n * Unlike {@link defineToolkit}, it has **no runtime implementation**: a\n * `\"use generative\"` compiler (e.g. `@assistant-ui/next` or `@assistant-ui/vite`)\n * detects `execute: humanTool()`, drops it, and stamps the tool `type: \"human\"`.\n * Reaching it at runtime means the module wasn't compiled (used outside a\n * `\"use generative\"` file), so it throws.\n */\nexport function humanTool(): never {\n  throw new Error(\n    \"[assistant-ui] humanTool() has no runtime implementation — it marks a \" +\n      \"human-in-the-loop tool and is stripped at build time by the \" +\n      \"use-generative compiler. Reaching it means this module was not compiled \" +\n      '(e.g. humanTool() used outside a \"use generative\" file).',\n  );\n}\n\n/**\n * @deprecated Use {@link humanTool}.\n */\nexport const hitlTool = humanTool;\n\n/**\n * @deprecated Use {@link humanTool}.\n */\nexport const hitl = humanTool;\n"],"mappings":";;;;;;;;;;;;;;;AAcA,SAAgB,YAAmB;CACjC,MAAM,IAAI,MACR,sQAIF;AACF;;;;AAKA,MAAa,WAAW;;;;AAKxB,MAAa,OAAO"}

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

@@ -7,6 +7,10 @@ import { FC } from "react";
  *
  * Rendering the component registers its tool for the lifetime of that render
  * subtree.
+ *
+ * @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 AssistantTool = FC & {
   /** Tool definition registered by this component. */unstable_tool: AssistantToolProps<any, any>;
@@ -18,6 +22,10 @@ type AssistantTool = FC & {
  * rather than calling {@link useAssistantTool} directly.
  *
  * @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.
  */
 declare const makeAssistantTool: <TArgs extends Record<string, unknown>, TResult>(tool: AssistantToolProps<TArgs, TResult>) => AssistantTool;
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"makeAssistantTool.d.ts","names":[],"sources":["../../../src/react/model-context/makeAssistantTool.ts"],"mappings":";;;;;;AASA;;;;KAAY,aAAA,GAAgB,EAAA;EAE1B,oDAAA,aAAA,EAAe,kBAAkB;AAAA;AAAA;AAWnC;;;;;;;AAXmC,cAWtB,iBAAA,iBACG,MAAA,4BAGd,IAAA,EAAM,kBAAA,CAAmB,KAAA,EAAO,OAAA,MAAQ,aAAA"}
+{"version":3,"file":"makeAssistantTool.d.ts","names":[],"sources":["../../../src/react/model-context/makeAssistantTool.ts"],"mappings":";;;;;;AAaA;;;;;;;;KAAY,aAAA,GAAgB,EAAA;EAiBf,oDAfX,aAAA,EAAe,kBAAkB;AAAA;;;;;;;;;;;;;cAetB,iBAAA,iBACG,MAAA,4BAGd,IAAA,EAAM,kBAAA,CAAmB,KAAA,EAAO,OAAA,MAAQ,aAAA"}

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

@@ -7,6 +7,10 @@ import { useAssistantTool } from "./useAssistantTool.js";
 * rather than calling {@link useAssistantTool} directly.
 *
 * @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.
 */
 const makeAssistantTool = (tool) => {
 	const Tool = () => {

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

@@ -1 +1 @@
-{"version":3,"file":"makeAssistantTool.js","names":[],"sources":["../../../src/react/model-context/makeAssistantTool.ts"],"sourcesContent":["import type { FC } from \"react\";\nimport { type AssistantToolProps, useAssistantTool } from \"./useAssistantTool\";\n\n/**\n * Component returned by {@link makeAssistantTool}.\n *\n * Rendering the component registers its tool for the lifetime of that render\n * subtree.\n */\nexport type AssistantTool = FC & {\n  /** Tool definition registered by this component. */\n  unstable_tool: AssistantToolProps<any, any>;\n};\n\n/**\n * Creates a React component that registers an assistant tool when rendered.\n *\n * Use this when exporting reusable tool modules that can be included in JSX\n * rather than calling {@link useAssistantTool} directly.\n *\n * @param tool - Tool definition and name to register.\n */\nexport const makeAssistantTool = <\n  TArgs extends Record<string, unknown>,\n  TResult,\n>(\n  tool: AssistantToolProps<TArgs, TResult>,\n) => {\n  const Tool: AssistantTool = () => {\n    useAssistantTool(tool);\n    return null;\n  };\n  Tool.unstable_tool = tool;\n  return Tool;\n};\n"],"mappings":";;;;;;;;;;AAsBA,MAAa,qBAIX,SACG;CACH,MAAM,aAA4B;EAChC,iBAAiB,IAAI;EACrB,OAAO;CACT;CACA,KAAK,gBAAgB;CACrB,OAAO;AACT"}
+{"version":3,"file":"makeAssistantTool.js","names":[],"sources":["../../../src/react/model-context/makeAssistantTool.ts"],"sourcesContent":["import type { FC } from \"react\";\nimport { type AssistantToolProps, useAssistantTool } from \"./useAssistantTool\";\n\n/**\n * Component returned by {@link makeAssistantTool}.\n *\n * Rendering the component registers its tool for the lifetime of that render\n * subtree.\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 AssistantTool = FC & {\n  /** Tool definition registered by this component. */\n  unstable_tool: AssistantToolProps<any, any>;\n};\n\n/**\n * Creates a React component that registers an assistant tool when rendered.\n *\n * Use this when exporting reusable tool modules that can be included in JSX\n * rather than calling {@link useAssistantTool} directly.\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 */\nexport const makeAssistantTool = <\n  TArgs extends Record<string, unknown>,\n  TResult,\n>(\n  tool: AssistantToolProps<TArgs, TResult>,\n) => {\n  const Tool: AssistantTool = () => {\n    useAssistantTool(tool);\n    return null;\n  };\n  Tool.unstable_tool = tool;\n  return Tool;\n};\n"],"mappings":";;;;;;;;;;;;;;AA8BA,MAAa,qBAIX,SACG;CACH,MAAM,aAA4B;EAChC,iBAAiB,IAAI;EACrB,OAAO;CACT;CACA,KAAK,gBAAgB;CACrB,OAAO;AACT"}

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

@@ -7,6 +7,10 @@ import { FC } from "react";
  *
  * Rendering the component registers a renderer for matching 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 AssistantToolUI = FC & {
   /** Tool renderer registered by this component. */unstable_tool: AssistantToolUIProps<any, any>;
@@ -18,6 +22,10 @@ type AssistantToolUI = FC & {
  * are registered elsewhere.
  *
  * @param tool - Tool renderer 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 makeAssistantToolUI: <TArgs, TResult>(tool: AssistantToolUIProps<TArgs, TResult>) => AssistantToolUI;
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"makeAssistantToolUI.d.ts","names":[],"sources":["../../../src/react/model-context/makeAssistantToolUI.ts"],"mappings":";;;;;;AAYA;;;;KAAY,eAAA,GAAkB,EAAA;EAE5B,kDAAA,aAAA,EAAe,oBAAoB;AAAA;AAAA;AAWrC;;;;;;;AAXqC,cAWxB,mBAAA,mBACX,IAAA,EAAM,oBAAA,CAAqB,KAAA,EAAO,OAAA,MAAQ,eAAA"}
+{"version":3,"file":"makeAssistantToolUI.d.ts","names":[],"sources":["../../../src/react/model-context/makeAssistantToolUI.ts"],"mappings":";;;;;;AAgBA;;;;;;;;KAAY,eAAA,GAAkB,EAAA;EAiBjB,kDAfX,aAAA,EAAe,oBAAoB;AAAA;;;;;;;;;;;;;cAexB,mBAAA,mBACX,IAAA,EAAM,oBAAA,CAAqB,KAAA,EAAO,OAAA,MAAQ,eAAA"}

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

@@ -7,6 +7,10 @@ import { useAssistantToolUI } from "./useAssistantToolUI.js";
 * are registered elsewhere.
 *
 * @param tool - Tool renderer 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 makeAssistantToolUI = (tool) => {
 	const ToolUI = () => {

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.
  *
@@ -36,7 +63,7 @@ type ToolDefinition<TArgs extends Record<string, unknown>, TResult> = WithRender
  *
  * @example
  * ```tsx
- * const toolkit = {
+ * const toolkit = defineToolkit({
  *   get_weather: {
  *     type: "frontend",
  *     description: "Get the weather for a city.",
@@ -44,7 +71,7 @@ type ToolDefinition<TArgs extends Record<string, unknown>, TResult> = WithRender
  *     execute: async ({ city }: { city: string }) => fetchWeather(city),
  *     render: WeatherToolUI,
  *   },
- * } satisfies Toolkit;
+ * });
  * ```
  */
 type Toolkit = Record<string, ToolDefinition<any, any>>;
@@ -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: humanTool()` → 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 = defineToolkit({\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 * });\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: humanTool()` → 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/useAssistantContext.js

@@ -1,4 +1,4 @@
-import { useEffect, useRef } from "react";
+import { useEffect, useRef } from "@assistant-ui/tap/react-shim";
 import { useAui } from "@assistant-ui/store";
 //#region src/react/model-context/useAssistantContext.ts
 const useAssistantContext = (config) => {