@assistant-ui/core 0.3.19 → 0.3.20

package/dist/react/client/interactable-model-context.d.ts

@@ -1,8 +1,8 @@
 import { Unstable_InteractableDefinition } from "../types/scopes/interactables.js";
 import { Tool, toJSONSchema } from "assistant-stream";
 //#region src/react/client/interactable-model-context.d.ts
-type PartialJSONSchema = ReturnType<typeof toJSONSchema>;
-declare function buildInteractableModelContext(definitions: Record<string, Unstable_InteractableDefinition>, partialSchemaCache: Map<string, PartialJSONSchema>, setDefState: (id: string, updater: (prev: unknown) => unknown) => void, streamBaselines?: Map<string, {
+export type PartialJSONSchema = ReturnType<typeof toJSONSchema>;
+export declare function buildInteractableModelContext(definitions: Record<string, Unstable_InteractableDefinition>, partialSchemaCache: Map<string, PartialJSONSchema>, setDefState: (id: string, updater: (prev: unknown) => unknown) => void, streamBaselines?: Map<string, {
   targetId: string;
   state: unknown;
 }>): {
@@ -10,5 +10,4 @@ declare function buildInteractableModelContext(definitions: Record<string, Unsta
   unstable_composerMetadata?: Record<string, unknown>;
 } | undefined;
 //#endregion
-export { PartialJSONSchema, buildInteractableModelContext };
 //# sourceMappingURL=interactable-model-context.d.ts.map

package/dist/react/client/interactable-model-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interactable-model-context.d.ts","names":[],"sources":["../../../src/react/client/interactable-model-context.ts"],"mappings":";;;KAYY,oBAAoB,kBAAkB;iBAgIlC,8BACd,aAAa,eAAe,kCAC5B,oBAAoB,YAAY,oBAChC,cAAc,YAAY,UAAU,oCACpC,kBAAe;EAA+B;EAAe;;EAGzD,OAAO,eAAe;EACtB,4BAA4B"}
+{"version":3,"file":"interactable-model-context.d.ts","names":[],"sources":["../../../src/react/client/interactable-model-context.ts"],"mappings":";;;YAYY,oBAAoB,kBAAkB;wBAgIlC,8BACd,aAAa,eAAe,kCAC5B,oBAAoB,YAAY,oBAChC,cAAc,YAAY,UAAU,oCACpC,kBAAe;EAA+B;EAAe;;EAGzD,OAAO,eAAe;EACtB,4BAA4B"}

package/dist/react/interactables-legacy/Interactables.d.ts

@@ -5,7 +5,6 @@ import { ClientOutput } from "@assistant-ui/store";
  * Scheduled for removal on/after 2026-09-14. See
  * {@link https://www.assistant-ui.com/docs/tools/interactables#migrating-from-the-previous-api | Interactables migration guide}.
  */
-declare const Interactables: import("@assistant-ui/tap").Resource<ClientOutput<"interactables">, []>;
+export declare const Interactables: import("@assistant-ui/tap").Resource<ClientOutput<"interactables">, []>;
 //#endregion
-export { Interactables };
 //# sourceMappingURL=Interactables.d.ts.map

package/dist/react/interactables-legacy/Interactables.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Interactables.d.ts","names":[],"sources":["../../../src/react/interactables-legacy/Interactables.ts"],"mappings":";;;;;;;cAoPa,2CAAa,SAAA"}
+{"version":3,"file":"Interactables.d.ts","names":[],"sources":["../../../src/react/interactables-legacy/Interactables.ts"],"mappings":";;;;;;;qBAoPa,2CAAa,SAAA"}

package/dist/react/interactables-legacy/interactable-model-context.d.ts

@@ -1,11 +1,10 @@
 import { InteractableDefinition, InteractableStateSchema } from "./scopes.js";
 import { Tool } from "assistant-stream";
 //#region src/react/interactables-legacy/interactable-model-context.d.ts
-declare function shallowMerge(prev: unknown, partial: unknown): unknown;
-declare function buildInteractableModelContext(definitions: Record<string, InteractableDefinition>, partialSchemaCache: Map<string, InteractableStateSchema>, setDefState: (id: string, updater: (prev: unknown) => unknown) => void): {
+export declare function shallowMerge(prev: unknown, partial: unknown): unknown;
+export declare function buildInteractableModelContext(definitions: Record<string, InteractableDefinition>, partialSchemaCache: Map<string, InteractableStateSchema>, setDefState: (id: string, updater: (prev: unknown) => unknown) => void): {
   system: string;
   tools: Record<string, Tool<any, any>>;
 } | undefined;
 //#endregion
-export { buildInteractableModelContext, shallowMerge };
 //# sourceMappingURL=interactable-model-context.d.ts.map

package/dist/react/interactables-legacy/interactable-model-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interactable-model-context.d.ts","names":[],"sources":["../../../src/react/interactables-legacy/interactable-model-context.ts"],"mappings":";;;iBAGgB,aAAa,eAAe;iBAiB5B,8BACd,aAAa,eAAe,yBAC5B,oBAAoB,YAAY,0BAChC,cAAc,YAAY,UAAU;EACjC;EAAgB,OAAO,eAAe"}
+{"version":3,"file":"interactable-model-context.d.ts","names":[],"sources":["../../../src/react/interactables-legacy/interactable-model-context.ts"],"mappings":";;;wBAGgB,aAAa,eAAe;wBAiB5B,8BACd,aAAa,eAAe,yBAC5B,oBAAoB,YAAY,0BAChC,cAAc,YAAY,UAAU;EACjC;EAAgB,OAAO,eAAe"}

package/dist/react/interactables-legacy/scopes.d.ts

@@ -6,10 +6,10 @@ import { Tool } from "assistant-stream";
  * Schema type matching Tool["parameters"] from assistant-stream.
  * Accepts both StandardSchemaV1 and JSONSchema7.
  */
-type InteractableStateSchema = NonNullable<Extract<Tool, {
+export type InteractableStateSchema = NonNullable<Extract<Tool, {
   parameters: unknown;
 }>["parameters"]>;
-type InteractableDefinition = {
+export type InteractableDefinition = {
   id: string;
   name: string;
   description: string;
@@ -17,7 +17,7 @@ type InteractableDefinition = {
   state: unknown;
   selected?: boolean | undefined;
 };
-type InteractableRegistration = {
+export type InteractableRegistration = {
   id: string;
   name: string;
   description: string;
@@ -25,24 +25,24 @@ type InteractableRegistration = {
   initialState: unknown;
   selected?: boolean | undefined;
 };
-type InteractablePersistenceStatus = {
+export type InteractablePersistenceStatus = {
   isPending: boolean;
   error: unknown;
 };
-type InteractablesState = {
+export type InteractablesState = {
   /** Keyed by instance id */
   definitions: Record<string, InteractableDefinition>;
   /** Per-id persistence sync status */
   persistence: Record<string, InteractablePersistenceStatus>;
 };
-type InteractablePersistedState = Record<string, {
+export type InteractablePersistedState = Record<string, {
   name: string;
   state: unknown;
 }>;
-type InteractablePersistenceAdapter = {
+export type InteractablePersistenceAdapter = {
   save(state: InteractablePersistedState): void | Promise<void>;
 };
-type InteractablesMethods = {
+export type InteractablesMethods = {
   getState(): InteractablesState;
   register(def: InteractableRegistration): Unsubscribe;
   setState(id: string, updater: (prev: unknown) => unknown): void;
@@ -52,9 +52,8 @@ type InteractablesMethods = {
   setPersistenceAdapter(adapter: InteractablePersistenceAdapter | undefined): void;
   flush(): Promise<void>;
 };
-type InteractablesClientSchema = {
+export type InteractablesClientSchema = {
   methods: InteractablesMethods;
 };
 //#endregion
-export { InteractableDefinition, InteractablePersistedState, InteractablePersistenceAdapter, InteractablePersistenceStatus, InteractableRegistration, InteractableStateSchema, InteractablesClientSchema, InteractablesMethods, InteractablesState };
 //# sourceMappingURL=scopes.d.ts.map

package/dist/react/interactables-legacy/scopes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scopes.d.ts","names":[],"sources":["../../../src/react/interactables-legacy/scopes.ts"],"mappings":";;;;;;;;KAOY,0BAA0B,YACpC,QAAQ;EAAQ;;KAGN;EACV;EACA;EACA;EACA,aAAa;EACb;EACA;;KAGU;EACV;EACA;EACA;EACA,aAAa;EACb;EACA;;KAGU;EACV;EACA;;KAGU;;EAEV,aAAa,eAAe;;EAE5B,aAAa,eAAe;;KAGlB,6BAA6B;EAErC;EAAc;;KAGN;EACV,KAAK,OAAO,oCAAoC;;KAGtC;EACV,YAAY;EACZ,SAAS,KAAK,2BAA2B;EACzC,SAAS,YAAY,UAAU;EAC/B,YAAY,YAAY;EACxB,eAAe;EACf,YAAY,OAAO;EACnB,sBACE,SAAS;EAEX,SAAS;;KAGC;EACV,SAAS"}
+{"version":3,"file":"scopes.d.ts","names":[],"sources":["../../../src/react/interactables-legacy/scopes.ts"],"mappings":";;;;;;;;YAOY,0BAA0B,YACpC,QAAQ;EAAQ;;YAGN;EACV;EACA;EACA;EACA,aAAa;EACb;EACA;;YAGU;EACV;EACA;EACA;EACA,aAAa;EACb;EACA;;YAGU;EACV;EACA;;YAGU;;EAEV,aAAa,eAAe;;EAE5B,aAAa,eAAe;;YAGlB,6BAA6B;EAErC;EAAc;;YAGN;EACV,KAAK,OAAO,oCAAoC;;YAGtC;EACV,YAAY;EACZ,SAAS,KAAK,2BAA2B;EACzC,SAAS,YAAY,UAAU;EAC/B,YAAY,YAAY;EACxB,eAAe;EACf,YAAY,OAAO;EACnB,sBACE,SAAS;EAEX,SAAS;;YAGC;EACV,SAAS"}

package/dist/react/interactables-legacy/useAssistantInteractable.d.ts

@@ -5,7 +5,7 @@ import { InteractableStateSchema } from "./scopes.js";
  * Scheduled for removal on/after 2026-09-14. See
  * {@link https://www.assistant-ui.com/docs/tools/interactables#migrating-from-the-previous-api | Interactables migration guide}.
  */
-type AssistantInteractableProps = {
+export type AssistantInteractableProps = {
   description: string;
   stateSchema: InteractableStateSchema;
   initialState: unknown;
@@ -24,7 +24,6 @@ type AssistantInteractableProps = {
  *
  * @returns The interactable instance id.
  */
-declare const useAssistantInteractable: (name: string, config: AssistantInteractableProps) => string;
+export declare const useAssistantInteractable: (name: string, config: AssistantInteractableProps) => string;
 //#endregion
-export { AssistantInteractableProps, useAssistantInteractable };
 //# sourceMappingURL=useAssistantInteractable.d.ts.map

package/dist/react/interactables-legacy/useAssistantInteractable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAssistantInteractable.d.ts","names":[],"sources":["../../../src/react/interactables-legacy/useAssistantInteractable.ts"],"mappings":";;;;;;;KAUY;EACV;EACA,aAAa;EACb;EACA;EACA;;;;;;;;;;;;;;cAeW,2BACX,cACA,QAAQ"}
+{"version":3,"file":"useAssistantInteractable.d.ts","names":[],"sources":["../../../src/react/interactables-legacy/useAssistantInteractable.ts"],"mappings":";;;;;;;YAUY;EACV;EACA,aAAa;EACb;EACA;EACA;;;;;;;;;;;;;;qBAeW,2BACX,cACA,QAAQ"}

package/dist/react/interactables-legacy/useInteractableState.d.ts

@@ -9,7 +9,7 @@ type StateUpdater<TState> = TState | ((prev: TState) => TState);
  * Scheduled for removal on/after 2026-09-14. See
  * {@link https://www.assistant-ui.com/docs/tools/interactables#migrating-from-the-previous-api | Interactables migration guide}.
  */
-declare const useInteractableState: <TState>(id: string, fallback: TState) => [TState, {
+export declare const useInteractableState: <TState>(id: string, fallback: TState) => [TState, {
   setState: (updater: StateUpdater<TState>) => void;
   setSelected: (selected: boolean) => void;
   isPending: boolean;
@@ -17,5 +17,4 @@ declare const useInteractableState: <TState>(id: string, fallback: TState) => [T
   flush: () => Promise<void>;
 }];
 //#endregion
-export { useInteractableState };
 //# sourceMappingURL=useInteractableState.d.ts.map

package/dist/react/interactables-legacy/useInteractableState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useInteractableState.d.ts","names":[],"sources":["../../../src/react/interactables-legacy/useInteractableState.ts"],"mappings":";KAGK,aAAa,UAAU,WAAW,MAAM,WAAW;;;;;;;;;;cAW3C,uBAAwB,QACnC,YACA,UAAU,YAEV;EAEE,WAAW,SAAS,aAAa;EACjC,cAAc;EACd;EACA;EACA,aAAa"}
+{"version":3,"file":"useInteractableState.d.ts","names":[],"sources":["../../../src/react/interactables-legacy/useInteractableState.ts"],"mappings":";KAGK,aAAa,UAAU,WAAW,MAAM,WAAW;;;;;;;;;;qBAW3C,uBAAwB,QACnC,YACA,UAAU,YAEV;EAEE,WAAW,SAAS,aAAa;EACjC,cAAc;EACd;EACA;EACA,aAAa"}

package/dist/react/interactables-shared/useInteractablePersistenceQueue.d.ts

@@ -14,11 +14,10 @@ type UseInteractablePersistenceQueueOptions<State> = {
   snapshot: () => State;
   updatePersistenceStatus: PersistenceStatusUpdater;
 };
-declare const useInteractablePersistenceQueue: <State>({ adapterRef, snapshot, updatePersistenceStatus }: UseInteractablePersistenceQueueOptions<State>) => {
+export declare const useInteractablePersistenceQueue: <State>({ adapterRef, snapshot, updatePersistenceStatus }: UseInteractablePersistenceQueueOptions<State>) => {
   flushIfPending: () => void;
   schedulePersistence: (id: string) => void;
   flush: () => Promise<void>;
 };
 //#endregion
-export { useInteractablePersistenceQueue };
 //# sourceMappingURL=useInteractablePersistenceQueue.d.ts.map

package/dist/react/interactables-shared/useInteractablePersistenceQueue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useInteractablePersistenceQueue.d.ts","names":[],"sources":["../../../src/react/interactables-shared/useInteractablePersistenceQueue.ts"],"mappings":";;KAKK,mBAAmB;EACtB,KAAK,OAAO,eAAe;;KAGxB;EACH;EACA;;KAGG,uBAAuB,eAAe;KAEtC,4BACH,UAAU,MAAM,yBAAyB;KAGtC,uCAAuC;EAC1C,YAAY,UAAU,mBAAmB;EACzC,gBAAgB;EAChB,yBAAyB;;cAGd,kCAAmC,SAAO,YAAA,UAAA,2BAIpD,uCAAuC;;EAuIjC,sBAAA"}
+{"version":3,"file":"useInteractablePersistenceQueue.d.ts","names":[],"sources":["../../../src/react/interactables-shared/useInteractablePersistenceQueue.ts"],"mappings":";;KAKK,mBAAmB;EACtB,KAAK,OAAO,eAAe;;KAGxB;EACH;EACA;;KAGG,uBAAuB,eAAe;KAEtC,4BACH,UAAU,MAAM,yBAAyB;KAGtC,uCAAuC;EAC1C,YAAY,UAAU,mBAAmB;EACzC,gBAAgB;EAChB,yBAAyB;;qBAGd,kCAAmC,SAAO,YAAA,UAAA,2BAIpD,uCAAuC;;EAuIjC,sBAAA"}

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

@@ -1,7 +1,7 @@
 import { Toolkit } from "./toolbox.js";
 import { McpServerConfig } from "assistant-stream";
 //#region src/react/model-context/define-mcp-toolkit.d.ts
-type McpToolkitEntry = McpServerConfig | {
+export type McpToolkitEntry = McpServerConfig | {
   server: McpServerConfig;
   disabled?: boolean | undefined;
   /**
@@ -11,17 +11,16 @@ type McpToolkitEntry = McpServerConfig | {
   prefix?: string | undefined;
   tools?: Record<string, McpToolkitToolConfig> | undefined;
 };
-type McpToolkitToolConfig = {
+export type McpToolkitToolConfig = {
   disabled?: boolean | undefined;
 };
-type McpToolkitDefinition = Record<string, McpToolkitEntry>;
+export type McpToolkitDefinition = Record<string, McpToolkitEntry>;
 /**
  * Defines MCP server tools as a spreadable toolkit fragment. Pass a raw
  * `McpServerConfig` for always-on servers, or `{ server, disabled, tools }`
  * when a server should stay configured but not expose all tools for the current
  * request.
  */
-declare function defineMcpToolkit(definition: McpToolkitDefinition): Toolkit;
+export declare function defineMcpToolkit(definition: McpToolkitDefinition): Toolkit;
 //#endregion
-export { McpToolkitDefinition, McpToolkitEntry, McpToolkitToolConfig, defineMcpToolkit };
 //# sourceMappingURL=define-mcp-toolkit.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"define-mcp-toolkit.d.ts","names":[],"sources":["../../../src/react/model-context/define-mcp-toolkit.ts"],"mappings":";;;KAGY,kBACR;EAEE,QAAQ;EACR;;;;;EAKA;EACA,QAAQ,eAAe;;KAGjB;EACV;;KAGU,uBAAuB,eAAe;;;;;;;iBAQlC,iBAAiB,YAAY,uBAAuB"}
+{"version":3,"file":"define-mcp-toolkit.d.ts","names":[],"sources":["../../../src/react/model-context/define-mcp-toolkit.ts"],"mappings":";;;YAGY,kBACR;EAEE,QAAQ;EACR;;;;;EAKA;EACA,QAAQ,eAAe;;YAGjB;EACV;;YAGU,uBAAuB,eAAe;;;;;;;wBAQlC,iBAAiB,YAAY,uBAAuB"}

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

@@ -10,8 +10,7 @@ import { Toolkit, ToolkitDefinition, ToolkitDefinitionEntryWithParameters } from
  * Outside generative compilation, it returns the toolkit unchanged and can be
  * used for plain frontend/backend/human toolkit objects.
  */
-declare function defineToolkit<TArgsByName extends { [K in keyof TArgsByName]: Record<string, unknown>; }, TResultByName extends { [K in keyof TArgsByName]: unknown; } = { [K in keyof TArgsByName]: any; }>(_definition: { [K in keyof TArgsByName]: ToolkitDefinitionEntryWithParameters<TArgsByName[K], TResultByName[K]>; }): Toolkit & { [K in keyof TArgsByName]: ToolkitDefinitionEntryWithParameters<TArgsByName[K], TResultByName[K]>; };
-declare function defineToolkit<const TDefinition extends ToolkitDefinition>(_definition: TDefinition): Toolkit & TDefinition;
+export declare function defineToolkit<TArgsByName extends { [K in keyof TArgsByName]: Record<string, unknown>; }, TResultByName extends { [K in keyof TArgsByName]: unknown; } = { [K in keyof TArgsByName]: any; }>(_definition: { [K in keyof TArgsByName]: ToolkitDefinitionEntryWithParameters<TArgsByName[K], TResultByName[K]>; }): Toolkit & { [K in keyof TArgsByName]: ToolkitDefinitionEntryWithParameters<TArgsByName[K], TResultByName[K]>; };
+export declare function defineToolkit<const TDefinition extends ToolkitDefinition>(_definition: TDefinition): Toolkit & TDefinition;
 //#endregion
-export { defineToolkit };
 //# sourceMappingURL=define-toolkit.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"define-toolkit.d.ts","names":[],"sources":["../../../src/react/model-context/define-toolkit.ts"],"mappings":";;;;;;;;;;;;iBAgBgB,cACd,uBACG,WAAW,cAAc,4BAE5B,yBAAyB,WAAW,8BACjC,WAAW,sBAEd,gBACC,WAAW,cAAc,qCACxB,YAAY,IACZ,cAAc,SAEd,aACD,WAAW,cAAc,qCACxB,YAAY,IACZ,cAAc;iBAGF,oBAAoB,oBAAoB,mBACtD,aAAa,cACZ,UAAU"}
+{"version":3,"file":"define-toolkit.d.ts","names":[],"sources":["../../../src/react/model-context/define-toolkit.ts"],"mappings":";;;;;;;;;;;;wBAgBgB,cACd,uBACG,WAAW,cAAc,4BAE5B,yBAAyB,WAAW,8BACjC,WAAW,sBAEd,gBACC,WAAW,cAAc,qCACxB,YAAY,IACZ,cAAc,SAEd,aACD,WAAW,cAAc,qCACxB,YAAY,IACZ,cAAc;wBAGF,oBAAoB,oBAAoB,mBACtD,aAAa,cACZ,UAAU"}

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

@@ -8,7 +8,6 @@
  * entries from the server build and keeps a `type: "backend"` renderer on the
  * client build.
  */
-declare function externalTool(): never;
+export declare function externalTool(): never;
 //#endregion
-export { externalTool };
 //# sourceMappingURL=external-tool.d.ts.map

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

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

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

@@ -13,15 +13,14 @@
  * Reaching it at runtime means the module wasn't compiled (used outside a
  * `"use generative"` file), so it throws.
  */
-declare function humanTool(): never;
+export declare function humanTool(): never;
 /**
  * @deprecated Use {@link humanTool}.
  */
-declare const hitlTool: typeof humanTool;
+export declare const hitlTool: typeof humanTool;
 /**
  * @deprecated Use {@link humanTool}.
  */
-declare const hitl: typeof humanTool;
+export declare const hitl: typeof humanTool;
 //#endregion
-export { hitl, hitlTool, humanTool };
 //# sourceMappingURL=human-tool.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"human-tool.d.ts","names":[],"sources":["../../../src/react/model-context/human-tool.ts"],"mappings":";;;;;;;;;;;;;;;iBAcgB;;;;cAYH,iBAAQ;;;;cAKR,aAAI"}
+{"version":3,"file":"human-tool.d.ts","names":[],"sources":["../../../src/react/model-context/human-tool.ts"],"mappings":";;;;;;;;;;;;;;;wBAcgB;;;;qBAYH,iBAAQ;;;;qBAKR,aAAI"}

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

@@ -3,7 +3,7 @@ import { Unstable_InteractableStateSchema } from "../types/scopes/interactables.
 import { Unstable_InferInteractableState, Unstable_InteractableVersionInfo } from "./useInteractable.js";
 import { ReactNode } from "react";
 //#region src/react/model-context/interactableTool.d.ts
-type Unstable_InteractableToolRenderProps<TState> = {
+export type Unstable_InteractableToolRenderProps<TState> = {
   /**
    * The live state. While `streaming` is true, fields the model has not
    * finished generating may still be missing.
@@ -20,7 +20,7 @@ type Unstable_InteractableToolRenderProps<TState> = {
   /** True while the tool call's arguments are still streaming in. */
   streaming: boolean;
 };
-type Unstable_InteractableToolConfig<TSchema extends Unstable_InteractableStateSchema> = {
+export type Unstable_InteractableToolConfig<TSchema extends Unstable_InteractableStateSchema> = {
   description: string;
   stateSchema: TSchema;
   render: (props: Unstable_InteractableToolRenderProps<Unstable_InferInteractableState<TSchema>>) => ReactNode;
@@ -45,9 +45,8 @@ type Unstable_InteractableToolConfig<TSchema extends Unstable_InteractableStateS
  *
  * @deprecated Unstable / Experimental (not actually removed).
  */
-declare const unstable_interactableTool: <TSchema extends Unstable_InteractableStateSchema>(config: Unstable_InteractableToolConfig<TSchema>) => ToolDefinition<Record<string, unknown>, {
+export declare const unstable_interactableTool: <TSchema extends Unstable_InteractableStateSchema>(config: Unstable_InteractableToolConfig<TSchema>) => ToolDefinition<Record<string, unknown>, {
   success: true;
 }>;
 //#endregion
-export { Unstable_InteractableToolConfig, Unstable_InteractableToolRenderProps, unstable_interactableTool };
 //# sourceMappingURL=interactableTool.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"interactableTool.d.ts","names":[],"sources":["../../../src/react/model-context/interactableTool.tsx"],"mappings":";;;;;KAWY,qCAAqC;;;;;EAK/C,OAAO;EACP,WAAW,SAAS,WAAW,MAAM,WAAW;;;;;;EAMhD,SAAS,iCAAiC;EAC1C;;EAEA;;KAGU,gCACV,gBAAgB;EAEhB;EACA,aAAa;EACb,SACE,OAAO,qCACL,gCAAgC,cAE/B;;;;;;;;;;;;;;;;;;;;;;cA2BM,4BACX,gBAAgB,kCAEhB,QAAQ,gCAAgC,aACvC,eAAe;EAA2B"}
+{"version":3,"file":"interactableTool.d.ts","names":[],"sources":["../../../src/react/model-context/interactableTool.tsx"],"mappings":";;;;;YAWY,qCAAqC;;;;;EAK/C,OAAO;EACP,WAAW,SAAS,WAAW,MAAM,WAAW;;;;;;EAMhD,SAAS,iCAAiC;EAC1C;;EAEA;;YAGU,gCACV,gBAAgB;EAEhB;EACA,aAAa;EACb,SACE,OAAO,qCACL,gCAAgC,cAE/B;;;;;;;;;;;;;;;;;;;;;;qBA2BM,4BACX,gBAAgB,kCAEhB,QAAQ,gCAAgC,aACvC,eAAe;EAA2B"}

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

@@ -7,7 +7,7 @@ import { FC } from "react";
  * Rendering the component registers a renderer for matching `data` message
  * parts.
  */
-type AssistantDataUI = FC & {
+export type AssistantDataUI = FC & {
   /** Data renderer registered by this component. */
   unstable_data: AssistantDataUIProps;
 };
@@ -17,7 +17,6 @@ type AssistantDataUI = FC & {
  *
  * @param dataUI - Data renderer registration.
  */
-declare const makeAssistantDataUI: <T = any>(dataUI: AssistantDataUIProps<T>) => AssistantDataUI;
+export declare const makeAssistantDataUI: <T = any>(dataUI: AssistantDataUIProps<T>) => AssistantDataUI;
 //#endregion
-export { AssistantDataUI, makeAssistantDataUI };
 //# sourceMappingURL=makeAssistantDataUI.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"makeAssistantDataUI.d.ts","names":[],"sources":["../../../src/react/model-context/makeAssistantDataUI.ts"],"mappings":";;;;;;;;;KAYY,kBAAkB;;EAE5B,eAAe;;;;;;;;cASJ,sBAAuB,SAClC,QAAQ,qBAAqB,OAAE"}
+{"version":3,"file":"makeAssistantDataUI.d.ts","names":[],"sources":["../../../src/react/model-context/makeAssistantDataUI.ts"],"mappings":";;;;;;;;;YAYY,kBAAkB;;EAE5B,eAAe;;;;;;;;qBASJ,sBAAuB,SAClC,QAAQ,qBAAqB,OAAE"}

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

@@ -11,7 +11,7 @@ import { FC } from "react";
  * `AuiConfig({ tools: Tools({ toolkit }) })` on the provider's `config` prop instead. See
  * https://assistant-ui.com/docs/migrations/toolkit-tools.
  */
-type AssistantTool = FC & {
+export type AssistantTool = FC & {
   /** Tool definition registered by this component. */
   unstable_tool: AssistantToolProps<any, any>;
 };
@@ -27,7 +27,6 @@ type AssistantTool = FC & {
  * `AuiConfig({ tools: Tools({ toolkit }) })` on the provider's `config` prop instead. See
  * https://assistant-ui.com/docs/migrations/toolkit-tools.
  */
-declare const makeAssistantTool: <TArgs extends Record<string, unknown>, TResult>(tool: AssistantToolProps<TArgs, TResult>) => AssistantTool;
+export declare const makeAssistantTool: <TArgs extends Record<string, unknown>, TResult>(tool: AssistantToolProps<TArgs, TResult>) => AssistantTool;
 //#endregion
-export { AssistantTool, makeAssistantTool };
 //# sourceMappingURL=makeAssistantTool.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"makeAssistantTool.d.ts","names":[],"sources":["../../../src/react/model-context/makeAssistantTool.ts"],"mappings":";;;;;;;;;;;;;KAaY,gBAAgB;;EAE1B,eAAe;;;;;;;;;;;;;;cAeJ,oBACX,cAAc,yBACd,SAEA,MAAM,mBAAmB,OAAO,aAAQ"}
+{"version":3,"file":"makeAssistantTool.d.ts","names":[],"sources":["../../../src/react/model-context/makeAssistantTool.ts"],"mappings":";;;;;;;;;;;;;YAaY,gBAAgB;;EAE1B,eAAe;;;;;;;;;;;;;;qBAeJ,oBACX,cAAc,yBACd,SAEA,MAAM,mBAAmB,OAAO,aAAQ"}

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

@@ -11,7 +11,7 @@ import { FC } from "react";
  * `MessagePrimitive.Parts` inline tool render overrides for per-message UI.
  * See https://assistant-ui.com/docs/migrations/toolkit-tools.
  */
-type AssistantToolUI = FC & {
+export type AssistantToolUI = FC & {
   /** Tool renderer registered by this component. */
   unstable_tool: AssistantToolUIProps<any, any>;
 };
@@ -27,7 +27,6 @@ type AssistantToolUI = FC & {
  * `MessagePrimitive.Parts` inline tool render overrides for per-message UI.
  * See https://assistant-ui.com/docs/migrations/toolkit-tools.
  */
-declare const makeAssistantToolUI: <TArgs, TResult>(tool: AssistantToolUIProps<TArgs, TResult>) => AssistantToolUI;
+export declare const makeAssistantToolUI: <TArgs, TResult>(tool: AssistantToolUIProps<TArgs, TResult>) => AssistantToolUI;
 //#endregion
-export { AssistantToolUI, makeAssistantToolUI };
 //# sourceMappingURL=makeAssistantToolUI.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"makeAssistantToolUI.d.ts","names":[],"sources":["../../../src/react/model-context/makeAssistantToolUI.ts"],"mappings":";;;;;;;;;;;;;KAgBY,kBAAkB;;EAE5B,eAAe;;;;;;;;;;;;;;cAeJ,sBAAuB,OAAO,SACzC,MAAM,qBAAqB,OAAO,aAAQ"}
+{"version":3,"file":"makeAssistantToolUI.d.ts","names":[],"sources":["../../../src/react/model-context/makeAssistantToolUI.ts"],"mappings":";;;;;;;;;;;;;YAgBY,kBAAkB;;EAE5B,eAAe;;;;;;;;;;;;;;qBAeJ,sBAAuB,OAAO,SACzC,MAAM,qBAAqB,OAAO,aAAQ"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"provider-tool.d.ts","names":[],"sources":["../../../src/react/model-context/provider-tool.ts"],"mappings":";;KAEK,uBAAuB,cAAc,2BAA2B,QACnE,KAAK;EACH;;KAGQ,mBACV,cAAc,0BAA0B,2BACtC,KACF,uBAAuB;;;;;iBAYT,aAAa,SAAS"}
+{"version":3,"file":"provider-tool.d.ts","names":[],"sources":["../../../src/react/model-context/provider-tool.ts"],"mappings":";;KAEK,uBAAuB,cAAc,2BAA2B,QACnE,KAAK;EACH;;YAGQ,mBACV,cAAc,0BAA0B,2BACtC,KACF,uBAAuB;;;;;wBAYT,aAAa,SAAS"}

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

@@ -6,7 +6,6 @@
  * `stubTool()` has no runtime implementation. It must be used inside a
  * `"use generative"` toolkit file so the compiler can strip it.
  */
-declare function stubTool(): never;
+export declare function stubTool(): never;
 //#endregion
-export { stubTool };
 //# sourceMappingURL=stub-tool.d.ts.map

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

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

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

@@ -3,7 +3,7 @@ import { ToolCallMessagePartComponent, ToolCallMessagePartProps } from "../types
 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>;
+export 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.
@@ -13,7 +13,7 @@ type ToolCallText<TArgs extends Record<string, unknown>, TResult> = ToolCallText
  * what the model is doing). MCP-app tool calls are detected separately from
  * the part itself and are not resolved here.
  */
-declare const isStandaloneToolDisplay: (tool: Pick<Tool<any, any>, "type" | "display">) => boolean;
+export declare const isStandaloneToolDisplay: (tool: Pick<Tool<any, any>, "type" | "display">) => boolean;
 type WithRender<T, TArgs extends Record<string, unknown>, TResult> = T extends {
   type: "frontend" | "human";
 } ? T & (T extends {
@@ -33,7 +33,7 @@ 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;
-declare const makeToolCallTextComponent: <TArgs extends Record<string, unknown>, TResult>(text: ToolCallText<TArgs, TResult>) => ((part: ToolCallMessagePartProps<TArgs, TResult>) => ReactNode);
+export 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.
  *
@@ -42,7 +42,7 @@ declare const makeToolCallTextComponent: <TArgs extends Record<string, unknown>,
  * the browser and require either `render` or `renderText` for their progress
  * and result. Backend tools execute server-side and may omit a renderer.
  */
-type ToolDefinition<TArgs extends Record<string, unknown> = Record<string, unknown>, TResult = unknown> = WithRender<Tool<TArgs, TResult>, TArgs, TResult>;
+export type ToolDefinition<TArgs extends Record<string, unknown> = Record<string, unknown>, TResult = unknown> = WithRender<Tool<TArgs, TResult>, TArgs, TResult>;
 /**
  * Named collection of tools exposed to the assistant model.
  *
@@ -61,7 +61,7 @@ type ToolDefinition<TArgs extends Record<string, unknown> = Record<string, unkno
  * });
  * ```
  */
-type Toolkit = Record<string, ToolDefinition<any, any>>;
+export type Toolkit = Record<string, ToolDefinition<any, any>>;
 /**
  * A tool as authored, before the build splits it: like {@link ToolDefinition}
  * but it may declare `description`, `parameters`, and a server-side `execute`
@@ -89,8 +89,8 @@ type ToolkitDefinitionInput<TArgs extends Record<string, unknown>, TResult> = Wi
  * carries a `type`, so it can only match the {@link ToolDefinition} arm of this
  * union.
  */
-type ToolkitDefinitionEntry<TArgs extends Record<string, unknown> = Record<string, unknown>, TResult = unknown> = ToolkitDefinitionInput<TArgs, TResult> | ToolDefinition<any, any>;
-type ToolkitDefinitionEntryWithParameters<TArgs extends Record<string, unknown> = Record<string, unknown>, TResult = unknown> = ToolkitDefinitionInput<TArgs, TResult> & {
+export type ToolkitDefinitionEntry<TArgs extends Record<string, unknown> = Record<string, unknown>, TResult = unknown> = ToolkitDefinitionInput<TArgs, TResult> | ToolDefinition<any, any>;
+export type ToolkitDefinitionEntryWithParameters<TArgs extends Record<string, unknown> = Record<string, unknown>, TResult = unknown> = ToolkitDefinitionInput<TArgs, TResult> & {
   parameters: NonNullable<ToolParameters<TArgs>>;
 };
 /**
@@ -98,12 +98,11 @@ type ToolkitDefinitionEntryWithParameters<TArgs extends Record<string, unknown>
  * {@link defineToolkit}. Backend entries may carry their server `execute` here;
  * the canonical {@link Toolkit} keeps those fields `undefined`.
  */
-type ToolkitDefinition<TArgsByName extends { [K in keyof TArgsByName]: Record<string, unknown>; } = Record<string, any>, TResultByName extends { [K in keyof TArgsByName]: unknown; } = { [K in keyof TArgsByName]: any; }> = { [K in keyof TArgsByName]: ToolkitDefinitionEntry<TArgsByName[K], TResultByName[K]>; };
+export type ToolkitDefinition<TArgsByName extends { [K in keyof TArgsByName]: Record<string, unknown>; } = Record<string, any>, TResultByName extends { [K in keyof TArgsByName]: unknown; } = { [K in keyof TArgsByName]: any; }> = { [K in keyof TArgsByName]: ToolkitDefinitionEntry<TArgsByName[K], TResultByName[K]>; };
 /** Configuration for the {@link Tools} resource. */
-type ToolsConfig = {
+export type ToolsConfig = {
   /** Tools to register with model context and, when provided, message renderers. */
   toolkit: Toolkit;
 };
 //#endregion
-export { ToolCallText, ToolDefinition, Toolkit, ToolkitDefinition, ToolkitDefinitionEntry, ToolkitDefinitionEntryWithParameters, ToolsConfig, isStandaloneToolDisplay, makeToolCallTextComponent };
 //# sourceMappingURL=toolbox.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"toolbox.d.ts","names":[],"sources":["../../../src/react/model-context/toolbox.ts"],"mappings":";;;;;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"}
+{"version":3,"file":"toolbox.d.ts","names":[],"sources":["../../../src/react/model-context/toolbox.ts"],"mappings":";;;;;YAgBY,aACV,cAAc,yBACd,WACE,eAAoB,OAAO,SAAS;;;;;;;;;;qBAW3B,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;qBAGE,4BACX,cAAc,yBACd,SAEA,MAAM,aAAa,OAAO,eACvB,MAAM,yBAAyB,OAAO,aAAa;;;;;;;;;YAc5C,eACV,cAAc,0BAA0B,yBACxC,qBACE,WAAW,KAAK,OAAO,UAAU,OAAO;;;;;;;;;;;;;;;;;;;YAoBhC,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;;;;;;;;;;YAYU,uBACV,cAAc,0BAA0B,yBACxC,qBACE,uBAAuB,OAAO,WAAW;YAEjC,qCACV,cAAc,0BAA0B,yBACxC,qBACE,uBAAuB,OAAO;EAChC,YAAY,YAAY,eAAe;;;;;;;YAQ7B,kBACV,uBACG,WAAW,cAAc,6BACxB,qBACJ,yBAAyB,WAAW,8BACjC,WAAW,2BAGb,WAAW,cAAc,uBACxB,YAAY,IACZ,cAAc;;YAKN;;EAEV,SAAS"}

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

@@ -1,7 +1,7 @@
 import { AssistantContextConfig } from "../../model-context/types.js";
 import "../../index.js";
 //#region src/react/model-context/useAssistantContext.d.ts
-declare const useAssistantContext: (config: AssistantContextConfig) => void;
+export declare const useAssistantContext: (config: AssistantContextConfig) => void;
 //#endregion
-export { type AssistantContextConfig, useAssistantContext };
+export type { AssistantContextConfig };
 //# sourceMappingURL=useAssistantContext.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useAssistantContext.d.ts","names":[],"sources":["../../../src/react/model-context/useAssistantContext.ts"],"mappings":";;;cAMa,sBAAuB,QAAQ"}
+{"version":3,"file":"useAssistantContext.d.ts","names":[],"sources":["../../../src/react/model-context/useAssistantContext.ts"],"mappings":";;;qBAMa,sBAAuB,QAAQ"}

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

@@ -1,7 +1,7 @@
 import { DataMessagePartComponent } from "../types/MessagePartComponentTypes.js";
 //#region src/react/model-context/useAssistantDataUI.d.ts
 /** Props used to register a renderer for `data` message parts. */
-type AssistantDataUIProps<T = any> = {
+export type AssistantDataUIProps<T = any> = {
   /** Data part name this renderer handles. */
   name: string;
   /** Component rendered for matching data message parts. */
@@ -13,7 +13,6 @@ type AssistantDataUIProps<T = any> = {
  *
  * @param dataUI - Data renderer registration, or `null` to skip registration.
  */
-declare const useAssistantDataUI: (dataUI: AssistantDataUIProps | null) => void;
+export declare const useAssistantDataUI: (dataUI: AssistantDataUIProps | null) => void;
 //#endregion
-export { AssistantDataUIProps, useAssistantDataUI };
 //# sourceMappingURL=useAssistantDataUI.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useAssistantDataUI.d.ts","names":[],"sources":["../../../src/react/model-context/useAssistantDataUI.ts"],"mappings":";;;KAKY,qBAAqB;;EAE/B;;EAEA,QAAQ,yBAAyB;;;;;;;;cAStB,qBAAsB,QAAQ"}
+{"version":3,"file":"useAssistantDataUI.d.ts","names":[],"sources":["../../../src/react/model-context/useAssistantDataUI.ts"],"mappings":";;;YAKY,qBAAqB;;EAE/B;;EAEA,QAAQ,yBAAyB;;;;;;;;qBAStB,qBAAsB,QAAQ"}

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

@@ -1,7 +1,7 @@
 import { AssistantInstructionsConfig } from "../../model-context/types.js";
 import "../../index.js";
 //#region src/react/model-context/useAssistantInstructions.d.ts
-declare const useAssistantInstructions: (config: string | AssistantInstructionsConfig) => void;
+export declare const useAssistantInstructions: (config: string | AssistantInstructionsConfig) => void;
 //#endregion
-export { type AssistantInstructionsConfig, useAssistantInstructions };
+export type { AssistantInstructionsConfig };
 //# sourceMappingURL=useAssistantInstructions.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useAssistantInstructions.d.ts","names":[],"sources":["../../../src/react/model-context/useAssistantInstructions.ts"],"mappings":";;;cAaa,2BACX,iBAAiB"}
+{"version":3,"file":"useAssistantInstructions.d.ts","names":[],"sources":["../../../src/react/model-context/useAssistantInstructions.ts"],"mappings":";;;qBAaa,2BACX,iBAAiB"}

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

@@ -10,7 +10,7 @@ import "../../index.js";
  * `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> & {
+export type AssistantToolProps<TArgs extends Record<string, unknown>, TResult> = AssistantToolProps$1<TArgs, TResult> & {
   /** Component used to render calls to this tool in assistant messages. */
   render?: ToolCallMessagePartComponent<TArgs, TResult> | undefined;
   /** Lightweight text rendered while a tool call is running or complete. */
@@ -50,7 +50,6 @@ type AssistantToolProps<TArgs extends Record<string, unknown>, TResult> = Assist
  * }
  * ```
  */
-declare const useAssistantTool: <TArgs extends Record<string, unknown>, TResult>(tool: AssistantToolProps<TArgs, TResult>) => void;
+export declare const useAssistantTool: <TArgs extends Record<string, unknown>, TResult>(tool: AssistantToolProps<TArgs, TResult>) => void;
 //#endregion
-export { AssistantToolProps, useAssistantTool };
 //# sourceMappingURL=useAssistantTool.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useAssistantTool.d.ts","names":[],"sources":["../../../src/react/model-context/useAssistantTool.ts"],"mappings":";;;;;;;;;;;;KAiBY,mBACV,cAAc,yBACd,WACE,qBAAuB,OAAO;;EAEhC,SAAS,6BAA6B,OAAO;;EAE7C,aAAa,aAAa,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqCtB,mBACX,cAAc,yBACd,SAEA,MAAM,mBAAmB,OAAO"}
+{"version":3,"file":"useAssistantTool.d.ts","names":[],"sources":["../../../src/react/model-context/useAssistantTool.ts"],"mappings":";;;;;;;;;;;;YAiBY,mBACV,cAAc,yBACd,WACE,qBAAuB,OAAO;;EAEhC,SAAS,6BAA6B,OAAO;;EAE7C,aAAa,aAAa,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAqCtB,mBACX,cAAc,yBACd,SAEA,MAAM,mBAAmB,OAAO"}