@assistant-ui/core 0.3.16 → 0.3.18

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

@@ -1 +1 @@
-{"version":3,"file":"makeAssistantTool.js","names":["FC","AssistantToolProps","useAssistantTool","AssistantTool","unstable_tool","makeAssistantTool","Record","tool","TArgs","TResult","Tool"],"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,MAAaK,qBAIXE,SACG;CACH,MAAMG,aAAsB;EAC1BR,iBAAiBK,IAAI;EAAC,OACf;CAAI;CAEbG,KAAKN,gBAAgBG;CACrB,OAAOG;AACT"}
+{"version":3,"file":"makeAssistantTool.js","names":["FC","AssistantToolProps","useAssistantTool","AssistantTool","unstable_tool","makeAssistantTool","Record","tool","TArgs","TResult","Tool"],"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 * `AuiConfig({ tools: Tools({ toolkit }) })` on the provider's `config` prop 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 * `AuiConfig({ tools: Tools({ toolkit }) })` on the provider's `config` prop 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,MAAaK,qBAIXE,SACG;CACH,MAAMG,aAAsB;EAC1BR,iBAAiBK,IAAI;EAAC,OACf;CAAI;CAEbG,KAAKN,gBAAgBG;CACrB,OAAOG;AACT"}

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

@@ -1,7 +1,9 @@
+import { ToolCallText as ToolCallText$1 } from "../../model-context/tool-call-text.js";
 import { ToolCallMessagePartComponent, ToolCallMessagePartProps } from "../types/MessagePartComponentTypes.js";
 import { Tool, ToolCallReader, ToolDeclaration, ToolModelOutputFunction } from "assistant-stream";
 import { ReactNode } from "react";
 //#region src/react/model-context/toolbox.d.ts
