@assistant-ui/core 0.2.14 → 0.2.15

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

@@ -1 +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"}
+{"version":3,"file":"human-tool.js","names":["humanTool","Error","hitlTool","hitl"],"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,SAAgBA,YAAmB;CACjC,MAAM,IAAIC,MACR,sQAIF;AACF;;;;AAKA,MAAaC,WAAWF;;;;AAKxB,MAAaG,OAAOH"}

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

@@ -1 +1 @@
-{"version":3,"file":"makeAssistantDataUI.js","names":[],"sources":["../../../src/react/model-context/makeAssistantDataUI.ts"],"sourcesContent":["import type { FC } from \"react\";\nimport {\n  type AssistantDataUIProps,\n  useAssistantDataUI,\n} from \"./useAssistantDataUI\";\n\n/**\n * Component returned by {@link makeAssistantDataUI}.\n *\n * Rendering the component registers a renderer for matching `data` message\n * parts.\n */\nexport type AssistantDataUI = FC & {\n  /** Data renderer registered by this component. */\n  unstable_data: AssistantDataUIProps;\n};\n\n/**\n * Creates a React component that registers a named data-part renderer when\n * rendered.\n *\n * @param dataUI - Data renderer registration.\n */\nexport const makeAssistantDataUI = <T = any>(\n  dataUI: AssistantDataUIProps<T>,\n) => {\n  const DataUI: AssistantDataUI = () => {\n    useAssistantDataUI(dataUI);\n    return null;\n  };\n  DataUI.unstable_data = dataUI;\n  return DataUI;\n};\n"],"mappings":";;;;;;;;AAuBA,MAAa,uBACX,WACG;CACH,MAAM,eAAgC;EACpC,mBAAmB,MAAM;EACzB,OAAO;CACT;CACA,OAAO,gBAAgB;CACvB,OAAO;AACT"}
+{"version":3,"file":"makeAssistantDataUI.js","names":["FC","AssistantDataUIProps","useAssistantDataUI","AssistantDataUI","unstable_data","makeAssistantDataUI","dataUI","T","DataUI"],"sources":["../../../src/react/model-context/makeAssistantDataUI.ts"],"sourcesContent":["import type { FC } from \"react\";\nimport {\n  type AssistantDataUIProps,\n  useAssistantDataUI,\n} from \"./useAssistantDataUI\";\n\n/**\n * Component returned by {@link makeAssistantDataUI}.\n *\n * Rendering the component registers a renderer for matching `data` message\n * parts.\n */\nexport type AssistantDataUI = FC & {\n  /** Data renderer registered by this component. */\n  unstable_data: AssistantDataUIProps;\n};\n\n/**\n * Creates a React component that registers a named data-part renderer when\n * rendered.\n *\n * @param dataUI - Data renderer registration.\n */\nexport const makeAssistantDataUI = <T = any>(\n  dataUI: AssistantDataUIProps<T>,\n) => {\n  const DataUI: AssistantDataUI = () => {\n    useAssistantDataUI(dataUI);\n    return null;\n  };\n  DataUI.unstable_data = dataUI;\n  return DataUI;\n};\n"],"mappings":";;;;;;;;AAuBA,MAAaK,uBACXC,WACG;CACH,MAAME,eAA0B;EAC9BN,mBAAmBI,MAAM;EAAC,OACnB;CAAI;CAEbE,OAAOJ,gBAAgBE;CACvB,OAAOE;AACT"}

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 *\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"}
+{"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"}

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 *\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"}
+{"version":3,"file":"makeAssistantToolUI.js","names":["FC","AssistantToolUIProps","useAssistantToolUI","AssistantToolUI","unstable_tool","makeAssistantToolUI","tool","TArgs","TResult","ToolUI"],"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,MAAaK,uBACXC,SACG;CACH,MAAMG,eAA0B;EAC9BP,mBAAmBI,IAAI;EAAC,OACjB;CAAI;CAEbG,OAAOL,gBAAgBE;CACvB,OAAOG;AACT"}

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

@@ -1 +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"}
+{"version":3,"file":"provider-tool.js","names":["Tool","ProviderToolDefinition","Record","Extract","TArgs","type","ProviderToolConfig","Pick","providerTool","_config","Error"],"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,SAAgBQ,aAAaC,SAAoC;CAC/D,MAAM,IAAIC,MACR,4QAIF;AACF"}

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

@@ -1 +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"}
+{"version":3,"file":"stub-tool.js","names":["stubTool","Error"],"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,SAAgBA,WAAkB;CAChC,MAAM,IAAIC,MACR,iMAGF;AACF"}

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 {\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"}
+{"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): 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,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,SACiD;CACjD,OAAO,SAASM,sBAAsBL,MAAM;EAC1C,OAAOF,oBAAoBC,MAAMC,IAAI;CACvC;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"useAssistantContext.js","names":[],"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,MAAa,uBAAuB,WAAmC;CACrE,MAAM,EAAE,YAAY,WAAW,UAAU;CACzC,MAAM,MAAM,OAAO;CACnB,MAAM,gBAAgB,OAAO,UAAU;CACvC,cAAc,UAAU;CAExB,gBAAgB;EACd,IAAI,UAAU;EAEd,OAAO,IAAI,aAAa,CAAC,CAAC,SAAS,EACjC,wBAAwB,EACtB,QAAQ,cAAc,QAAQ,EAChC,GACF,CAAC;CACH,GAAG,CAAC,KAAK,QAAQ,CAAC;AACpB"}
+{"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,aAAa,CAAC,CAACC,SAAS,EACjCC,wBAAwB,EACtBC,QAAQL,cAAcC,QAAQ,EAChC,GACF,CAAC;CACH,GAAG,CAACF,KAAKD,QAAQ,CAAC;AACpB"}

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

@@ -1,5 +1,6 @@
 import { useEffect } from "@assistant-ui/tap/react-shim";
 import { useAui } from "@assistant-ui/store";
+import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
 //#region src/react/model-context/useAssistantDataUI.ts
 /**
 * Registers a renderer for named `data` message parts while the component is
@@ -8,15 +9,33 @@ import { useAui } from "@assistant-ui/store";
 * @param dataUI - Data renderer registration, or `null` to skip registration.
 */
 const useAssistantDataUI = (dataUI) => {
+	const $ = c(7);
 	const aui = useAui();
-	useEffect(() => {
-		if (!dataUI?.name || !dataUI?.render) return void 0;
-		return aui.dataRenderers().setDataUI(dataUI.name, dataUI.render);
-	}, [
-		aui,
-		dataUI?.name,
-		dataUI?.render
-	]);
+	let t0;
+	if ($[0] !== aui || $[1] !== dataUI) {
+		t0 = () => {
+			if (!dataUI?.name || !dataUI?.render) return;
+			return aui.dataRenderers().setDataUI(dataUI.name, dataUI.render);
+		};
+		$[0] = aui;
+		$[1] = dataUI;
+		$[2] = t0;
+	} else t0 = $[2];
+	const t1 = dataUI?.name;
+	const t2 = dataUI?.render;
+	let t3;
+	if ($[3] !== aui || $[4] !== t1 || $[5] !== t2) {
+		t3 = [
+			aui,
+			t1,
+			t2
+		];
+		$[3] = aui;
+		$[4] = t1;
+		$[5] = t2;
+		$[6] = t3;
+	} else t3 = $[6];
+	useEffect(t0, t3);
 };
 //#endregion
 export { useAssistantDataUI };

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

@@ -1 +1 @@
-{"version":3,"file":"useAssistantDataUI.js","names":[],"sources":["../../../src/react/model-context/useAssistantDataUI.ts"],"sourcesContent":["import { useEffect } from \"react\";\nimport { useAui } from \"@assistant-ui/store\";\nimport type { DataMessagePartComponent } from \"../types/MessagePartComponentTypes\";\n\n/** Props used to register a renderer for `data` message parts. */\nexport type AssistantDataUIProps<T = any> = {\n  /** Data part name this renderer handles. */\n  name: string;\n  /** Component rendered for matching data message parts. */\n  render: DataMessagePartComponent<T>;\n};\n\n/**\n * Registers a renderer for named `data` message parts while the component is\n * mounted.\n *\n * @param dataUI - Data renderer registration, or `null` to skip registration.\n */\nexport const useAssistantDataUI = (dataUI: AssistantDataUIProps | null) => {\n  const aui = useAui();\n  useEffect(() => {\n    if (!dataUI?.name || !dataUI?.render) return undefined;\n    return aui.dataRenderers().setDataUI(dataUI.name, dataUI.render);\n  }, [aui, dataUI?.name, dataUI?.render]);\n};\n"],"mappings":";;;;;;;;;AAkBA,MAAa,sBAAsB,WAAwC;CACzE,MAAM,MAAM,OAAO;CACnB,gBAAgB;EACd,IAAI,CAAC,QAAQ,QAAQ,CAAC,QAAQ,QAAQ,OAAO,KAAA;EAC7C,OAAO,IAAI,cAAc,CAAC,CAAC,UAAU,OAAO,MAAM,OAAO,MAAM;CACjE,GAAG;EAAC;EAAK,QAAQ;EAAM,QAAQ;CAAM,CAAC;AACxC"}
+{"version":3,"file":"useAssistantDataUI.js","names":["useEffect","useAui","DataMessagePartComponent","AssistantDataUIProps","name","render","T","useAssistantDataUI","dataUI","$","_c","aui","t0","dataRenderers","setDataUI","t1","t2","t3"],"sources":["../../../src/react/model-context/useAssistantDataUI.ts"],"sourcesContent":["import { useEffect } from \"react\";\nimport { useAui } from \"@assistant-ui/store\";\nimport type { DataMessagePartComponent } from \"../types/MessagePartComponentTypes\";\n\n/** Props used to register a renderer for `data` message parts. */\nexport type AssistantDataUIProps<T = any> = {\n  /** Data part name this renderer handles. */\n  name: string;\n  /** Component rendered for matching data message parts. */\n  render: DataMessagePartComponent<T>;\n};\n\n/**\n * Registers a renderer for named `data` message parts while the component is\n * mounted.\n *\n * @param dataUI - Data renderer registration, or `null` to skip registration.\n */\nexport const useAssistantDataUI = (dataUI: AssistantDataUIProps | null) => {\n  const aui = useAui();\n  useEffect(() => {\n    if (!dataUI?.name || !dataUI?.render) return undefined;\n    return aui.dataRenderers().setDataUI(dataUI.name, dataUI.render);\n  }, [aui, dataUI?.name, dataUI?.render]);\n};\n"],"mappings":";;;;;;;;;;AAkBA,MAAaO,sBAAqBC,WAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CAChC,MAAAC,MAAYV,OAAO;CAAE,IAAAW;CAAA,IAAAH,EAAA,OAAAE,OAAAF,EAAA,OAAAD,QAAA;EACXI,WAAA;GACR,IAAI,CAACJ,QAAMJ,QAAP,CAAkBI,QAAMH,QAAQ;GAAmB,OAChDM,IAAGE,cAAe,CAAC,CAAAC,UAAWN,OAAMJ,MAAOI,OAAMH,MAAO;EAAC;EACjEI,EAAA,KAAAE;EAAAF,EAAA,KAAAD;EAAAC,EAAA,KAAAG;CAAA,OAAAA,KAAAH,EAAA;CAAQ,MAAAM,KAAAP,QAAMJ;CAAQ,MAAAY,KAAAR,QAAMH;CAAQ,IAAAY;CAAA,IAAAR,EAAA,OAAAE,OAAAF,EAAA,OAAAM,MAAAN,EAAA,OAAAO,IAAA;EAAlCC,KAAA;GAACN;GAAKI;GAAcC;EAAc;EAACP,EAAA,KAAAE;EAAAF,EAAA,KAAAM;EAAAN,EAAA,KAAAO;EAAAP,EAAA,KAAAQ;CAAA,OAAAA,KAAAR,EAAA;CAHtCT,UAAUY,IAGPK,EAAmC;AAAC"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"useAssistantInstructions.js","names":[],"sources":["../../../src/react/model-context/useAssistantInstructions.ts"],"sourcesContent":["import { useEffect } from \"react\";\nimport { useAui } from \"@assistant-ui/store\";\nimport type { AssistantInstructionsConfig } from \"../..\";\n\nexport type { AssistantInstructionsConfig };\n\nconst getInstructions = (\n  instruction: string | AssistantInstructionsConfig,\n): AssistantInstructionsConfig => {\n  if (typeof instruction === \"string\") return { instruction };\n  return instruction;\n};\n\nexport const useAssistantInstructions = (\n  config: string | AssistantInstructionsConfig,\n) => {\n  const { instruction, disabled = false } = getInstructions(config);\n  const aui = useAui();\n\n  useEffect(() => {\n    if (disabled) return;\n\n    const config = {\n      system: instruction,\n    };\n    return aui.modelContext().register({\n      getModelContext: () => config,\n    });\n  }, [aui, instruction, disabled]);\n};\n"],"mappings":";;;AAMA,MAAM,mBACJ,gBACgC;CAChC,IAAI,OAAO,gBAAgB,UAAU,OAAO,EAAE,YAAY;CAC1D,OAAO;AACT;AAEA,MAAa,4BACX,WACG;CACH,MAAM,EAAE,aAAa,WAAW,UAAU,gBAAgB,MAAM;CAChE,MAAM,MAAM,OAAO;CAEnB,gBAAgB;EACd,IAAI,UAAU;EAEd,MAAM,SAAS,EACb,QAAQ,YACV;EACA,OAAO,IAAI,aAAa,CAAC,CAAC,SAAS,EACjC,uBAAuB,OACzB,CAAC;CACH,GAAG;EAAC;EAAK;EAAa;CAAQ,CAAC;AACjC"}
+{"version":3,"file":"useAssistantInstructions.js","names":["useEffect","useAui","AssistantInstructionsConfig","getInstructions","instruction","useAssistantInstructions","config","$","_c","t0","disabled","t1","undefined","aui","t2","t3","config_0","system","modelContext","register","getModelContext"],"sources":["../../../src/react/model-context/useAssistantInstructions.ts"],"sourcesContent":["import { useEffect } from \"react\";\nimport { useAui } from \"@assistant-ui/store\";\nimport type { AssistantInstructionsConfig } from \"../..\";\n\nexport type { AssistantInstructionsConfig };\n\nconst getInstructions = (\n  instruction: string | AssistantInstructionsConfig,\n): AssistantInstructionsConfig => {\n  if (typeof instruction === \"string\") return { instruction };\n  return instruction;\n};\n\nexport const useAssistantInstructions = (\n  config: string | AssistantInstructionsConfig,\n) => {\n  const { instruction, disabled = false } = getInstructions(config);\n  const aui = useAui();\n\n  useEffect(() => {\n    if (disabled) return;\n\n    const config = {\n      system: instruction,\n    };\n    return aui.modelContext().register({\n      getModelContext: () => config,\n    });\n  }, [aui, instruction, disabled]);\n};\n"],"mappings":";;;;AAMA,MAAMG,mBACJC,gBACgC;CAChC,IAAI,OAAOA,gBAAgB,UAAU,OAAO,EAAEA,YAAY;CAC1D,OAAOA;AACT;AAEA,MAAaC,4BAA2BC,WAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CAAA,IAAAC;CAAA,IAAAF,EAAA,OAAAD,QAAA;EAGIG,KAAAN,gBAAgBG,MAAM;EAACC,EAAA,KAAAD;EAAAC,EAAA,KAAAE;CAAA,OAAAA,KAAAF,EAAA;CAAjE,MAAA,EAAAH,aAAAM,UAAAC,OAA0CF;CAArB,MAAAC,WAAAC,OAAAC,KAAAA,IAAA,QAAAD;CACrB,MAAAE,MAAYZ,OAAO;CAAE,IAAAa;CAAA,IAAAC;CAAA,IAAAR,EAAA,OAAAM,OAAAN,EAAA,OAAAG,YAAAH,EAAA,OAAAH,aAAA;EAEXU,WAAA;GACR,IAAIJ,UAAQ;GAEZ,MAAAM,WAAe,EAAAC,QACLb,YACV;GAAE,OACKS,IAAGK,aAAc,CAAC,CAAAC,SAAU,EAAAC,uBACVd,SACzB,CAAC;EAAC;EACDS,KAAA;GAACF;GAAKT;GAAaM;EAAQ;EAACH,EAAA,KAAAM;EAAAN,EAAA,KAAAG;EAAAH,EAAA,KAAAH;EAAAG,EAAA,KAAAO;EAAAP,EAAA,KAAAQ;CAAA,OAAA;EAAAD,KAAAP,EAAA;EAAAQ,KAAAR,EAAA;CAAA;CAT/BP,UAAUc,IASPC,EAA4B;AAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"useAssistantInteractable.js","names":[],"sources":["../../../src/react/model-context/useAssistantInteractable.ts"],"sourcesContent":["import { useEffect, useId, useRef } from \"react\";\nimport { useAui } from \"@assistant-ui/store\";\nimport type { InteractableStateSchema } from \"../types/scopes/interactables\";\n\nexport type AssistantInteractableProps = {\n  description: string;\n  stateSchema: InteractableStateSchema;\n  initialState: unknown;\n  id?: string;\n  selected?: boolean;\n};\n\n/**\n * Registers an interactable with the AI assistant.\n *\n * This hook handles registration only. To read and write the interactable's\n * state, use {@link useInteractableState} with the returned id.\n *\n * @returns The interactable instance id.\n */\nexport const useAssistantInteractable = (\n  name: string,\n  config: AssistantInteractableProps,\n): string => {\n  const aui = useAui();\n\n  const autoId = useId().replace(/[^a-zA-Z0-9]/g, \"\");\n  const id = config.id ?? autoId;\n\n  const stateSchemaRef = useRef(config.stateSchema);\n  stateSchemaRef.current = config.stateSchema;\n  const initialStateRef = useRef(config.initialState);\n  initialStateRef.current = config.initialState;\n\n  useEffect(() => {\n    return aui.interactables().register({\n      id,\n      name,\n      description: config.description,\n      stateSchema: stateSchemaRef.current,\n      initialState: initialStateRef.current,\n      selected: config.selected,\n    });\n  }, [aui, id, name, config.description, config.selected]);\n\n  return id;\n};\n"],"mappings":";;;;;;;;;;;AAoBA,MAAa,4BACX,MACA,WACW;CACX,MAAM,MAAM,OAAO;CAEnB,MAAM,SAAS,MAAM,CAAC,CAAC,QAAQ,iBAAiB,EAAE;CAClD,MAAM,KAAK,OAAO,MAAM;CAExB,MAAM,iBAAiB,OAAO,OAAO,WAAW;CAChD,eAAe,UAAU,OAAO;CAChC,MAAM,kBAAkB,OAAO,OAAO,YAAY;CAClD,gBAAgB,UAAU,OAAO;CAEjC,gBAAgB;EACd,OAAO,IAAI,cAAc,CAAC,CAAC,SAAS;GAClC;GACA;GACA,aAAa,OAAO;GACpB,aAAa,eAAe;GAC5B,cAAc,gBAAgB;GAC9B,UAAU,OAAO;EACnB,CAAC;CACH,GAAG;EAAC;EAAK;EAAI;EAAM,OAAO;EAAa,OAAO;CAAQ,CAAC;CAEvD,OAAO;AACT"}
+{"version":3,"file":"useAssistantInteractable.js","names":["useEffect","useId","useRef","useAui","InteractableStateSchema","AssistantInteractableProps","description","stateSchema","initialState","id","selected","useAssistantInteractable","name","config","aui","autoId","replace","stateSchemaRef","current","initialStateRef","interactables","register"],"sources":["../../../src/react/model-context/useAssistantInteractable.ts"],"sourcesContent":["import { useEffect, useId, useRef } from \"react\";\nimport { useAui } from \"@assistant-ui/store\";\nimport type { InteractableStateSchema } from \"../types/scopes/interactables\";\n\nexport type AssistantInteractableProps = {\n  description: string;\n  stateSchema: InteractableStateSchema;\n  initialState: unknown;\n  id?: string;\n  selected?: boolean;\n};\n\n/**\n * Registers an interactable with the AI assistant.\n *\n * This hook handles registration only. To read and write the interactable's\n * state, use {@link useInteractableState} with the returned id.\n *\n * @returns The interactable instance id.\n */\nexport const useAssistantInteractable = (\n  name: string,\n  config: AssistantInteractableProps,\n): string => {\n  const aui = useAui();\n\n  const autoId = useId().replace(/[^a-zA-Z0-9]/g, \"\");\n  const id = config.id ?? autoId;\n\n  const stateSchemaRef = useRef(config.stateSchema);\n  stateSchemaRef.current = config.stateSchema;\n  const initialStateRef = useRef(config.initialState);\n  initialStateRef.current = config.initialState;\n\n  useEffect(() => {\n    return aui.interactables().register({\n      id,\n      name,\n      description: config.description,\n      stateSchema: stateSchemaRef.current,\n      initialState: initialStateRef.current,\n      selected: config.selected,\n    });\n  }, [aui, id, name, config.description, config.selected]);\n\n  return id;\n};\n"],"mappings":";;;;;;;;;;;AAoBA,MAAaW,4BACXC,MACAC,WACW;CACX,MAAMC,MAAMX,OAAO;CAEnB,MAAMY,SAASd,MAAM,CAAC,CAACe,QAAQ,iBAAiB,EAAE;CAClD,MAAMP,KAAKI,OAAOJ,MAAMM;CAExB,MAAME,iBAAiBf,OAAOW,OAAON,WAAW;CAChDU,eAAeC,UAAUL,OAAON;CAChC,MAAMY,kBAAkBjB,OAAOW,OAAOL,YAAY;CAClDW,gBAAgBD,UAAUL,OAAOL;CAEjCR,gBAAgB;EACd,OAAOc,IAAIM,cAAc,CAAC,CAACC,SAAS;GAClCZ;GACAG;GACAN,aAAaO,OAAOP;GACpBC,aAAaU,eAAeC;GAC5BV,cAAcW,gBAAgBD;GAC9BR,UAAUG,OAAOH;EACnB,CAAC;CACH,GAAG;EAACI;EAAKL;EAAIG;EAAMC,OAAOP;EAAaO,OAAOH;CAAQ,CAAC;CAEvD,OAAOD;AACT"}

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

@@ -1,6 +1,7 @@
 import { isStandaloneToolDisplay, makeToolCallTextComponent } from "./toolbox.js";
-import { useEffect, useMemo } from "@assistant-ui/tap/react-shim";
+import { useEffect } from "@assistant-ui/tap/react-shim";
 import { useAui } from "@assistant-ui/store";
+import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
 //#region src/react/model-context/useAssistantTool.ts
 /**
 * Registers a tool with the assistant model context while the component is
@@ -37,24 +38,65 @@ import { useAui } from "@assistant-ui/store";
 * ```
 */
 const useAssistantTool = (tool) => {
+	const $ = c(14);
 	const aui = useAui();
-	const standalone = isStandaloneToolDisplay(tool);
-	const renderTextComponent = useMemo(() => tool.renderText ? makeToolCallTextComponent(tool.renderText) : void 0, [tool.renderText]);
+	let t0;
+	if ($[0] !== tool) {
+		t0 = isStandaloneToolDisplay(tool);
+		$[0] = tool;
+		$[1] = t0;
+	} else t0 = $[1];
+	const standalone = t0;
+	let t1;
+	if ($[2] !== tool.renderText) {
+		t1 = tool.renderText ? makeToolCallTextComponent(tool.renderText) : void 0;
+		$[2] = tool.renderText;
+		$[3] = t1;
+	} else t1 = $[3];
+	const renderTextComponent = t1;
 	const render = tool.render ?? renderTextComponent;
-	useEffect(() => {
-		if (!render) return void 0;
-		return aui.tools().setToolUI(tool.toolName, render, { standalone });
-	}, [
-		aui,
-		tool.toolName,
-		render,
-		standalone
-	]);
-	useEffect(() => {
-		const { toolName, render, renderText, display, ...rest } = tool;
-		const context = { tools: { [toolName]: rest } };
-		return aui.modelContext().register({ getModelContext: () => context });
-	}, [aui, tool]);
+	let t2;
+	let t3;
+	if ($[4] !== aui || $[5] !== render || $[6] !== standalone || $[7] !== tool.toolName) {
+		t2 = () => {
+			if (!render) return;
+			return aui.tools().setToolUI(tool.toolName, render, { standalone });
+		};
+		t3 = [
+			aui,
+			tool.toolName,
+			render,
+			standalone
+		];
+		$[4] = aui;
+		$[5] = render;
+		$[6] = standalone;
+		$[7] = tool.toolName;
+		$[8] = t2;
+		$[9] = t3;
+	} else {
+		t2 = $[8];
+		t3 = $[9];
+	}
+	useEffect(t2, t3);
+	let t4;
+	let t5;
+	if ($[10] !== aui || $[11] !== tool) {
+		t4 = () => {
+			const { toolName, render: render_0, renderText, display, ...rest } = tool;
+			const context = { tools: { [toolName]: rest } };
+			return aui.modelContext().register({ getModelContext: () => context });
+		};
+		t5 = [aui, tool];
+		$[10] = aui;
+		$[11] = tool;
+		$[12] = t4;
+		$[13] = t5;
+	} else {
+		t4 = $[12];
+		t5 = $[13];
+	}
+	useEffect(t4, t5);
 };
 //#endregion
 export { useAssistantTool };

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

@@ -1 +1 @@
-{"version":3,"file":"useAssistantTool.js","names":[],"sources":["../../../src/react/model-context/useAssistantTool.ts"],"sourcesContent":["import { useEffect, useMemo } from \"react\";\nimport { useAui } from \"@assistant-ui/store\";\nimport type { ToolCallMessagePartComponent } from \"../types/MessagePartComponentTypes\";\nimport type { AssistantToolProps as CoreAssistantToolProps } from \"../..\";\nimport {\n  isStandaloneToolDisplay,\n  makeToolCallTextComponent,\n  type ToolCallText,\n} from \"./toolbox\";\n\n/**\n * Props used to register a tool from React.\n *\n * @deprecated Use a toolkit with `Tools({ toolkit })` and register it via\n * `useAui({ tools: Tools({ toolkit }) })` instead. See\n * https://assistant-ui.com/docs/migrations/toolkit-tools.\n */\nexport type AssistantToolProps<\n  TArgs extends Record<string, unknown>,\n  TResult,\n> = CoreAssistantToolProps<TArgs, TResult> & {\n  /** Component used to render calls to this tool in assistant messages. */\n  render?: ToolCallMessagePartComponent<TArgs, TResult> | undefined;\n  /** Lightweight text rendered while a tool call is running or complete. */\n  renderText?: ToolCallText<TArgs, TResult> | undefined;\n};\n\n/**\n * Registers a tool with the assistant model context while the component is\n * mounted.\n *\n * If `render` is provided, it is also installed as the renderer for matching\n * tool-call message parts. The registration is removed automatically when the\n * component unmounts or the tool definition changes.\n *\n * Pass a referentially stable tool object, such as one declared at module\n * scope or memoized with `useMemo`, to avoid re-registering on every render.\n *\n * @param tool - Tool definition and name to register.\n *\n * @deprecated Use a toolkit with `Tools({ toolkit })` and register it via\n * `useAui({ tools: Tools({ toolkit }) })` instead. See\n * https://assistant-ui.com/docs/migrations/toolkit-tools.\n *\n * @example\n * ```tsx\n * const weatherTool = {\n *   toolName: \"get_weather\",\n *   type: \"frontend\",\n *   description: \"Get the weather for a city.\",\n *   parameters: weatherSchema,\n *   execute: async ({ city }: { city: string }) => fetchWeather(city),\n *   render: WeatherToolUI,\n * } satisfies AssistantToolProps<{ city: string }, Weather>;\n *\n * function WeatherToolRegistration() {\n *   useAssistantTool(weatherTool);\n *   return null;\n * }\n * ```\n */\nexport const useAssistantTool = <\n  TArgs extends Record<string, unknown>,\n  TResult,\n>(\n  tool: AssistantToolProps<TArgs, TResult>,\n) => {\n  const aui = useAui();\n\n  const standalone = isStandaloneToolDisplay(tool);\n  const renderTextComponent = useMemo(\n    () =>\n      tool.renderText ? makeToolCallTextComponent(tool.renderText) : undefined,\n    [tool.renderText],\n  );\n  const render = tool.render ?? renderTextComponent;\n\n  useEffect(() => {\n    if (!render) return undefined;\n    return aui.tools().setToolUI(tool.toolName, render, { standalone });\n  }, [aui, tool.toolName, render, standalone]);\n\n  useEffect(() => {\n    // `render`, `renderText`, and `display` are client-only presentation\n    // concerns and never reach the model.\n    const { toolName, render, renderText, display, ...rest } = tool;\n    const context = {\n      tools: {\n        [toolName]: rest,\n      },\n    };\n    return aui.modelContext().register({\n      getModelContext: () => context,\n    });\n  }, [aui, tool]);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6DA,MAAa,oBAIX,SACG;CACH,MAAM,MAAM,OAAO;CAEnB,MAAM,aAAa,wBAAwB,IAAI;CAC/C,MAAM,sBAAsB,cAExB,KAAK,aAAa,0BAA0B,KAAK,UAAU,IAAI,KAAA,GACjE,CAAC,KAAK,UAAU,CAClB;CACA,MAAM,SAAS,KAAK,UAAU;CAE9B,gBAAgB;EACd,IAAI,CAAC,QAAQ,OAAO,KAAA;EACpB,OAAO,IAAI,MAAM,CAAC,CAAC,UAAU,KAAK,UAAU,QAAQ,EAAE,WAAW,CAAC;CACpE,GAAG;EAAC;EAAK,KAAK;EAAU;EAAQ;CAAU,CAAC;CAE3C,gBAAgB;EAGd,MAAM,EAAE,UAAU,QAAQ,YAAY,SAAS,GAAG,SAAS;EAC3D,MAAM,UAAU,EACd,OAAO,GACJ,WAAW,KACd,EACF;EACA,OAAO,IAAI,aAAa,CAAC,CAAC,SAAS,EACjC,uBAAuB,QACzB,CAAC;CACH,GAAG,CAAC,KAAK,IAAI,CAAC;AAChB"}
+{"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","t3","toolName","tools","setToolUI","t4","t5","render_0","display","rest","context","modelContext","register","getModelContext"],"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,IAAAC;CAAA,IAAAT,EAAA,OAAAE,OAAAF,EAAA,OAAAJ,UAAAI,EAAA,OAAAI,cAAAJ,EAAA,OAAAD,KAAAW,UAAA;EAExCF,WAAA;GACR,IAAI,CAACZ,QAAM;GAAmB,OACvBM,IAAGS,MAAO,CAAC,CAAAC,UAAWb,KAAIW,UAAWd,QAAQ,EAAAQ,WAAa,CAAC;EAAC;EAClEK,KAAA;GAACP;GAAKH,KAAIW;GAAWd;GAAQQ;EAAU;EAACJ,EAAA,KAAAE;EAAAF,EAAA,KAAAJ;EAAAI,EAAA,KAAAI;EAAAJ,EAAA,KAAAD,KAAAW;EAAAV,EAAA,KAAAQ;EAAAR,EAAA,KAAAS;CAAA,OAAA;EAAAD,KAAAR,EAAA;EAAAS,KAAAT,EAAA;CAAA;CAH3ChB,UAAUwB,IAGPC,EAAwC;CAAC,IAAAI;CAAA,IAAAC;CAAA,IAAAd,EAAA,QAAAE,OAAAF,EAAA,QAAAD,MAAA;EAElCc,WAAA;GAGR,MAAA,EAAAH,UAAAd,QAAAmB,UAAAlB,YAAAmB,SAAA,GAAAC,SAA2DlB;GAC3D,MAAAmB,UAAgB,EAAAP,OACP,GACJD,WAAWO,KACd,EACF;GAAE,OACKf,IAAGiB,aAAc,CAAC,CAAAC,SAAU,EAAAC,uBACVH,QACzB,CAAC;EAAC;EACDJ,KAAA,CAACZ,KAAKH,IAAI;EAACC,EAAA,MAAAE;EAAAF,EAAA,MAAAD;EAAAC,EAAA,MAAAa;EAAAb,EAAA,MAAAc;CAAA,OAAA;EAAAD,KAAAb,EAAA;EAAAc,KAAAd,EAAA;CAAA;CAZdhB,UAAU6B,IAYPC,EAAW;AAAC"}

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

@@ -1,5 +1,6 @@
 import { useEffect } from "@assistant-ui/tap/react-shim";
 import { useAui } from "@assistant-ui/store";
+import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
 //#region src/react/model-context/useAssistantToolUI.ts
 /**
 * Registers a tool-call renderer while the component is mounted.
@@ -14,17 +15,37 @@ import { useAui } from "@assistant-ui/store";
 * See https://assistant-ui.com/docs/migrations/toolkit-tools.
 */
 const useAssistantToolUI = (tool) => {
+	const $ = c(9);
 	const aui = useAui();
 	const standalone = tool?.display === "standalone";
-	useEffect(() => {
-		if (!tool?.toolName || !tool?.render) return void 0;
-		return aui.tools().setToolUI(tool.toolName, tool.render, { standalone });
-	}, [
-		aui,
-		tool?.toolName,
-		tool?.render,
-		standalone
-	]);
+	let t0;
+	if ($[0] !== aui || $[1] !== standalone || $[2] !== tool) {
+		t0 = () => {
+			if (!tool?.toolName || !tool?.render) return;
+			return aui.tools().setToolUI(tool.toolName, tool.render, { standalone });
+		};
+		$[0] = aui;
+		$[1] = standalone;
+		$[2] = tool;
+		$[3] = t0;
+	} else t0 = $[3];
+	const t1 = tool?.toolName;
+	const t2 = tool?.render;
+	let t3;
+	if ($[4] !== aui || $[5] !== standalone || $[6] !== t1 || $[7] !== t2) {
+		t3 = [
+			aui,
+			t1,
+			t2,
+			standalone
+		];
+		$[4] = aui;
+		$[5] = standalone;
+		$[6] = t1;
+		$[7] = t2;
+		$[8] = t3;
+	} else t3 = $[8];
+	useEffect(t0, t3);
 };
 //#endregion
 export { useAssistantToolUI };

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

@@ -1 +1 @@
-{"version":3,"file":"useAssistantToolUI.js","names":[],"sources":["../../../src/react/model-context/useAssistantToolUI.ts"],"sourcesContent":["import { useEffect } from \"react\";\nimport { useAui } from \"@assistant-ui/store\";\nimport type { ToolCallMessagePartComponent } from \"../types/MessagePartComponentTypes\";\n\n/**\n * Props used to register a renderer for tool-call message parts.\n *\n * @deprecated Put `render`/`renderText` on the matching toolkit entry, or use\n * `MessagePrimitive.Parts` inline tool render overrides for per-message UI.\n * See https://assistant-ui.com/docs/migrations/toolkit-tools.\n */\nexport type AssistantToolUIProps<TArgs, TResult> = {\n  /** Name of the tool whose calls should use this renderer. */\n  toolName: string;\n  /** Component rendered for matching tool-call message parts. */\n  render: ToolCallMessagePartComponent<TArgs, TResult>;\n  /**\n   * How the UI is presented relative to the chain-of-thought trace. Set\n   * `\"standalone\"` to surface it on its own (e.g. human-in-the-loop or\n   * generative UI for a backend/MCP tool). Defaults to `\"inline\"`.\n   */\n  display?: \"standalone\" | \"inline\";\n};\n\n/**\n * Registers a tool-call renderer while the component is mounted.\n *\n * This only affects rendering. Pair it with {@link Tools} or a backend tool\n * registry to expose the actual tool definition to the model.\n *\n * @param tool - Tool renderer registration, or `null` to skip registration.\n *\n * @deprecated Put `render`/`renderText` on the matching toolkit entry, or use\n * `MessagePrimitive.Parts` inline tool render overrides for per-message UI.\n * See https://assistant-ui.com/docs/migrations/toolkit-tools.\n */\nexport const useAssistantToolUI = (\n  tool: AssistantToolUIProps<any, any> | null,\n) => {\n  const aui = useAui();\n  const standalone = tool?.display === \"standalone\";\n  useEffect(() => {\n    if (!tool?.toolName || !tool?.render) return undefined;\n    return aui.tools().setToolUI(tool.toolName, tool.render, { standalone });\n  }, [aui, tool?.toolName, tool?.render, standalone]);\n};\n"],"mappings":";;;;;;;;;;;;;;;AAoCA,MAAa,sBACX,SACG;CACH,MAAM,MAAM,OAAO;CACnB,MAAM,aAAa,MAAM,YAAY;CACrC,gBAAgB;EACd,IAAI,CAAC,MAAM,YAAY,CAAC,MAAM,QAAQ,OAAO,KAAA;EAC7C,OAAO,IAAI,MAAM,CAAC,CAAC,UAAU,KAAK,UAAU,KAAK,QAAQ,EAAE,WAAW,CAAC;CACzE,GAAG;EAAC;EAAK,MAAM;EAAU,MAAM;EAAQ;CAAU,CAAC;AACpD"}
+{"version":3,"file":"useAssistantToolUI.js","names":["useEffect","useAui","ToolCallMessagePartComponent","AssistantToolUIProps","toolName","render","TArgs","TResult","display","useAssistantToolUI","tool","$","_c","aui","standalone","t0","tools","setToolUI","t1","t2","t3"],"sources":["../../../src/react/model-context/useAssistantToolUI.ts"],"sourcesContent":["import { useEffect } from \"react\";\nimport { useAui } from \"@assistant-ui/store\";\nimport type { ToolCallMessagePartComponent } from \"../types/MessagePartComponentTypes\";\n\n/**\n * Props used to register a renderer for tool-call message parts.\n *\n * @deprecated Put `render`/`renderText` on the matching toolkit entry, or use\n * `MessagePrimitive.Parts` inline tool render overrides for per-message UI.\n * See https://assistant-ui.com/docs/migrations/toolkit-tools.\n */\nexport type AssistantToolUIProps<TArgs, TResult> = {\n  /** Name of the tool whose calls should use this renderer. */\n  toolName: string;\n  /** Component rendered for matching tool-call message parts. */\n  render: ToolCallMessagePartComponent<TArgs, TResult>;\n  /**\n   * How the UI is presented relative to the chain-of-thought trace. Set\n   * `\"standalone\"` to surface it on its own (e.g. human-in-the-loop or\n   * generative UI for a backend/MCP tool). Defaults to `\"inline\"`.\n   */\n  display?: \"standalone\" | \"inline\";\n};\n\n/**\n * Registers a tool-call renderer while the component is mounted.\n *\n * This only affects rendering. Pair it with {@link Tools} or a backend tool\n * registry to expose the actual tool definition to the model.\n *\n * @param tool - Tool renderer registration, or `null` to skip registration.\n *\n * @deprecated Put `render`/`renderText` on the matching toolkit entry, or use\n * `MessagePrimitive.Parts` inline tool render overrides for per-message UI.\n * See https://assistant-ui.com/docs/migrations/toolkit-tools.\n */\nexport const useAssistantToolUI = (\n  tool: AssistantToolUIProps<any, any> | null,\n) => {\n  const aui = useAui();\n  const standalone = tool?.display === \"standalone\";\n  useEffect(() => {\n    if (!tool?.toolName || !tool?.render) return undefined;\n    return aui.tools().setToolUI(tool.toolName, tool.render, { standalone });\n  }, [aui, tool?.toolName, tool?.render, standalone]);\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAoCA,MAAaS,sBAAqBC,SAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CAGhC,MAAAC,MAAYZ,OAAO;CACnB,MAAAa,aAAmBJ,MAAIF,YAAc;CAAa,IAAAO;CAAA,IAAAJ,EAAA,OAAAE,OAAAF,EAAA,OAAAG,cAAAH,EAAA,OAAAD,MAAA;EACxCK,WAAA;GACR,IAAI,CAACL,MAAIN,YAAL,CAAoBM,MAAIL,QAAQ;GAAmB,OAChDQ,IAAGG,MAAO,CAAC,CAAAC,UAAWP,KAAIN,UAAWM,KAAIL,QAAS,EAAAS,WAAa,CAAC;EAAC;EACzEH,EAAA,KAAAE;EAAAF,EAAA,KAAAG;EAAAH,EAAA,KAAAD;EAAAC,EAAA,KAAAI;CAAA,OAAAA,KAAAJ,EAAA;CAAQ,MAAAO,KAAAR,MAAIN;CAAY,MAAAe,KAAAT,MAAIL;CAAQ,IAAAe;CAAA,IAAAT,EAAA,OAAAE,OAAAF,EAAA,OAAAG,cAAAH,EAAA,OAAAO,MAAAP,EAAA,OAAAQ,IAAA;EAAlCC,KAAA;GAACP;GAAKK;GAAgBC;GAAcL;EAAU;EAACH,EAAA,KAAAE;EAAAF,EAAA,KAAAG;EAAAH,EAAA,KAAAO;EAAAP,EAAA,KAAAQ;EAAAR,EAAA,KAAAS;CAAA,OAAAA,KAAAT,EAAA;CAHlDX,UAAUe,IAGPK,EAA+C;AAAC"}

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

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

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

@@ -1,14 +1,41 @@
-import { useCallback, useEffect, useState } from "@assistant-ui/tap/react-shim";
+import { useEffect, useState } from "@assistant-ui/tap/react-shim";
+import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
 import { create } from "zustand";
 //#region src/react/model-context/useInlineRender.ts
 const useInlineRender = (toolUI) => {
-	const [useToolUIStore] = useState(() => create(() => ({ toolUI })));
-	useEffect(() => {
-		useToolUIStore.setState({ toolUI });
-	}, [toolUI, useToolUIStore]);
-	return useCallback(function ToolUI(args) {
-		return useToolUIStore().toolUI(args);
-	}, [useToolUIStore]);
+	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;
 };
 //#endregion
 export { useInlineRender };

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

@@ -1 +1 @@
-{"version":3,"file":"useInlineRender.js","names":[],"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,MAAa,mBACX,WACiD;CACjD,MAAM,CAAC,kBAAkB,eACvB,cAAc,EACZ,OACF,EAAE,CACJ;CAEA,gBAAgB;EACd,eAAe,SAAS,EAAE,OAAO,CAAC;CACpC,GAAG,CAAC,QAAQ,cAAc,CAAC;CAE3B,OAAO,YACL,SAAS,OAAO,MAAM;EAEpB,OADc,eACH,CAAC,CAAC,OAAO,IAAI;CAC1B,GACA,CAAC,cAAc,CACjB;AACF"}
+{"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"}