+type ToolCallText<TArgs extends Record<string, unknown>, TResult> = ToolCallText$1<TArgs, TResult, ReactNode>;
 /**
  * Resolves whether a tool's UI should be presented standalone (outside the
  * chain-of-thought grouping), applying the type-based defaults.
@@ -31,20 +33,6 @@ type ToolParameters<TArgs extends Record<string, unknown>> = ToolDeclaration<TAr
 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>) => ((part: ToolCallMessagePartProps<TArgs, TResult>) => ReactNode);
 /**
  * Tool definition accepted by the React tool registry.

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":";;;;;;;;;;;;;cAqBa,0BACX,MAAM,KAAK;KAMR,WAAW,GAAG,cAAc,yBAAyB,WAAW;EACnE;IAEE,KACG;EAAY;;EAEH,QAAQ,6BAA6B,OAAO;;EAE5C,SAAS,6BAA6B,OAAO;EAC7C,YAAY,aAAa,OAAO;;EAEpC,QAAQ,6BAA6B,OAAO;KACpD;EACE,SAAS,6BAA6B,OAAO;EAC7C,aAAa,aAAa,OAAO;;KAGlC,eAAe,cAAc,2BAChC,gBAAgB;KAGb,qBAAqB,WACxB,YAAY;KAGT,YAAY,cAAc,yBAAyB,YACtD,MAAM,OACN,SAAS,uBACN,UAAU,QAAQ;KAElB,eAAe,cAAc,yBAAyB,YACzD,QAAQ,eAAe,OAAO,UAC9B,SAAS;KAGN,oBAAoB,cAAc,2BACnC,cACE;EAAW,MAAM;MAAY;KAE9B,qBAAqB,cAAc,yBAAyB,WAC7D,cACE;EAAW,MAAM;EAAO,QAAQ;MAA0B;KAEpD,aAAa,cAAc,yBAAyB;EAE1D,SAAS,oBAAoB;EAC7B,WAAW,qBAAqB,OAAO;;EAGvC,UAAU,oBAAoB;EAC9B,UAAU,qBAAqB,OAAO;;cAqB/B,4BACX,cAAc,yBACd,SAEA,MAAM,aAAa,OAAO,eACvB,MAAM,yBAAyB,OAAO,aAAa;;;;;;;;;KAc5C,eACV,cAAc,0BAA0B,yBACxC,qBACE,WAAW,KAAK,OAAO,UAAU,OAAO;;;;;;;;;;;;;;;;;;;KAoBhC,UAAU,eAAe;;;;;;;;;;KAWhC,sBACH,GACA,mBAAmB,GACnB,4BACoB,EAAE,QAGpB,QAAQ,EAAE,qCACL,KAAK,0BACL,KAAK,QAAQ,2BACf,KAAK,OAAO;KAEd,iCACH;EAAY;GACZ,cAAc,yBACd,WACE,KACF;EAOA;6BAC2B,IACvB,sBAAsB,cAAc,YAAY,QAAQ,QAAQ,iDAErC,IAC3B,sBACE,oBAEA,wBAAwB,QAAQ,QAAQ,QAAQ,yEAGA,IAClD,sBACE,4CAGE,eACA,SAAS,uBACN,QAAQ,WAAW,QAAQ,QAAQ,mBAG9C,sBAAsB,iBAAiB,eAAe;KAInD,uBACH,cAAc,yBACd,WACE,WACF,gBAAgB,OAAO,wBAAuB,KAC1C;EAAY;IACV,iCAAiC,GAAG,OAAO,0BAGjD,OACA;;;;;;;;;;KAYU,uBACV,cAAc,0BAA0B,yBACxC,qBACE,uBAAuB,OAAO,WAAW;KAEjC,qCACV,cAAc,0BAA0B,yBACxC,qBACE,uBAAuB,OAAO;EAChC,YAAY,YAAY,eAAe;;;;;;;KAQ7B,kBACV,uBACG,WAAW,cAAc,6BACxB,qBACJ,yBAAyB,WAAW,8BACjC,WAAW,2BAGb,WAAW,cAAc,uBACxB,YAAY,IACZ,cAAc;;KAKN;;EAEV,SAAS"}
+{"version":3,"file":"toolbox.d.ts","names":[],"sources":["../../../src/react/model-context/toolbox.ts"],"mappings":";;;;;KAgBY,aACV,cAAc,yBACd,WACE,eAAoB,OAAO,SAAS;;;;;;;;;;cAW3B,0BACX,MAAM,KAAK;KAMR,WAAW,GAAG,cAAc,yBAAyB,WAAW;EACnE;IAEE,KACG;EAAY;;EAEH,QAAQ,6BAA6B,OAAO;;EAE5C,SAAS,6BAA6B,OAAO;EAC7C,YAAY,aAAa,OAAO;;EAEpC,QAAQ,6BAA6B,OAAO;KACpD;EACE,SAAS,6BAA6B,OAAO;EAC7C,aAAa,aAAa,OAAO;;KAGlC,eAAe,cAAc,2BAChC,gBAAgB;KAGb,qBAAqB,WACxB,YAAY;KAGT,YAAY,cAAc,yBAAyB,YACtD,MAAM,OACN,SAAS,uBACN,UAAU,QAAQ;KAElB,eAAe,cAAc,yBAAyB,YACzD,QAAQ,eAAe,OAAO,UAC9B,SAAS;cAGE,4BACX,cAAc,yBACd,SAEA,MAAM,aAAa,OAAO,eACvB,MAAM,yBAAyB,OAAO,aAAa;;;;;;;;;KAc5C,eACV,cAAc,0BAA0B,yBACxC,qBACE,WAAW,KAAK,OAAO,UAAU,OAAO;;;;;;;;;;;;;;;;;;;KAoBhC,UAAU,eAAe;;;;;;;;;;KAWhC,sBACH,GACA,mBAAmB,GACnB,4BACoB,EAAE,QAGpB,QAAQ,EAAE,qCACL,KAAK,0BACL,KAAK,QAAQ,2BACf,KAAK,OAAO;KAEd,iCACH;EAAY;GACZ,cAAc,yBACd,WACE,KACF;EAOA;6BAC2B,IACvB,sBAAsB,cAAc,YAAY,QAAQ,QAAQ,iDAErC,IAC3B,sBACE,oBAEA,wBAAwB,QAAQ,QAAQ,QAAQ,yEAGA,IAClD,sBACE,4CAGE,eACA,SAAS,uBACN,QAAQ,WAAW,QAAQ,QAAQ,mBAG9C,sBAAsB,iBAAiB,eAAe;KAInD,uBACH,cAAc,yBACd,WACE,WACF,gBAAgB,OAAO,wBAAuB,KAC1C;EAAY;IACV,iCAAiC,GAAG,OAAO,0BAGjD,OACA;;;;;;;;;;KAYU,uBACV,cAAc,0BAA0B,yBACxC,qBACE,uBAAuB,OAAO,WAAW;KAEjC,qCACV,cAAc,0BAA0B,yBACxC,qBACE,uBAAuB,OAAO;EAChC,YAAY,YAAY,eAAe;;;;;;;KAQ7B,kBACV,uBACG,WAAW,cAAc,6BACxB,qBACJ,yBAAyB,WAAW,8BACjC,WAAW,2BAGb,WAAW,cAAc,uBACxB,YAAY,IACZ,cAAc;;KAKN;;EAEV,SAAS"}

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

@@ -1,3 +1,4 @@
+import { resolveToolCallText } from "../../model-context/tool-call-text.js";
 //#region src/react/model-context/toolbox.ts
 /**
 * Resolves whether a tool's UI should be presented standalone (outside the
@@ -12,19 +13,6 @@ 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);

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

@@ -1 +1 @@
-{"version":3,"file":"toolbox.js","names":["Tool","ToolCallReader","ToolDeclaration","ToolModelOutputFunction","ReactNode","ToolCallMessagePartComponent","ToolCallMessagePartProps","isStandaloneToolDisplay","tool","Pick","display","undefined","type","WithRender","Record","T","render","TArgs","TResult","renderText","ToolCallText","ToolParameters","ToolExecuteContext","Parameters","NonNullable","ToolExecute","args","context","Promise","ToolStreamCall","reader","ToolCallRunningText","options","ToolCallCompleteText","result","running","complete","resolveToolCallText","text","part","isRunning","status","value","makeToolCallTextComponent","ToolCallTextComponent","ToolDefinition","Toolkit","OverrideOptionalField","TKey","Exclude","TValue","OverrideToolDeclarationCallbacks","streamCall","Omit","NoInfer","ToolkitDefinitionInput","ToolkitDefinitionEntry","ToolkitDefinitionEntryWithParameters","parameters","ToolkitDefinition","TArgsByName","K","TResultByName","ToolsConfig","toolkit"],"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): ((part: ToolCallMessagePartProps<TArgs, TResult>) => ReactNode) => {\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<T, \"streamCall\", ToolStreamCall<TArgs, unknown>>;\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,MAAaO,2BACXC,SACY;CACZ,IAAIA,KAAKE,YAAYC,KAAAA,GAAW,OAAOH,KAAKE,YAAY;CACxD,OAAOF,KAAKI,SAAS;AACvB;AAuDA,MAAMyB,uBACJC,MACAC,SACc;CAId,IAAI,EAFFA,KAAKE,QAAQ7B,SAAS,aAAa2B,KAAKE,QAAQ7B,SAAS,oBAE3C;EACd,MAAM8B,QAAQJ,KAAKF;EACnB,IAAI,OAAOM,UAAU,YAAY,OAAOA,SAAS;EACjD,OAAOA,MAAM;GAAEhB,MAAMa,KAAKb;GAAMQ,QAAQK,KAAKL;EAAO,CAAC;CACvD;CAEA,MAAMQ,QAAQJ,KAAKH;CACnB,IAAI,OAAOO,UAAU,YAAY,OAAOA,SAAS;CACjD,OAAOA,MAAM,EAAEhB,MAAMa,KAAKb,KAAK,CAAC;AAClC;AAEA,MAAaiB,6BAIXL,SACoE;CACpE,OAAO,SAASM,sBAAsBL,MAAM;EAC1C,OAAOF,oBAAoBC,MAAMC,IAAI;CACvC;AACF"}
+{"version":3,"file":"toolbox.js","names":["Tool","ToolCallReader","ToolDeclaration","ToolModelOutputFunction","ReactNode","ToolCallMessagePartComponent","ToolCallMessagePartProps","resolveToolCallText","ToolCallText","NeutralToolCallText","Record","TArgs","TResult","isStandaloneToolDisplay","tool","Pick","display","undefined","type","WithRender","T","render","renderText","ToolParameters","ToolExecuteContext","Parameters","NonNullable","ToolExecute","args","context","Promise","ToolStreamCall","reader","makeToolCallTextComponent","text","part","ToolCallTextComponent","ToolDefinition","Toolkit","OverrideOptionalField","TKey","Exclude","TValue","OverrideToolDeclarationCallbacks","streamCall","Omit","NoInfer","ToolkitDefinitionInput","ToolkitDefinitionEntry","ToolkitDefinitionEntryWithParameters","parameters","ToolkitDefinition","TArgsByName","K","TResultByName","ToolsConfig","toolkit"],"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\";\nimport {\n  resolveToolCallText,\n  type ToolCallText as NeutralToolCallText,\n} from \"../../model-context/tool-call-text\";\n\nexport type ToolCallText<\n  TArgs extends Record<string, unknown>,\n  TResult,\n> = NeutralToolCallText<TArgs, TResult, ReactNode>;\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\nexport const makeToolCallTextComponent = <\n  TArgs extends Record<string, unknown>,\n  TResult,\n>(\n  text: ToolCallText<TArgs, TResult>,\n): ((part: ToolCallMessagePartProps<TArgs, TResult>) => ReactNode) => {\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<T, \"streamCall\", ToolStreamCall<TArgs, unknown>>;\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":";;;;;;;;;;;AA8BA,MAAaa,2BACXC,SACY;CACZ,IAAIA,KAAKE,YAAYC,KAAAA,GAAW,OAAOH,KAAKE,YAAY;CACxD,OAAOF,KAAKI,SAAS;AACvB;AAqCA,MAAae,6BAIXC,SACoE;CACpE,OAAO,SAASE,sBAAsBD,MAAM;EAC1C,OAAO5B,oBAAoB2B,MAAMC,IAAI;CACvC;AACF"}

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

@@ -1,15 +1,45 @@
-import { useEffect, useRef } from "@assistant-ui/tap/react-shim";
+import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { useEffect, useInsertionEffect, useRef } from "@assistant-ui/tap/react-shim";
 import { useAui } from "@assistant-ui/store";
 //#region src/react/model-context/useAssistantContext.ts
 const useAssistantContext = (config) => {
-	const { getContext, disabled = false } = config;
+	const $ = c(7);
+	const { getContext, disabled: t0 } = config;
+	const disabled = t0 === void 0 ? false : t0;
 	const aui = useAui();
 	const getContextRef = useRef(getContext);
-	getContextRef.current = getContext;
-	useEffect(() => {
-		if (disabled) return;
-		return aui.modelContext.register({ getModelContext: () => ({ system: getContextRef.current() }) });
-	}, [aui, disabled]);
+	let t1;
+	let t2;
+	if ($[0] !== getContext) {
+		t1 = () => {
+			getContextRef.current = getContext;
+		};
+		t2 = [getContext];
+		$[0] = getContext;
+		$[1] = t1;
+		$[2] = t2;
+	} else {
+		t1 = $[1];
+		t2 = $[2];
+	}
+	useInsertionEffect(t1, t2);
+	let t3;
+	let t4;
+	if ($[3] !== aui || $[4] !== disabled) {
+		t3 = () => {
+			if (disabled) return;
+			return aui.modelContext.register({ getModelContext: () => ({ system: getContextRef.current() }) });
+		};
+		t4 = [aui, disabled];
+		$[3] = aui;
+		$[4] = disabled;
+		$[5] = t3;
+		$[6] = t4;
+	} else {
+		t3 = $[5];
+		t4 = $[6];
+	}
+	useEffect(t3, t4);
 };
 //#endregion
 export { useAssistantContext };

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

@@ -1 +1 @@
-{"version":3,"file":"useAssistantContext.js","names":["useEffect","useRef","useAui","AssistantContextConfig","useAssistantContext","config","getContext","disabled","aui","getContextRef","current","modelContext","register","getModelContext","system"],"sources":["../../../src/react/model-context/useAssistantContext.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\nimport { useAui } from \"@assistant-ui/store\";\nimport type { AssistantContextConfig } from \"../..\";\n\nexport type { AssistantContextConfig };\n\nexport const useAssistantContext = (config: AssistantContextConfig) => {\n  const { getContext, disabled = false } = config;\n  const aui = useAui();\n  const getContextRef = useRef(getContext);\n  getContextRef.current = getContext;\n\n  useEffect(() => {\n    if (disabled) return;\n\n    return aui.modelContext.register({\n      getModelContext: () => ({\n        system: getContextRef.current(),\n      }),\n    });\n  }, [aui, disabled]);\n};\n"],"mappings":";;;AAMA,MAAaI,uBAAuBC,WAAmC;CACrE,MAAM,EAAEC,YAAYC,WAAW,UAAUF;CACzC,MAAMG,MAAMN,OAAO;CACnB,MAAMO,gBAAgBR,OAAOK,UAAU;CACvCG,cAAcC,UAAUJ;CAExBN,gBAAgB;EACd,IAAIO,UAAU;EAEd,OAAOC,IAAIG,aAAaC,SAAS,EAC/BC,wBAAwB,EACtBC,QAAQL,cAAcC,QAAQ,EAChC,GACF,CAAC;CACH,GAAG,CAACF,KAAKD,QAAQ,CAAC;AACpB"}
+{"version":3,"file":"useAssistantContext.js","names":["useEffect","useInsertionEffect","useRef","useAui","AssistantContextConfig","useAssistantContext","config","$","_c","getContext","disabled","t0","undefined","aui","getContextRef","t1","t2","current","t3","t4","modelContext","register","getModelContext","system"],"sources":["../../../src/react/model-context/useAssistantContext.ts"],"sourcesContent":["import { useEffect, useInsertionEffect, useRef } from \"react\";\nimport { useAui } from \"@assistant-ui/store\";\nimport type { AssistantContextConfig } from \"../..\";\n\nexport type { AssistantContextConfig };\n\nexport const useAssistantContext = (config: AssistantContextConfig) => {\n  const { getContext, disabled = false } = config;\n  const aui = useAui();\n  const getContextRef = useRef(getContext);\n  useInsertionEffect(() => {\n    getContextRef.current = getContext;\n  }, [getContext]);\n\n  useEffect(() => {\n    if (disabled) return;\n\n    return aui.modelContext.register({\n      getModelContext: () => ({\n        system: getContextRef.current(),\n      }),\n    });\n  }, [aui, disabled]);\n};\n"],"mappings":";;;;AAMA,MAAaK,uBAAsBC,WAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CACjC,MAAA,EAAAC,YAAAC,UAAAC,OAAyCL;CAArB,MAAAI,WAAAC,OAAAC,KAAAA,IAAA,QAAAD;CACpB,MAAAE,MAAYV,OAAO;CACnB,MAAAW,gBAAsBZ,OAAOO,UAAU;CAAE,IAAAM;CAAA,IAAAC;CAAA,IAAAT,EAAA,OAAAE,YAAA;EACtBM,WAAA;GACjBD,cAAaG,UAAWR;EAAH;EACpBO,KAAA,CAACP,UAAU;EAACF,EAAA,KAAAE;EAAAF,EAAA,KAAAQ;EAAAR,EAAA,KAAAS;CAAA,OAAA;EAAAD,KAAAR,EAAA;EAAAS,KAAAT,EAAA;CAAA;CAFfN,mBAAmBc,IAEhBC,EAAY;CAAC,IAAAE;CAAA,IAAAC;CAAA,IAAAZ,EAAA,OAAAM,OAAAN,EAAA,OAAAG,UAAA;EAENQ,WAAA;GACR,IAAIR,UAAQ;GAAS,OAEdG,IAAGO,aAAaC,SAAU,EAAAC,wBACP,EAAAC,QACdT,cAAaG,QAAS,EAChC,GACF,CAAC;EAAC;EACDE,KAAA,CAACN,KAAKH,QAAQ;EAACH,EAAA,KAAAM;EAAAN,EAAA,KAAAG;EAAAH,EAAA,KAAAW;EAAAX,EAAA,KAAAY;CAAA,OAAA;EAAAD,KAAAX,EAAA;EAAAY,KAAAZ,EAAA;CAAA;CARlBP,UAAUkB,IAQPC,EAAe;AAAC"}

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

@@ -7,7 +7,7 @@ import "../../index.js";
  * 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
+ * `AuiConfig({ tools: Tools({ toolkit }) })` on the provider's `config` prop instead. See
  * https://assistant-ui.com/docs/migrations/toolkit-tools.
  */
 type AssistantToolProps<TArgs extends Record<string, unknown>, TResult> = AssistantToolProps$1<TArgs, TResult> & {
@@ -30,7 +30,7 @@ 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
+ * `AuiConfig({ tools: Tools({ toolkit }) })` on the provider's `config` prop instead. See
  * https://assistant-ui.com/docs/migrations/toolkit-tools.
  *
  * @example

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

@@ -17,7 +17,7 @@ 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
+* `AuiConfig({ tools: Tools({ toolkit }) })` on the provider's `config` prop instead. See
 * https://assistant-ui.com/docs/migrations/toolkit-tools.
 *
 * @example

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

@@ -1 +1 @@
-{"version":3,"file":"useAssistantTool.js","names":["useEffect","useMemo","useAui","ToolCallMessagePartComponent","AssistantToolProps","CoreAssistantToolProps","isStandaloneToolDisplay","makeToolCallTextComponent","ToolCallText","Record","TArgs","TResult","render","renderText","useAssistantTool","tool","$","_c","aui","t0","standalone","t1","undefined","renderTextComponent","t2","tools","toolName","setToolUI","t3","t4","modelContext","render_0","display","rest","context","register","getModelContext","t5"],"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,MAAac,oBAAmBC,SAAA;CAAA,MAAAC,IAAAC,EAAA,EAAA;CAM9B,MAAAC,MAAYhB,OAAO;CAAE,IAAAiB;CAAA,IAAAH,EAAA,OAAAD,MAAA;EAEFI,KAAAb,wBAAwBS,IAAI;EAACC,EAAA,KAAAD;EAAAC,EAAA,KAAAG;CAAA,OAAAA,KAAAH,EAAA;CAAhD,MAAAI,aAAmBD;CAA8B,IAAAE;CAAA,IAAAL,EAAA,OAAAD,KAAAF,YAAA;EAG7CQ,KAAAN,KAAIF,aAAcN,0BAA0BQ,KAAIF,UAAuB,IAAvES,KAAAA;EAAwEN,EAAA,KAAAD,KAAAF;EAAAG,EAAA,KAAAK;CAAA,OAAAA,KAAAL,EAAA;CAF5E,MAAAO,sBAEIF;CAGJ,MAAAT,SAAeG,KAAIH,UAAJW;CAAmC,IAAAC;CAAA,IAAAR,EAAA,OAAAE,IAAAO,SAAAT,EAAA,OAAAJ,UAAAI,EAAA,OAAAI,cAAAJ,EAAA,OAAAD,KAAAW,UAAA;EAExCF,WAAA;GACR,IAAI,CAACZ,QAAM;GAAmB,OACvBM,IAAGO,MAAME,UAAWZ,KAAIW,UAAWd,QAAQ,EAAAQ,WAAa,CAAC;EAAC;EAClEJ,EAAA,KAAAE,IAAAO;EAAAT,EAAA,KAAAJ;EAAAI,EAAA,KAAAI;EAAAJ,EAAA,KAAAD,KAAAW;EAAAV,EAAA,KAAAQ;CAAA,OAAAA,KAAAR,EAAA;CAAA,IAAAY;CAAA,IAAAZ,EAAA,OAAAE,OAAAF,EAAA,QAAAJ,UAAAI,EAAA,QAAAI,cAAAJ,EAAA,QAAAD,KAAAW,UAAA;EAAEE,KAAA;GAACV;GAAKH,KAAIW;GAAWd;GAAQQ;EAAU;EAACJ,EAAA,KAAAE;EAAAF,EAAA,MAAAJ;EAAAI,EAAA,MAAAI;EAAAJ,EAAA,MAAAD,KAAAW;EAAAV,EAAA,MAAAY;CAAA,OAAAA,KAAAZ,EAAA;CAH3ChB,UAAUwB,IAGPI,EAAwC;CAAC,IAAAC;CAAA,IAAAb,EAAA,QAAAE,IAAAY,gBAAAd,EAAA,QAAAD,MAAA;EAElCc,WAAA;GAGR,MAAA,EAAAH,UAAAd,QAAAmB,UAAAlB,YAAAmB,SAAA,GAAAC,SAA2DlB;GAC3D,MAAAmB,UAAgB,EAAAT,OACP,GACJC,WAAWO,KACd,EACF;GAAE,OACKf,IAAGY,aAAaK,SAAU,EAAAC,uBACRF,QACzB,CAAC;EAAC;EACHlB,EAAA,MAAAE,IAAAY;EAAAd,EAAA,MAAAD;EAAAC,EAAA,MAAAa;CAAA,OAAAA,KAAAb,EAAA;CAAA,IAAAqB;CAAA,IAAArB,EAAA,QAAAE,OAAAF,EAAA,QAAAD,MAAA;EAAEsB,KAAA,CAACnB,KAAKH,IAAI;EAACC,EAAA,MAAAE;EAAAF,EAAA,MAAAD;EAAAC,EAAA,MAAAqB;CAAA,OAAAA,KAAArB,EAAA;CAZdhB,UAAU6B,IAYPQ,EAAW;AAAC"}
+{"version":3,"file":"useAssistantTool.js","names":["useEffect","useMemo","useAui","ToolCallMessagePartComponent","AssistantToolProps","CoreAssistantToolProps","isStandaloneToolDisplay","makeToolCallTextComponent","ToolCallText","Record","TArgs","TResult","render","renderText","useAssistantTool","tool","$","_c","aui","t0","standalone","t1","undefined","renderTextComponent","t2","tools","toolName","setToolUI","t3","t4","modelContext","render_0","display","rest","context","register","getModelContext","t5"],"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 * `AuiConfig({ tools: Tools({ toolkit }) })` on the provider's `config` prop 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 * `AuiConfig({ tools: Tools({ toolkit }) })` on the provider's `config` prop 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,MAAac,oBAAmBC,SAAA;CAAA,MAAAC,IAAAC,EAAA,EAAA;CAM9B,MAAAC,MAAYhB,OAAO;CAAE,IAAAiB;CAAA,IAAAH,EAAA,OAAAD,MAAA;EAEFI,KAAAb,wBAAwBS,IAAI;EAACC,EAAA,KAAAD;EAAAC,EAAA,KAAAG;CAAA,OAAAA,KAAAH,EAAA;CAAhD,MAAAI,aAAmBD;CAA8B,IAAAE;CAAA,IAAAL,EAAA,OAAAD,KAAAF,YAAA;EAG7CQ,KAAAN,KAAIF,aAAcN,0BAA0BQ,KAAIF,UAAuB,IAAvES,KAAAA;EAAwEN,EAAA,KAAAD,KAAAF;EAAAG,EAAA,KAAAK;CAAA,OAAAA,KAAAL,EAAA;CAF5E,MAAAO,sBAEIF;CAGJ,MAAAT,SAAeG,KAAIH,UAAJW;CAAmC,IAAAC;CAAA,IAAAR,EAAA,OAAAE,IAAAO,SAAAT,EAAA,OAAAJ,UAAAI,EAAA,OAAAI,cAAAJ,EAAA,OAAAD,KAAAW,UAAA;EAExCF,WAAA;GACR,IAAI,CAACZ,QAAM;GAAmB,OACvBM,IAAGO,MAAME,UAAWZ,KAAIW,UAAWd,QAAQ,EAAAQ,WAAa,CAAC;EAAC;EAClEJ,EAAA,KAAAE,IAAAO;EAAAT,EAAA,KAAAJ;EAAAI,EAAA,KAAAI;EAAAJ,EAAA,KAAAD,KAAAW;EAAAV,EAAA,KAAAQ;CAAA,OAAAA,KAAAR,EAAA;CAAA,IAAAY;CAAA,IAAAZ,EAAA,OAAAE,OAAAF,EAAA,QAAAJ,UAAAI,EAAA,QAAAI,cAAAJ,EAAA,QAAAD,KAAAW,UAAA;EAAEE,KAAA;GAACV;GAAKH,KAAIW;GAAWd;GAAQQ;EAAU;EAACJ,EAAA,KAAAE;EAAAF,EAAA,MAAAJ;EAAAI,EAAA,MAAAI;EAAAJ,EAAA,MAAAD,KAAAW;EAAAV,EAAA,MAAAY;CAAA,OAAAA,KAAAZ,EAAA;CAH3ChB,UAAUwB,IAGPI,EAAwC;CAAC,IAAAC;CAAA,IAAAb,EAAA,QAAAE,IAAAY,gBAAAd,EAAA,QAAAD,MAAA;EAElCc,WAAA;GAGR,MAAA,EAAAH,UAAAd,QAAAmB,UAAAlB,YAAAmB,SAAA,GAAAC,SAA2DlB;GAC3D,MAAAmB,UAAgB,EAAAT,OACP,GACJC,WAAWO,KACd,EACF;GAAE,OACKf,IAAGY,aAAaK,SAAU,EAAAC,uBACRF,QACzB,CAAC;EAAC;EACHlB,EAAA,MAAAE,IAAAY;EAAAd,EAAA,MAAAD;EAAAC,EAAA,MAAAa;CAAA,OAAAA,KAAAb,EAAA;CAAA,IAAAqB;CAAA,IAAArB,EAAA,QAAAE,OAAAF,EAAA,QAAAD,MAAA;EAAEsB,KAAA,CAACnB,KAAKH,IAAI;EAACC,EAAA,MAAAE;EAAAF,EAAA,MAAAD;EAAAC,EAAA,MAAAqB;CAAA,OAAAA,KAAArB,EAAA;CAZdhB,UAAU6B,IAYPQ,EAAW;AAAC"}

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

@@ -1,4 +1,5 @@
-import { useEffect, useRef } from "@assistant-ui/tap/react-shim";
+import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { useEffect, useInsertionEffect, useRef } from "@assistant-ui/tap/react-shim";
 import { useAui } from "@assistant-ui/store";
 //#region src/react/model-context/useAuiToolOverrides.ts
 /**
@@ -15,15 +16,40 @@ import { useAui } from "@assistant-ui/store";
 * @deprecated Experimental, API may change.
 */
 function useAuiToolOverrides(overrides) {
+	const $ = c(7);
 	const aui = useAui();
 	const overridesRef = useRef(overrides);
-	overridesRef.current = overrides;
-	useEffect(() => {
-		return aui.modelContext.register({ getModelContext: () => ({
+	let t0;
+	let t1;
+	if ($[0] !== overrides) {
+		t0 = () => {
+			overridesRef.current = overrides;
+		};
+		t1 = [overrides];
+		$[0] = overrides;
+		$[1] = t0;
+		$[2] = t1;
+	} else {
+		t0 = $[1];
+		t1 = $[2];
+	}
+	useInsertionEffect(t0, t1);
+	let t2;
+	if ($[3] !== aui.modelContext) {
+		t2 = () => aui.modelContext.register({ getModelContext: () => ({
 			priority: 1e3,
 			tools: overridesRef.current
 		}) });
-	}, [aui]);
+		$[3] = aui.modelContext;
+		$[4] = t2;
+	} else t2 = $[4];
+	let t3;
+	if ($[5] !== aui) {
+		t3 = [aui];
+		$[5] = aui;
+		$[6] = t3;
+	} else t3 = $[6];
+	useEffect(t2, t3);
 }
 //#endregion
 export { useAuiToolOverrides };

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

@@ -1 +1 @@
-{"version":3,"file":"useAuiToolOverrides.js","names":["useEffect","useRef","useAui","Tool","AuiToolOverride","Record","Partial","TArgs","TResult","AuiToolOverrides","useAuiToolOverrides","overrides","aui","overridesRef","current","modelContext","register","getModelContext","priority","tools"],"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,SAAgBU,oBAAoBC,WAAmC;CACrE,MAAMC,MAAMV,OAAO;CACnB,MAAMW,eAAeZ,OAAOU,SAAS;CACrCE,aAAaC,UAAUH;CAEvBX,gBAAgB;EACd,OAAOY,IAAIG,aAAaC,SAAS,EAC/BC,wBAAwB;GACtBC,UAAU;GACVC,OAAON,aAAaC;EACtB,GACF,CAAC;CACH,GAAG,CAACF,GAAG,CAAC;AACV"}
+{"version":3,"file":"useAuiToolOverrides.js","names":["useEffect","useInsertionEffect","useRef","useAui","Tool","AuiToolOverride","Record","Partial","TArgs","TResult","AuiToolOverrides","useAuiToolOverrides","overrides","$","_c","aui","overridesRef","t0","t1","current","t2","modelContext","register","getModelContext","priority","tools","t3"],"sources":["../../../src/react/model-context/useAuiToolOverrides.ts"],"sourcesContent":["import { useEffect, useInsertionEffect, 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  useInsertionEffect(() => {\n    overridesRef.current = overrides;\n  }, [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,SAAOW,oBAAAC,WAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CACL,MAAAC,MAAYZ,OAAO;CACnB,MAAAa,eAAqBd,OAAOU,SAAS;CAAE,IAAAK;CAAA,IAAAC;CAAA,IAAAL,EAAA,OAAAD,WAAA;EACpBK,WAAA;GACjBD,aAAYG,UAAWP;EAAH;EACnBM,KAAA,CAACN,SAAS;EAACC,EAAA,KAAAD;EAAAC,EAAA,KAAAI;EAAAJ,EAAA,KAAAK;CAAA,OAAA;EAAAD,KAAAJ,EAAA;EAAAK,KAAAL,EAAA;CAAA;CAFdZ,mBAAmBgB,IAEhBC,EAAW;CAAC,IAAAE;CAAA,IAAAP,EAAA,OAAAE,IAAAM,cAAA;EAELD,WACDL,IAAGM,aAAaC,SAAU,EAAAC,wBACP;GAAAC,UACZ;GAAIC,OACPT,aAAYG;EACrB,GACF,CAAC;EACFN,EAAA,KAAAE,IAAAM;EAAAR,EAAA,KAAAO;CAAA,OAAAA,KAAAP,EAAA;CAAA,IAAAa;CAAA,IAAAb,EAAA,OAAAE,KAAA;EAAEW,KAAA,CAACX,GAAG;EAACF,EAAA,KAAAE;EAAAF,EAAA,KAAAa;CAAA,OAAAA,KAAAb,EAAA;CAPRb,UAAUoB,IAOPM,EAAK;AAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"useInlineRender.d.ts","names":[],"sources":["../../../src/react/model-context/useInlineRender.ts"],"mappings":";;;cAIa,kBAAmB,OAAO,SACrC,QAAQ,GAAG,yBAAyB,OAAO,cAC1C,GAAG,yBAAyB,OAAO"}
+{"version":3,"file":"useInlineRender.d.ts","names":[],"sources":["../../../src/react/model-context/useInlineRender.ts"],"mappings":";;;cAKa,kBAAmB,OAAO,SACrC,QAAQ,GAAG,yBAAyB,OAAO,cAC1C,GAAG,yBAAyB,OAAO"}

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

@@ -1,41 +1,15 @@
-import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
-import { useEffect, useState } from "@assistant-ui/tap/react-shim";
-import { create } from "zustand";
+import { WritableSubscribable } from "../../subscribable/subscribable.js";
+import { useSubscribable } from "../../store/runtime-clients/useSubscribable.js";
+import { useCallback, useEffect, useState } from "@assistant-ui/tap/react-shim";
 //#region src/react/model-context/useInlineRender.ts
 const useInlineRender = (toolUI) => {
-	const $ = c(8);
-	let t0;
-	if ($[0] !== toolUI) {
-		t0 = () => create(() => ({ toolUI }));
-		$[0] = toolUI;
-		$[1] = t0;
-	} else t0 = $[1];
-	const [useToolUIStore] = useState(t0);
-	let t1;
-	let t2;
-	if ($[2] !== toolUI || $[3] !== useToolUIStore) {
-		t1 = () => {
-			useToolUIStore.setState({ toolUI });
-		};
-		t2 = [toolUI, useToolUIStore];
-		$[2] = toolUI;
-		$[3] = useToolUIStore;
-		$[4] = t1;
-		$[5] = t2;
-	} else {
-		t1 = $[4];
-		t2 = $[5];
-	}
-	useEffect(t1, t2);
-	let t3;
-	if ($[6] !== useToolUIStore) {
-		t3 = function ToolUI(args) {
-			return useToolUIStore().toolUI(args);
-		};
-		$[6] = useToolUIStore;
-		$[7] = t3;
-	} else t3 = $[7];
-	return t3;
+	const [toolUIStore] = useState(() => new WritableSubscribable(toolUI));
+	useEffect(() => {
+		toolUIStore.setState(toolUI);
+	}, [toolUI, toolUIStore]);
+	return useCallback(function ToolUI(args) {
+		return useSubscribable(toolUIStore)(args);
+	}, [toolUIStore]);
 };
 //#endregion
 export { useInlineRender };

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

@@ -1 +1 @@
-{"version":3,"file":"useInlineRender.js","names":["FC","useCallback","useEffect","useState","ToolCallMessagePartProps","create","useInlineRender","toolUI","$","_c","t0","useToolUIStore","t1","t2","setState","t3","ToolUI","args","store"],"sources":["../../../src/react/model-context/useInlineRender.ts"],"sourcesContent":["import { type FC, useCallback, useEffect, useState } from \"react\";\nimport type { ToolCallMessagePartProps } from \"../types/MessagePartComponentTypes\";\nimport { create } from \"zustand\";\n\nexport const useInlineRender = <TArgs, TResult>(\n  toolUI: FC<ToolCallMessagePartProps<TArgs, TResult>>,\n): FC<ToolCallMessagePartProps<TArgs, TResult>> => {\n  const [useToolUIStore] = useState(() =>\n    create(() => ({\n      toolUI,\n    })),\n  );\n\n  useEffect(() => {\n    useToolUIStore.setState({ toolUI });\n  }, [toolUI, useToolUIStore]);\n\n  return useCallback(\n    function ToolUI(args) {\n      const store = useToolUIStore();\n      return store.toolUI(args);\n    },\n    [useToolUIStore],\n  );\n};\n"],"mappings":";;;;AAIA,MAAaM,mBAAkBC,WAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CAAA,IAAAC;CAAA,IAAAF,EAAA,OAAAD,QAAA;EAGKG,WAChCL,cAAc,EAAAE,OAEd,EAAE;EAACC,EAAA,KAAAD;EAAAC,EAAA,KAAAE;CAAA,OAAAA,KAAAF,EAAA;CAHL,MAAA,CAAAG,kBAAyBR,SAASO,EAIlC;CAAE,IAAAE;CAAA,IAAAC;CAAA,IAAAL,EAAA,OAAAD,UAAAC,EAAA,OAAAG,gBAAA;EAEQC,WAAA;GACRD,eAAcG,SAAU,EAAAP,OAAS,CAAC;EAAC;EAClCM,KAAA,CAACN,QAAQI,cAAc;EAACH,EAAA,KAAAD;EAAAC,EAAA,KAAAG;EAAAH,EAAA,KAAAI;EAAAJ,EAAA,KAAAK;CAAA,OAAA;EAAAD,KAAAJ,EAAA;EAAAK,KAAAL,EAAA;CAAA;CAF3BN,UAAUU,IAEPC,EAAwB;CAAC,IAAAE;CAAA,IAAAP,EAAA,OAAAG,gBAAA;EAG1BI,KAAA,SAAAC,OAAAC,MAAA;GACiC,OAAjBN,eACPO,CAAK,CAAAX,OAAQU,IAAI;EAAC;EAC1BT,EAAA,KAAAG;EAAAH,EAAA,KAAAO;CAAA,OAAAA,KAAAP,EAAA;CAAA,OAJIO;AAMN"}
+{"version":3,"file":"useInlineRender.js","names":["FC","useCallback","useEffect","useState","ToolCallMessagePartProps","WritableSubscribable","useSubscribable","useInlineRender","toolUI","TArgs","TResult","toolUIStore","setState","ToolUI","args","currentToolUI"],"sources":["../../../src/react/model-context/useInlineRender.ts"],"sourcesContent":["import { type FC, useCallback, useEffect, useState } from \"react\";\nimport type { ToolCallMessagePartProps } from \"../types/MessagePartComponentTypes\";\nimport { WritableSubscribable } from \"../../subscribable/subscribable\";\nimport { useSubscribable } from \"../../store/runtime-clients/useSubscribable\";\n\nexport const useInlineRender = <TArgs, TResult>(\n  toolUI: FC<ToolCallMessagePartProps<TArgs, TResult>>,\n): FC<ToolCallMessagePartProps<TArgs, TResult>> => {\n  const [toolUIStore] = useState(\n    () =>\n      new WritableSubscribable<FC<ToolCallMessagePartProps<TArgs, TResult>>>(\n        toolUI,\n      ),\n  );\n\n  useEffect(() => {\n    toolUIStore.setState(toolUI);\n  }, [toolUI, toolUIStore]);\n\n  return useCallback(\n    function ToolUI(args) {\n      // Invoked as a plain function so its hooks belong to this component,\n      // which keeps its identity while `toolUI` changes underneath.\n      const currentToolUI = useSubscribable(toolUIStore);\n      return currentToolUI(args);\n    },\n    [toolUIStore],\n  );\n};\n"],"mappings":";;;;AAKA,MAAaO,mBACXC,WACiD;CACjD,MAAM,CAACG,eAAeR,eAElB,IAAIE,qBACFG,MACF,CACJ;CAEAN,gBAAgB;EACdS,YAAYC,SAASJ,MAAM;CAC7B,GAAG,CAACA,QAAQG,WAAW,CAAC;CAExB,OAAOV,YACL,SAASY,OAAOC,MAAM;EAIpB,OADsBR,gBAAgBK,WAC/BI,CAAa,CAACD,IAAI;CAC3B,GACA,CAACH,WAAW,CACd;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"useToolArgsStatus.d.ts","names":[],"sources":["../../../src/react/model-context/useToolArgsStatus.ts"],"mappings":";KAOK;;;;KAKO,eACV,cAAc,0BAA0B;;EAGxC;;EAEA,YAAY,QAAQ,aAAa,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;cA2B7B,oBACX,cAAc,0BAA0B,8BACrC,eAAe"}
+{"version":3,"file":"useToolArgsStatus.d.ts","names":[],"sources":["../../../src/react/model-context/useToolArgsStatus.ts"],"mappings":";KAQK;;;;KAKO,eACV,cAAc,0BAA0B;;EAGxC;;EAEA,YAAY,QAAQ,aAAa,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;cA2B7B,oBACX,cAAc,0BAA0B,8BACrC,eAAe"}

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

@@ -1,3 +1,4 @@
+import { nullProtoRecord } from "../../utils/record.js";
 import { getPartialJsonObjectFieldState, getPartialJsonObjectMeta } from "assistant-stream/utils";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
 import "@assistant-ui/tap/react-shim";
@@ -45,7 +46,7 @@ const useToolArgsStatus = () => {
 	const meta = t2;
 	let propStatus;
 	if ($[2] !== args || $[3] !== isStreaming || $[4] !== meta) {
-		propStatus = {};
+		propStatus = nullProtoRecord();
 		for (const key of Object.keys(args)) if (meta) {
 			const fieldState = getPartialJsonObjectFieldState(args, [key]);
 			propStatus[key] = fieldState === "complete" || !isStreaming ? "complete" : "streaming";

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

@@ -1 +1 @@
-{"version":3,"file":"useToolArgsStatus.js","names":["useMemo","useAuiState","getPartialJsonObjectFieldState","getPartialJsonObjectMeta","PropFieldStatus","ToolArgsStatus","Record","status","propStatus","Partial","TArgs","useToolArgsStatus","$","_c","part","_temp","t0","statusType","type","Error","isStreaming","args","t1","t2","meta","key","Object","keys","fieldState","t3","t4","s"],"sources":["../../../src/react/model-context/useToolArgsStatus.ts"],"sourcesContent":["import { useMemo } from \"react\";\nimport { useAuiState } from \"@assistant-ui/store\";\nimport {\n  getPartialJsonObjectFieldState,\n  getPartialJsonObjectMeta,\n} from \"assistant-stream/utils\";\n\ntype PropFieldStatus = \"streaming\" | \"complete\";\n\n/**\n * Streaming completion status for the arguments of the current tool call.\n */\nexport type ToolArgsStatus<\n  TArgs extends Record<string, unknown> = Record<string, unknown>,\n> = {\n  /** Overall lifecycle state of the tool-call part. */\n  status: \"running\" | \"complete\" | \"incomplete\" | \"requires-action\";\n  /** Per-argument status keyed by argument name. */\n  propStatus: Partial<Record<keyof TArgs, PropFieldStatus>>;\n};\n\n/**\n * Reads whether each argument field for the current tool-call message part is\n * still streaming or complete.\n *\n * Use inside a tool-call renderer to avoid showing incomplete argument values\n * as final.\n *\n * @throws If called outside a tool-call message part.\n *\n * @example\n * ```tsx\n * function WeatherToolUI({\n *   args,\n * }: ToolCallMessagePartProps<{ city: string }>) {\n *   const { propStatus } = useToolArgsStatus<{ city: string }>();\n *\n *   return (\n *     <span>\n *       {propStatus.city === \"streaming\" ? \"Reading city...\" : args.city}\n *     </span>\n *   );\n * }\n * ```\n */\nexport const useToolArgsStatus = <\n  TArgs extends Record<string, unknown> = Record<string, unknown>,\n>(): ToolArgsStatus<TArgs> => {\n  const part = useAuiState((s) => s.part);\n\n  return useMemo(() => {\n    const statusType = part.status.type;\n\n    if (part.type !== \"tool-call\") {\n      throw new Error(\n        \"useToolArgsStatus can only be used inside tool-call message parts\",\n      );\n    }\n\n    const isStreaming = statusType === \"running\";\n    const args = part.args as Record<string, unknown>;\n    const meta = getPartialJsonObjectMeta(args as Record<symbol, unknown>);\n    const propStatus: Partial<Record<string, PropFieldStatus>> = {};\n\n    for (const key of Object.keys(args)) {\n      if (meta) {\n        const fieldState = getPartialJsonObjectFieldState(args, [key]);\n        propStatus[key] =\n          fieldState === \"complete\" || !isStreaming ? \"complete\" : \"streaming\";\n      } else {\n        propStatus[key] = isStreaming ? \"streaming\" : \"complete\";\n      }\n    }\n\n    return {\n      status: statusType,\n      propStatus: propStatus as Partial<Record<keyof TArgs, PropFieldStatus>>,\n    };\n  }, [part]);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,MAAaW,0BAAoB;CAAA,MAAAC,IAAAC,EAAA,CAAA;CAG/B,MAAAC,OAAab,YAAYc,KAAa;CAAE,IAAAC;CAGtC,MAAAC,aAAmBH,KAAIP,OAAOW;CAE9B,IAAIJ,KAAII,SAAU,aAChB,MAAM,IAAIC,MACR,mEACF;CAGF,MAAAC,cAAoBH,eAAe;CACnC,MAAAI,OAAaP,KAAIO;CACqB,MAAAC,KAAAD;CAA+B,IAAAE;CAAA,IAAAX,EAAA,OAAAU,IAAA;EAAxDC,KAAApB,yBAAyBmB,EAA+B;EAACV,EAAA,KAAAU;EAAAV,EAAA,KAAAW;CAAA,OAAAA,KAAAX,EAAA;CAAtE,MAAAY,OAAaD;CAA0D,IAAAf;CAAA,IAAAI,EAAA,OAAAS,QAAAT,EAAA,OAAAQ,eAAAR,EAAA,OAAAY,MAAA;EACvEhB,aAA6D,CAAC;EAE9D,KAAK,MAAAiB,OAAaC,OAAMC,KAAMN,IAAI,GAChC,IAAIG,MAAI;GACN,MAAAI,aAAmB1B,+BAA+BmB,MAAM,CAACI,GAAG,CAAC;GAC7DjB,WAAWiB,OACTG,eAAe,cAAf,CAA8BR,cAA9B,aAAA;EADa,OAGfZ,WAAWiB,OAAOL,cAAA,cAAA;EAErBR,EAAA,KAAAS;EAAAT,EAAA,KAAAQ;EAAAR,EAAA,KAAAY;EAAAZ,EAAA,KAAAJ;CAAA,OAAAA,aAAAI,EAAA;CAIa,MAAAiB,KAAArB;CAA2D,IAAAsB;CAAA,IAAAlB,EAAA,OAAAK,cAAAL,EAAA,OAAAiB,IAAA;EAFlEC,KAAA;GAAAvB,QACGU;GAAUT,YACNqB;EACd;EAACjB,EAAA,KAAAK;EAAAL,EAAA,KAAAiB;EAAAjB,EAAA,KAAAkB;CAAA,OAAAA,KAAAlB,EAAA;CAHDI,KAAOc;CAGL,OA3BGd;AA4BG;AAjCqB,SAAAD,MAAAgB,GAAA;CAAA,OAGCA,EAACjB;AAAK"}
+{"version":3,"file":"useToolArgsStatus.js","names":["useMemo","useAuiState","getPartialJsonObjectFieldState","getPartialJsonObjectMeta","nullProtoRecord","PropFieldStatus","ToolArgsStatus","Record","status","propStatus","Partial","TArgs","useToolArgsStatus","$","_c","part","_temp","t0","statusType","type","Error","isStreaming","args","t1","t2","meta","key","Object","keys","fieldState","t3","t4","s"],"sources":["../../../src/react/model-context/useToolArgsStatus.ts"],"sourcesContent":["import { useMemo } from \"react\";\nimport { useAuiState } from \"@assistant-ui/store\";\nimport {\n  getPartialJsonObjectFieldState,\n  getPartialJsonObjectMeta,\n} from \"assistant-stream/utils\";\nimport { nullProtoRecord } from \"../../utils/record\";\n\ntype PropFieldStatus = \"streaming\" | \"complete\";\n\n/**\n * Streaming completion status for the arguments of the current tool call.\n */\nexport type ToolArgsStatus<\n  TArgs extends Record<string, unknown> = Record<string, unknown>,\n> = {\n  /** Overall lifecycle state of the tool-call part. */\n  status: \"running\" | \"complete\" | \"incomplete\" | \"requires-action\";\n  /** Per-argument status keyed by argument name. */\n  propStatus: Partial<Record<keyof TArgs, PropFieldStatus>>;\n};\n\n/**\n * Reads whether each argument field for the current tool-call message part is\n * still streaming or complete.\n *\n * Use inside a tool-call renderer to avoid showing incomplete argument values\n * as final.\n *\n * @throws If called outside a tool-call message part.\n *\n * @example\n * ```tsx\n * function WeatherToolUI({\n *   args,\n * }: ToolCallMessagePartProps<{ city: string }>) {\n *   const { propStatus } = useToolArgsStatus<{ city: string }>();\n *\n *   return (\n *     <span>\n *       {propStatus.city === \"streaming\" ? \"Reading city...\" : args.city}\n *     </span>\n *   );\n * }\n * ```\n */\nexport const useToolArgsStatus = <\n  TArgs extends Record<string, unknown> = Record<string, unknown>,\n>(): ToolArgsStatus<TArgs> => {\n  const part = useAuiState((s) => s.part);\n\n  return useMemo(() => {\n    const statusType = part.status.type;\n\n    if (part.type !== \"tool-call\") {\n      throw new Error(\n        \"useToolArgsStatus can only be used inside tool-call message parts\",\n      );\n    }\n\n    const isStreaming = statusType === \"running\";\n    const args = part.args as Record<string, unknown>;\n    const meta = getPartialJsonObjectMeta(args as Record<symbol, unknown>);\n    const propStatus = nullProtoRecord<PropFieldStatus>();\n\n    for (const key of Object.keys(args)) {\n      if (meta) {\n        const fieldState = getPartialJsonObjectFieldState(args, [key]);\n        propStatus[key] =\n          fieldState === \"complete\" || !isStreaming ? \"complete\" : \"streaming\";\n      } else {\n        propStatus[key] = isStreaming ? \"streaming\" : \"complete\";\n      }\n    }\n\n    return {\n      status: statusType,\n      propStatus: propStatus as Partial<Record<keyof TArgs, PropFieldStatus>>,\n    };\n  }, [part]);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CA,MAAaY,0BAAoB;CAAA,MAAAC,IAAAC,EAAA,CAAA;CAG/B,MAAAC,OAAad,YAAYe,KAAa;CAAE,IAAAC;CAGtC,MAAAC,aAAmBH,KAAIP,OAAOW;CAE9B,IAAIJ,KAAII,SAAU,aAChB,MAAM,IAAIC,MACR,mEACF;CAGF,MAAAC,cAAoBH,eAAe;CACnC,MAAAI,OAAaP,KAAIO;CACqB,MAAAC,KAAAD;CAA+B,IAAAE;CAAA,IAAAX,EAAA,OAAAU,IAAA;EAAxDC,KAAArB,yBAAyBoB,EAA+B;EAACV,EAAA,KAAAU;EAAAV,EAAA,KAAAW;CAAA,OAAAA,KAAAX,EAAA;CAAtE,MAAAY,OAAaD;CAA0D,IAAAf;CAAA,IAAAI,EAAA,OAAAS,QAAAT,EAAA,OAAAQ,eAAAR,EAAA,OAAAY,MAAA;EACvEhB,aAAmBL,gBAAiC;EAEpD,KAAK,MAAAsB,OAAaC,OAAMC,KAAMN,IAAI,GAChC,IAAIG,MAAI;GACN,MAAAI,aAAmB3B,+BAA+BoB,MAAM,CAACI,GAAG,CAAC;GAC7DjB,WAAWiB,OACTG,eAAe,cAAf,CAA8BR,cAA9B,aAAA;EADa,OAGfZ,WAAWiB,OAAOL,cAAA,cAAA;EAErBR,EAAA,KAAAS;EAAAT,EAAA,KAAAQ;EAAAR,EAAA,KAAAY;EAAAZ,EAAA,KAAAJ;CAAA,OAAAA,aAAAI,EAAA;CAIa,MAAAiB,KAAArB;CAA2D,IAAAsB;CAAA,IAAAlB,EAAA,OAAAK,cAAAL,EAAA,OAAAiB,IAAA;EAFlEC,KAAA;GAAAvB,QACGU;GAAUT,YACNqB;EACd;EAACjB,EAAA,KAAAK;EAAAL,EAAA,KAAAiB;EAAAjB,EAAA,KAAAkB;CAAA,OAAAA,KAAAlB,EAAA;CAHDI,KAAOc;CAGL,OA3BGd;AA4BG;AAjCqB,SAAAD,MAAAgB,GAAA;CAAA,OAGCA,EAACjB;AAAK"}

package/dist/react/primitive-hooks/useMessageError.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useMessageError.d.ts","names":[],"sources":["../../../src/react/primitive-hooks/useMessageError.ts"],"mappings":";cAEa,oFAAe,sDAAA"}
+{"version":3,"file":"useMessageError.d.ts","names":[],"sources":["../../../src/react/primitive-hooks/useMessageError.ts"],"mappings":";cAGa,oFAAe,sDAAA"}

package/dist/react/primitive-hooks/useMessageError.js

@@ -1,15 +1,9 @@
+import { messageErrorText } from "../../store/primitive-predicates.js";
 import { useAuiState } from "@assistant-ui/store";
 //#region src/react/primitive-hooks/useMessageError.ts
 const useMessageError = () => {
-	return useAuiState(_temp);
+	return useAuiState(messageErrorText);
 };
-function _temp(s) {
-	if (s.message.status?.type !== "incomplete" || s.message.status.reason !== "error") return;
-	const error = s.message.status.error;
-	if (typeof error === "string") return error;
-	if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") return error.message;
-	return error ?? "An error occurred";
-}
 //#endregion
 export { useMessageError };
 

package/dist/react/primitive-hooks/useMessageError.js.map

@@ -1 +1 @@
-{"version":3,"file":"useMessageError.js","names":["useAuiState","useMessageError","_temp","s","message","status","type","reason","error"],"sources":["../../../src/react/primitive-hooks/useMessageError.ts"],"sourcesContent":["import { useAuiState } from \"@assistant-ui/store\";\n\nexport const useMessageError = () => {\n  return useAuiState((s) => {\n    if (\n      s.message.status?.type !== \"incomplete\" ||\n      s.message.status.reason !== \"error\"\n    ) {\n      return undefined;\n    }\n    const error = s.message.status.error;\n    if (typeof error === \"string\") return error;\n    if (\n      typeof error === \"object\" &&\n      error !== null &&\n      \"message\" in error &&\n      typeof error.message === \"string\"\n    ) {\n      return error.message;\n    }\n    return error ?? \"An error occurred\";\n  });\n};\n"],"mappings":";;AAEA,MAAaC,wBAAkB;CAAA,OACtBD,YAAYE,KAkBlB;AAAC;AAnB2B,SAAAA,MAAAC,GAAA;CAE3B,IACEA,EAACC,QAAQC,QAAaC,SAAK,gBAC3BH,EAACC,QAAQC,OAAOE,WAAY,SAAO;CAIrC,MAAAC,QAAcL,EAACC,QAAQC,OAAOG;CAC9B,IAAI,OAAOA,UAAU,UAAQ,OAASA;CACtC,IACE,OAAOA,UAAU,YACjBA,UAAU,QACV,aAAaA,SACb,OAAOA,MAAKJ,YAAa,UAAQ,OAE1BI,MAAKJ;CACb,OACMI,SAAA;AAA4B"}
+{"version":3,"file":"useMessageError.js","names":["useAuiState","messageErrorText","useMessageError"],"sources":["../../../src/react/primitive-hooks/useMessageError.ts"],"sourcesContent":["import { useAuiState } from \"@assistant-ui/store\";\nimport { messageErrorText } from \"../../store/primitive-predicates\";\n\nexport const useMessageError = () => {\n  return useAuiState(messageErrorText);\n};\n"],"mappings":";;;AAGA,MAAaE,wBAAkB;CAAA,OACtBF,YAAYC,gBAAgB;AAAC"}

package/dist/react/primitive-hooks/useThreadListLoadMore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useThreadListLoadMore.d.ts","names":[],"sources":["../../../src/react/primitive-hooks/useThreadListLoadMore.ts"],"mappings":";cAGa;EAAA;EAAA"}
+{"version":3,"file":"useThreadListLoadMore.d.ts","names":[],"sources":["../../../src/react/primitive-hooks/useThreadListLoadMore.ts"],"mappings":";cAIa;EAAA;EAAA"}

package/dist/react/primitive-hooks/useThreadListLoadMore.js

@@ -1,3 +1,4 @@
+import { threadListLoadMoreDisabled } from "../../store/primitive-predicates.js";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
 import "@assistant-ui/tap/react-shim";
 import { useAui, useAuiState } from "@assistant-ui/store";
@@ -5,7 +6,7 @@ import { useAui, useAuiState } from "@assistant-ui/store";
 const useThreadListLoadMore = () => {
 	const $ = c(5);
 	const aui = useAui();
-	const disabled = useAuiState(_temp);
+	const disabled = useAuiState(threadListLoadMoreDisabled);
 	let t0;
 	if ($[0] !== aui) {
 		t0 = () => {
@@ -27,9 +28,6 @@ const useThreadListLoadMore = () => {
 	} else t1 = $[4];
 	return t1;
 };
-function _temp(s) {
-	return !s.threads.hasMore || s.threads.isLoading || s.threads.isLoadingMore;
-}
 //#endregion
 export { useThreadListLoadMore };
 

package/dist/react/primitive-hooks/useThreadListLoadMore.js.map

@@ -1 +1 @@
-{"version":3,"file":"useThreadListLoadMore.js","names":["useCallback","useAui","useAuiState","useThreadListLoadMore","$","_c","aui","disabled","_temp","t0","threads","loadMore","t1","s","hasMore","isLoading","isLoadingMore"],"sources":["../../../src/react/primitive-hooks/useThreadListLoadMore.ts"],"sourcesContent":["import { useCallback } from \"react\";\nimport { useAui, useAuiState } from \"@assistant-ui/store\";\n\nexport const useThreadListLoadMore = () => {\n  const aui = useAui();\n  const disabled = useAuiState(\n    (s) => !s.threads.hasMore || s.threads.isLoading || s.threads.isLoadingMore,\n  );\n\n  const loadMore = useCallback(() => {\n    aui.threads.loadMore();\n  }, [aui]);\n\n  return { loadMore, disabled };\n};\n"],"mappings":";;;;AAGA,MAAaG,8BAAwB;CAAA,MAAAC,IAAAC,EAAA,CAAA;CACnC,MAAAC,MAAYL,OAAO;CACnB,MAAAM,WAAiBL,YACfM,KACF;CAAE,IAAAC;CAAA,IAAAL,EAAA,OAAAE,KAAA;EAE2BG,WAAA;GAC3BH,IAAGI,QAAQC,SAAU;EAAC;EACvBP,EAAA,KAAAE;EAAAF,EAAA,KAAAK;CAAA,OAAAA,KAAAL,EAAA;CAFD,MAAAO,WAAiBF;CAEP,IAAAG;CAAA,IAAAR,EAAA,OAAAG,YAAAH,EAAA,OAAAO,UAAA;EAEHC,KAAA;GAAAD;GAAAJ;EAAqB;EAACH,EAAA,KAAAG;EAAAH,EAAA,KAAAO;EAAAP,EAAA,KAAAQ;CAAA,OAAAA,KAAAR,EAAA;CAAA,OAAtBQ;AAAsB;AAVM,SAAAJ,MAAAK,GAAA;CAAA,OAG1B,CAACA,EAACH,QAAQI,WAAYD,EAACH,QAAQK,aAAcF,EAACH,QAAQM;AAAc"}
+{"version":3,"file":"useThreadListLoadMore.js","names":["useCallback","useAui","useAuiState","threadListLoadMoreDisabled","useThreadListLoadMore","$","_c","aui","disabled","t0","threads","loadMore","t1"],"sources":["../../../src/react/primitive-hooks/useThreadListLoadMore.ts"],"sourcesContent":["import { useCallback } from \"react\";\nimport { useAui, useAuiState } from \"@assistant-ui/store\";\nimport { threadListLoadMoreDisabled } from \"../../store/primitive-predicates\";\n\nexport const useThreadListLoadMore = () => {\n  const aui = useAui();\n  const disabled = useAuiState(threadListLoadMoreDisabled);\n\n  const loadMore = useCallback(() => {\n    aui.threads.loadMore();\n  }, [aui]);\n\n  return { loadMore, disabled };\n};\n"],"mappings":";;;;;AAIA,MAAaI,8BAAwB;CAAA,MAAAC,IAAAC,EAAA,CAAA;CACnC,MAAAC,MAAYN,OAAO;CACnB,MAAAO,WAAiBN,YAAYC,0BAA0B;CAAE,IAAAM;CAAA,IAAAJ,EAAA,OAAAE,KAAA;EAE5BE,WAAA;GAC3BF,IAAGG,QAAQC,SAAU;EAAC;EACvBN,EAAA,KAAAE;EAAAF,EAAA,KAAAI;CAAA,OAAAA,KAAAJ,EAAA;CAFD,MAAAM,WAAiBF;CAEP,IAAAG;CAAA,IAAAP,EAAA,OAAAG,YAAAH,EAAA,OAAAM,UAAA;EAEHC,KAAA;GAAAD;GAAAH;EAAqB;EAACH,EAAA,KAAAG;EAAAH,EAAA,KAAAM;EAAAN,EAAA,KAAAO;CAAA,OAAAA,KAAAP,EAAA;CAAA,OAAtBO;AAAsB"}

package/dist/react/primitives/composer/ComposerAttachments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ComposerAttachments.d.ts","names":[],"sources":["../../../../src/react/primitives/composer/ComposerAttachments.tsx"],"mappings":";;;KAWK;EACH,QAAQ;EACR,WAAW;EACX,OAAO;EACP,aAAa;;kBAGE;OACH;;IAGN,YAAY;IACZ;;;IAIA,WAAW;MAAS,YAAY;UAAiB;IACjD;;;kBAgCS;OACH;IACV;IACA,aAAa;;;;;;cAOJ,oCAAoC,GAAG,mCAAmC;cAgD1E,8BAA8B,GACzC,6BAA6B"}
+{"version":3,"file":"ComposerAttachments.d.ts","names":[],"sources":["../../../../src/react/primitives/composer/ComposerAttachments.tsx"],"mappings":";;;KAYK;EACH,QAAQ;EACR,WAAW;EACX,OAAO;EACP,aAAa;;kBAGE;OACH;;IAGN,YAAY;IACZ;;;IAIA,WAAW;MAAS,YAAY;UAAiB;IACjD;;;kBAgCS;OACH;IACV;IACA,aAAa;;;;;;cAOJ,oCAAoC,GAAG,mCAAmC;cAoD1E,8BAA8B,GACzC,6BAA6B"}

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

@@ -2,6 +2,7 @@ import { ComposerAttachmentByIndexProvider } from "../../providers/AttachmentByI
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
 import { memo, useMemo } from "@assistant-ui/tap/react-shim";
 import { RenderChildrenWithAccessor, useAuiState } from "@assistant-ui/store";
+import { useShallowSelector } from "@assistant-ui/store/internal";
 import { jsx } from "react/jsx-runtime";
 //#region src/react/primitives/composer/ComposerAttachments.tsx
 const getComponent = (components, attachment) => {
@@ -60,8 +61,8 @@ const ComposerPrimitiveAttachmentByIndex = memo((t0) => {
 }, (prev, next) => prev.index === next.index && prev.components?.Image === next.components?.Image && prev.components?.Document === next.components?.Document && prev.components?.File === next.components?.File && prev.components?.Attachment === next.components?.Attachment);
 ComposerPrimitiveAttachmentByIndex.displayName = "ComposerPrimitive.AttachmentByIndex";
 const ComposerPrimitiveAttachmentsInner = ({ children }) => {
-	const attachmentsCount = useAuiState((s) => s.composer.attachments.length);
-	return useMemo(() => Array.from({ length: attachmentsCount }, (_, index) => /* @__PURE__ */ jsx(ComposerAttachmentByIndexProvider, {
+	const attachmentIds = useAuiState(useShallowSelector((s) => s.composer.attachments.map((attachment) => attachment.id)));
+	return useMemo(() => attachmentIds.map((attachmentId, index) => /* @__PURE__ */ jsx(ComposerAttachmentByIndexProvider, {
 		index,
 		children: /* @__PURE__ */ jsx(RenderChildrenWithAccessor, {
 			getItemState: (aui) => aui.composer.attachment({ index }).getState(),
@@ -69,7 +70,7 @@ const ComposerPrimitiveAttachmentsInner = ({ children }) => {
 				return getItem();
 			} })
 		})
-	}, index)), [attachmentsCount, children]);
+	}, attachmentId)), [attachmentIds, children]);
 };
 const ComposerPrimitiveAttachments = (t0) => {
 	const $ = c(4);

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

@@ -1 +1 @@
-{"version":3,"file":"ComposerAttachments.js","names":["Attachment","ComponentType","FC","ReactNode","memo","useMemo","RenderChildrenWithAccessor","useAuiState","ComposerAttachmentByIndexProvider","ComposerAttachmentsComponentConfig","Image","Document","File","ComposerPrimitiveAttachments","Props","components","children","value","attachment","getComponent","type","AttachmentComponent","t0","$","_c","_temp","t1","Component","t2","ComposerPrimitiveAttachmentByIndex","index","prev","next","displayName","ComposerPrimitiveAttachmentsInner","attachmentsCount","s","composer","attachments","length","Array","from","_","aui","getState","getItem"],"sources":["../../../../src/react/primitives/composer/ComposerAttachments.tsx"],"sourcesContent":["import type { Attachment } from \"../../../types/attachment\";\nimport {\n  type ComponentType,\n  type FC,\n  type ReactNode,\n  memo,\n  useMemo,\n} from \"react\";\nimport { RenderChildrenWithAccessor, useAuiState } from \"@assistant-ui/store\";\nimport { ComposerAttachmentByIndexProvider } from \"../../providers/AttachmentByIndexProvider\";\n\ntype ComposerAttachmentsComponentConfig = {\n  Image?: ComponentType | undefined;\n  Document?: ComponentType | undefined;\n  File?: ComponentType | undefined;\n  Attachment?: ComponentType | undefined;\n};\n\nexport namespace ComposerPrimitiveAttachments {\n  export type Props =\n    | {\n        /** @deprecated Use the children render function instead. */\n        components: ComposerAttachmentsComponentConfig;\n        children?: never;\n      }\n    | {\n        /** Render function called for each attachment. Receives the attachment. */\n        children: (value: { attachment: Attachment }) => ReactNode;\n        components?: never;\n      };\n}\n\nconst getComponent = (\n  components: ComposerAttachmentsComponentConfig | undefined,\n  attachment: Attachment,\n) => {\n  const type = attachment.type;\n  switch (type) {\n    case \"image\":\n      return components?.Image ?? components?.Attachment;\n    case \"document\":\n      return components?.Document ?? components?.Attachment;\n    case \"file\":\n      return components?.File ?? components?.Attachment;\n    default:\n      return components?.Attachment;\n  }\n};\n\nconst AttachmentComponent: FC<{\n  components: ComposerAttachmentsComponentConfig | undefined;\n}> = ({ components }) => {\n  const attachment = useAuiState((s) => s.attachment);\n  if (!attachment) return null;\n\n  const Component = getComponent(components, attachment);\n  if (!Component) return null;\n  return <Component />;\n};\n\nexport namespace ComposerPrimitiveAttachmentByIndex {\n  export type Props = {\n    index: number;\n    components?: ComposerAttachmentsComponentConfig;\n  };\n}\n\n/**\n * Renders a single attachment at the specified index within the composer.\n */\nexport const ComposerPrimitiveAttachmentByIndex: FC<ComposerPrimitiveAttachmentByIndex.Props> =\n  memo(\n    ({ index, components }) => {\n      return (\n        <ComposerAttachmentByIndexProvider index={index}>\n          <AttachmentComponent components={components} />\n        </ComposerAttachmentByIndexProvider>\n      );\n    },\n    (prev, next) =>\n      prev.index === next.index &&\n      prev.components?.Image === next.components?.Image &&\n      prev.components?.Document === next.components?.Document &&\n      prev.components?.File === next.components?.File &&\n      prev.components?.Attachment === next.components?.Attachment,\n  );\n\nComposerPrimitiveAttachmentByIndex.displayName =\n  \"ComposerPrimitive.AttachmentByIndex\";\n\nconst ComposerPrimitiveAttachmentsInner: FC<{\n  children: (value: { attachment: Attachment }) => ReactNode;\n}> = ({ children }) => {\n  const attachmentsCount = useAuiState((s) => s.composer.attachments.length);\n\n  return useMemo(\n    () =>\n      Array.from({ length: attachmentsCount }, (_, index) => (\n        <ComposerAttachmentByIndexProvider key={index} index={index}>\n          <RenderChildrenWithAccessor\n            getItemState={(aui) =>\n              aui.composer.attachment({ index }).getState()\n            }\n          >\n            {(getItem) =>\n              children({\n                get attachment() {\n                  return getItem();\n                },\n              })\n            }\n          </RenderChildrenWithAccessor>\n        </ComposerAttachmentByIndexProvider>\n      )),\n    [attachmentsCount, children],\n  );\n};\n\nexport const ComposerPrimitiveAttachments: FC<\n  ComposerPrimitiveAttachments.Props\n> = ({ components, children }) => {\n  if (components) {\n    return (\n      <ComposerPrimitiveAttachmentsInner>\n        {({ attachment }) => {\n          const Component = getComponent(components, attachment);\n          if (!Component) return null;\n          return <Component />;\n        }}\n      </ComposerPrimitiveAttachmentsInner>\n    );\n  }\n  return (\n    <ComposerPrimitiveAttachmentsInner>\n      {children}\n    </ComposerPrimitiveAttachmentsInner>\n  );\n};\n\nComposerPrimitiveAttachments.displayName = \"ComposerPrimitive.Attachments\";\n"],"mappings":"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"}
+{"version":3,"file":"ComposerAttachments.js","names":["Attachment","ComponentType","FC","ReactNode","memo","useMemo","RenderChildrenWithAccessor","useAuiState","useShallowSelector","ComposerAttachmentByIndexProvider","ComposerAttachmentsComponentConfig","Image","Document","File","ComposerPrimitiveAttachments","Props","components","children","value","attachment","getComponent","type","AttachmentComponent","t0","$","_c","_temp","t1","Component","t2","ComposerPrimitiveAttachmentByIndex","index","prev","next","displayName","ComposerPrimitiveAttachmentsInner","attachmentIds","s","composer","attachments","map","id","attachmentId","aui","getState","getItem"],"sources":["../../../../src/react/primitives/composer/ComposerAttachments.tsx"],"sourcesContent":["import type { Attachment } from \"../../../types/attachment\";\nimport {\n  type ComponentType,\n  type FC,\n  type ReactNode,\n  memo,\n  useMemo,\n} from \"react\";\nimport { RenderChildrenWithAccessor, useAuiState } from \"@assistant-ui/store\";\nimport { useShallowSelector } from \"@assistant-ui/store/internal\";\nimport { ComposerAttachmentByIndexProvider } from \"../../providers/AttachmentByIndexProvider\";\n\ntype ComposerAttachmentsComponentConfig = {\n  Image?: ComponentType | undefined;\n  Document?: ComponentType | undefined;\n  File?: ComponentType | undefined;\n  Attachment?: ComponentType | undefined;\n};\n\nexport namespace ComposerPrimitiveAttachments {\n  export type Props =\n    | {\n        /** @deprecated Use the children render function instead. */\n        components: ComposerAttachmentsComponentConfig;\n        children?: never;\n      }\n    | {\n        /** Render function called for each attachment. Receives the attachment. */\n        children: (value: { attachment: Attachment }) => ReactNode;\n        components?: never;\n      };\n}\n\nconst getComponent = (\n  components: ComposerAttachmentsComponentConfig | undefined,\n  attachment: Attachment,\n) => {\n  const type = attachment.type;\n  switch (type) {\n    case \"image\":\n      return components?.Image ?? components?.Attachment;\n    case \"document\":\n      return components?.Document ?? components?.Attachment;\n    case \"file\":\n      return components?.File ?? components?.Attachment;\n    default:\n      return components?.Attachment;\n  }\n};\n\nconst AttachmentComponent: FC<{\n  components: ComposerAttachmentsComponentConfig | undefined;\n}> = ({ components }) => {\n  const attachment = useAuiState((s) => s.attachment);\n  if (!attachment) return null;\n\n  const Component = getComponent(components, attachment);\n  if (!Component) return null;\n  return <Component />;\n};\n\nexport namespace ComposerPrimitiveAttachmentByIndex {\n  export type Props = {\n    index: number;\n    components?: ComposerAttachmentsComponentConfig;\n  };\n}\n\n/**\n * Renders a single attachment at the specified index within the composer.\n */\nexport const ComposerPrimitiveAttachmentByIndex: FC<ComposerPrimitiveAttachmentByIndex.Props> =\n  memo(\n    ({ index, components }) => {\n      return (\n        <ComposerAttachmentByIndexProvider index={index}>\n          <AttachmentComponent components={components} />\n        </ComposerAttachmentByIndexProvider>\n      );\n    },\n    (prev, next) =>\n      prev.index === next.index &&\n      prev.components?.Image === next.components?.Image &&\n      prev.components?.Document === next.components?.Document &&\n      prev.components?.File === next.components?.File &&\n      prev.components?.Attachment === next.components?.Attachment,\n  );\n\nComposerPrimitiveAttachmentByIndex.displayName =\n  \"ComposerPrimitive.AttachmentByIndex\";\n\nconst ComposerPrimitiveAttachmentsInner: FC<{\n  children: (value: { attachment: Attachment }) => ReactNode;\n}> = ({ children }) => {\n  const attachmentIds = useAuiState(\n    useShallowSelector((s) =>\n      s.composer.attachments.map((attachment) => attachment.id),\n    ),\n  );\n\n  return useMemo(\n    () =>\n      attachmentIds.map((attachmentId, index) => (\n        <ComposerAttachmentByIndexProvider key={attachmentId} index={index}>\n          <RenderChildrenWithAccessor\n            getItemState={(aui) =>\n              aui.composer.attachment({ index }).getState()\n            }\n          >\n            {(getItem) =>\n              children({\n                get attachment() {\n                  return getItem();\n                },\n              })\n            }\n          </RenderChildrenWithAccessor>\n        </ComposerAttachmentByIndexProvider>\n      )),\n    [attachmentIds, children],\n  );\n};\n\nexport const ComposerPrimitiveAttachments: FC<\n  ComposerPrimitiveAttachments.Props\n> = ({ components, children }) => {\n  if (components) {\n    return (\n      <ComposerPrimitiveAttachmentsInner>\n        {({ attachment }) => {\n          const Component = getComponent(components, attachment);\n          if (!Component) return null;\n          return <Component />;\n        }}\n      </ComposerPrimitiveAttachmentsInner>\n    );\n  }\n  return (\n    <ComposerPrimitiveAttachmentsInner>\n      {children}\n    </ComposerPrimitiveAttachmentsInner>\n  );\n};\n\nComposerPrimitiveAttachments.displayName = \"ComposerPrimitive.Attachments\";\n"],"mappings":";;;;;;;AAiCA,MAAMoB,gBACJJ,YACAG,eACG;CAEH,QADaA,WAAWE,MACxB;EACE,KAAK,SACH,OAAOL,YAAYL,SAASK,YAAYhB;EAC1C,KAAK,YACH,OAAOgB,YAAYJ,YAAYI,YAAYhB;EAC7C,KAAK,QACH,OAAOgB,YAAYH,QAAQG,YAAYhB;EACzC,SACE,OAAOgB,YAAYhB;CACvB;AACF;AAEA,MAAMsB,uBAEDC,OAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CAAC,MAAA,EAAAT,eAAAO;CACJ,MAAAJ,aAAmBZ,YAAYmB,KAAmB;CAClD,IAAI,CAACP,YAAU,OAAS;CAAK,IAAAQ;CAAA,IAAAH,EAAA,OAAAL,cAAAK,EAAA,OAAAR,YAAA;EAEXW,KAAAP,aAAaJ,YAAYG,UAAU;EAACK,EAAA,KAAAL;EAAAK,EAAA,KAAAR;EAAAQ,EAAA,KAAAG;CAAA,OAAAA,KAAAH,EAAA;CAAtD,MAAAI,YAAkBD;CAClB,IAAI,CAACC,WAAS,OAAS;CAAK,IAAAC;CAAA,IAAAL,EAAA,OAAAI,WAAA;EACrBC,KAAA,oBAAC,WAAD,CAAU,CAAA;EAAGL,EAAA,KAAAI;EAAAJ,EAAA,KAAAK;CAAA,OAAAA,KAAAL,EAAA;CAAA,OAAbK;AAAa;;;;AAatB,MAAaC,qCACX1B,MACEmB,OAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CAAC,MAAA,EAAAM,OAAAf,eAAAO;CAAqB,IAAAI;CAAA,IAAAH,EAAA,OAAAR,YAAA;EAGhBW,KAAA,oBAAC,qBAAD,EAAiCX,WAAU,CAAA;EAAIQ,EAAA,KAAAR;EAAAQ,EAAA,KAAAG;CAAA,OAAAA,KAAAH,EAAA;CAAA,IAAAK;CAAA,IAAAL,EAAA,OAAAO,SAAAP,EAAA,OAAAG,IAAA;EADjDE,KAAA,oBAAC,mCAAD;GAA0CE;GACxCJ,UAAAA;EADgC,CAAA;EAEEH,EAAA,KAAAO;EAAAP,EAAA,KAAAG;EAAAH,EAAA,KAAAK;CAAA,OAAAA,KAAAL,EAAA;CAAA,OAFpCK;AAEoC,IAGvCG,MAAMC,SACLD,KAAKD,UAAUE,KAAKF,SACpBC,KAAKhB,YAAYL,UAAUsB,KAAKjB,YAAYL,SAC5CqB,KAAKhB,YAAYJ,aAAaqB,KAAKjB,YAAYJ,YAC/CoB,KAAKhB,YAAYH,SAASoB,KAAKjB,YAAYH,QAC3CmB,KAAKhB,YAAYhB,eAAeiC,KAAKjB,YAAYhB,UACrD;AAEF8B,mCAAmCI,cACjC;AAEF,MAAMC,qCAEA,EAAElB,eAAe;CACrB,MAAMmB,gBAAgB7B,YACpBC,oBAAoB6B,MAClBA,EAAEC,SAASC,YAAYC,KAAKrB,eAAeA,WAAWsB,EAAE,CAC1D,CACF;CAEA,OAAOpC,cAEH+B,cAAcI,KAAKE,cAAcX,UAC/B,oBAAC,mCAAD;EAA6DA;EAC3D,UAAA,oBAAC,4BAAD;GACE,eAAeY,QACbA,IAAIL,SAASnB,WAAW,EAAEY,MAAM,CAAC,CAAC,CAACa,SAAS;GAG5CC,WAAAA,YACA5B,SAAS,EACP,IAAIE,aAAa;IACf,OAAO0B,QAAQ;GACjB,EACF,CAAC;EAEuB,CAAA;CACK,GAdKH,YAcL,CACpC,GACH,CAACN,eAAenB,QAAQ,CAC1B;AACF;AAEA,MAAaH,gCAETS,OAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CAAC,MAAA,EAAAT,YAAAC,aAAAM;CACH,IAAIP,YAAU;EAAA,IAAAW;EAAA,IAAAH,EAAA,OAAAR,YAAA;GAEVW,KAAA,oBAAC,mCAAD,EAAA,WACGE,OAAA;IAAC,MAAA,EAAAV,eAAAU;IACA,MAAAD,YAAkBR,aAAaJ,YAAYG,UAAU;IACrD,IAAI,CAACS,WAAS,OAAS;IAAK,OACrB,oBAAC,WAAD,CAAU,CAAA;GAAG,EAJU,CAAA;GAMEJ,EAAA,KAAAR;GAAAQ,EAAA,KAAAG;EAAA,OAAAA,KAAAH,EAAA;EAAA,OANpCG;CAMoC;CAEvC,IAAAA;CAAA,IAAAH,EAAA,OAAAP,UAAA;EAECU,KAAA,oBAAC,mCAAD,EACGV,SAD+B,CAAA;EAEEO,EAAA,KAAAP;EAAAO,EAAA,KAAAG;CAAA,OAAAA,KAAAH,EAAA;CAAA,OAFpCG;AAEoC;AAIxCb,6BAA6BoB,cAAc;AA5FtC,SAAAR,MAAAW,GAAA;CAAA,OACmCA,EAAClB;AAAW"}