@assistant-ui/core 0.2.18 → 0.2.19

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

@@ -0,0 +1,53 @@
+import { Unstable_InteractableStateSchema } from "../types/scopes/interactables.js";
+import { ToolDefinition } from "./toolbox.js";
+import { Unstable_InferInteractableState, Unstable_InteractableVersionInfo } from "./useInteractable.js";
+import { ReactNode } from "react";
+
+//#region src/react/model-context/interactableTool.d.ts
+type Unstable_InteractableToolRenderProps<TState> = {
+  /**
+   * The live state. While `streaming` is true, fields the model has not
+   * finished generating may still be missing.
+   */
+  state: TState;
+  setState: (updater: TState | ((prev: TState) => TState)) => void;
+  /**
+   * This message's version of the instance: its state as of this point in the
+   * conversation, whether it is the most recent edit, and a `restore()` back
+   * to it. `undefined` while streaming.
+   */
+  version: Unstable_InteractableVersionInfo<TState> | undefined;
+  id: string; /** True while the tool call's arguments are still streaming in. */
+  streaming: boolean;
+};
+type Unstable_InteractableToolConfig<TSchema extends Unstable_InteractableStateSchema> = {
+  description: string;
+  stateSchema: TSchema;
+  render: (props: Unstable_InteractableToolRenderProps<Unstable_InferInteractableState<TSchema>>) => ReactNode;
+};
+/**
+ * Defines a tool that creates a thread-scoped interactable from its arguments,
+ * for assignment to a toolkit entry — the entry key is the interactable name:
+ *
+ * ```tsx
+ * notepad: unstable_interactableTool({
+ *   description: "A notepad the user can read and edit.",
+ *   stateSchema: notepadSchema,
+ *   render: (props) => <Notepad {...props} />,
+ * }),
+ * ```
+ *
+ * `render` shows at the creating call and — installed automatically — at every
+ * `update_{name}` call, with streaming previews, instance-id wiring, and
+ * registration handled. It receives the live `state`/`setState` plus this
+ * message's `version`; whether older messages render frozen history or stay
+ * live-editable is the render function's choice.
+ *
+ * @deprecated Unstable / Experimental (not actually removed).
+ */
+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

@@ -0,0 +1 @@
+{"version":3,"file":"interactableTool.d.ts","names":[],"sources":["../../../src/react/model-context/interactableTool.tsx"],"mappings":";;;;;;KAWY,oCAAA;;AAAZ;;;EAKE,KAAA,EAAO,MAAA;EACP,QAAA,GAAW,OAAA,EAAS,MAAA,KAAW,IAAA,EAAM,MAAA,KAAW,MAAA;EAAX;;;;;EAMrC,OAAA,EAAS,gCAAA,CAAiC,MAAA;EAC1C,EAAA,UARA;EAUA,SAAA;AAAA;AAAA,KAGU,+BAAA,iBACM,gCAAA;EAEhB,WAAA;EACA,WAAA,EAAa,OAAA;EACb,MAAA,GACE,KAAA,EAAO,oCAAA,CACL,+BAAA,CAAgC,OAAA,OAE/B,SAAA;AAAA;;;;;;;AAZI;AAGX;;;;;;;;;;;;;cAoCa,yBAAA,mBACK,gCAAA,EAEhB,MAAA,EAAQ,+BAAA,CAAgC,OAAA,MACvC,cAAA,CAAe,MAAA;EAA2B,OAAA;AAAA"}

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

@@ -0,0 +1,188 @@
+import { unstable_useInteractableState } from "./useInteractableState.js";
+import { unstable_useInteractable } from "./useInteractable.js";
+import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { Fragment, jsx } from "react/jsx-runtime";
+//#region src/react/model-context/interactableTool.tsx
+const noop = () => {};
+/**
+* Defines a tool that creates a thread-scoped interactable from its arguments,
+* for assignment to a toolkit entry — the entry key is the interactable name:
+*
+* ```tsx
+* notepad: unstable_interactableTool({
+*   description: "A notepad the user can read and edit.",
+*   stateSchema: notepadSchema,
+*   render: (props) => <Notepad {...props} />,
+* }),
+* ```
+*
+* `render` shows at the creating call and — installed automatically — at every
+* `update_{name}` call, with streaming previews, instance-id wiring, and
+* registration handled. It receives the live `state`/`setState` plus this
+* message's `version`; whether older messages render frozen history or stay
+* live-editable is the render function's choice.
+*
+* @deprecated Unstable / Experimental (not actually removed).
+*/
+const unstable_interactableTool = (config) => {
+	const Anchor = (t0) => {
+		const $ = c(10);
+		const { name, id, initial } = t0;
+		let t1;
+		if ($[0] !== id || $[1] !== initial) {
+			t1 = {
+				id,
+				description: config.description,
+				stateSchema: config.stateSchema,
+				initialState: initial,
+				updateRender: UpdateToolUI
+			};
+			$[0] = id;
+			$[1] = initial;
+			$[2] = t1;
+		} else t1 = $[2];
+		const [state, t2] = unstable_useInteractable(name, t1);
+		const { id: resolvedId, setState, version } = t2;
+		let t3;
+		if ($[3] !== resolvedId || $[4] !== setState || $[5] !== state || $[6] !== version) {
+			t3 = config.render({
+				state,
+				setState,
+				version,
+				id: resolvedId,
+				streaming: false
+			});
+			$[3] = resolvedId;
+			$[4] = setState;
+			$[5] = state;
+			$[6] = version;
+			$[7] = t3;
+		} else t3 = $[7];
+		let t4;
+		if ($[8] !== t3) {
+			t4 = /* @__PURE__ */ jsx(Fragment, { children: t3 });
+			$[8] = t3;
+			$[9] = t4;
+		} else t4 = $[9];
+		return t4;
+	};
+	const StreamingUpdate = (t0) => {
+		const $ = c(6);
+		const { id } = t0;
+		const [state, t1] = unstable_useInteractableState(id);
+		const { setState } = t1;
+		if (state === void 0) return null;
+		let t2;
+		if ($[0] !== id || $[1] !== setState || $[2] !== state) {
+			t2 = config.render({
+				state,
+				setState,
+				version: void 0,
+				id,
+				streaming: true
+			});
+			$[0] = id;
+			$[1] = setState;
+			$[2] = state;
+			$[3] = t2;
+		} else t2 = $[3];
+		let t3;
+		if ($[4] !== t2) {
+			t3 = /* @__PURE__ */ jsx(Fragment, { children: t2 });
+			$[4] = t2;
+			$[5] = t3;
+		} else t3 = $[5];
+		return t3;
+	};
+	const UpdateToolUI = (t0) => {
+		const $ = c(9);
+		const { toolName, args, result } = t0;
+		if (!result) {
+			let t1;
+			if ($[0] !== args.id) {
+				t1 = typeof args.id === "string" ? /* @__PURE__ */ jsx(StreamingUpdate, { id: args.id }) : null;
+				$[0] = args.id;
+				$[1] = t1;
+			} else t1 = $[1];
+			return t1;
+		}
+		if (!result.success) return null;
+		let partial;
+		if ($[2] !== args) {
+			const { id: _id, ...t1 } = args;
+			partial = t1;
+			$[2] = args;
+			$[3] = partial;
+		} else partial = $[3];
+		let t1;
+		if ($[4] !== toolName) {
+			t1 = toolName.slice(7);
+			$[4] = toolName;
+			$[5] = t1;
+		} else t1 = $[5];
+		const t2 = partial;
+		let t3;
+		if ($[6] !== t1 || $[7] !== t2) {
+			t3 = /* @__PURE__ */ jsx(Anchor, {
+				name: t1,
+				initial: t2
+			});
+			$[6] = t1;
+			$[7] = t2;
+			$[8] = t3;
+		} else t3 = $[8];
+		return t3;
+	};
+	const InteractableToolUI = (t0) => {
+		const $ = c(9);
+		const { toolName, toolCallId, args, result } = t0;
+		const state = args;
+		if (!result) {
+			let t1;
+			if ($[0] !== state || $[1] !== toolCallId) {
+				t1 = config.render({
+					state,
+					setState: noop,
+					version: void 0,
+					id: toolCallId,
+					streaming: true
+				});
+				$[0] = state;
+				$[1] = toolCallId;
+				$[2] = t1;
+			} else t1 = $[2];
+			let t2;
+			if ($[3] !== t1) {
+				t2 = /* @__PURE__ */ jsx(Fragment, { children: t1 });
+				$[3] = t1;
+				$[4] = t2;
+			} else t2 = $[4];
+			return t2;
+		}
+		let t1;
+		if ($[5] !== state || $[6] !== toolCallId || $[7] !== toolName) {
+			t1 = /* @__PURE__ */ jsx(Anchor, {
+				name: toolName,
+				id: toolCallId,
+				initial: state
+			});
+			$[5] = state;
+			$[6] = toolCallId;
+			$[7] = toolName;
+			$[8] = t1;
+		} else t1 = $[8];
+		return t1;
+	};
+	return {
+		type: "frontend",
+		description: config.description,
+		parameters: config.stateSchema,
+		display: "standalone",
+		execute: async () => ({ success: true }),
+		render: InteractableToolUI
+	};
+};
+//#endregion
+export { unstable_interactableTool };
+
+//# sourceMappingURL=interactableTool.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"interactableTool.js","names":["ReactNode","Unstable_InteractableStateSchema","ToolDefinition","ToolCallMessagePartComponent","unstable_useInteractable","useInteractable","Unstable_InferInteractableState","Unstable_InteractableVersionInfo","unstable_useInteractableState","useInteractableState","Unstable_InteractableToolRenderProps","state","TState","setState","updater","prev","version","id","streaming","Unstable_InteractableToolConfig","description","stateSchema","TSchema","render","props","noop","UPDATE_TOOL_PREFIX","unstable_interactableTool","config","Record","success","UpdateArgs","UpdateResult","error","Anchor","t0","$","_c","name","initial","t1","initialState","updateRender","UpdateToolUI","t2","resolvedId","t3","t4","StreamingUpdate","undefined","toolName","args","result","partial","_id","slice","length","InteractableToolUI","toolCallId","type","parameters","display","execute","const"],"sources":["../../../src/react/model-context/interactableTool.tsx"],"sourcesContent":["import type { ReactNode } from \"react\";\nimport type { Unstable_InteractableStateSchema } from \"../types/scopes/interactables\";\nimport type { ToolDefinition } from \"./toolbox\";\nimport type { ToolCallMessagePartComponent } from \"../types/MessagePartComponentTypes\";\nimport {\n  unstable_useInteractable as useInteractable,\n  type Unstable_InferInteractableState,\n  type Unstable_InteractableVersionInfo,\n} from \"./useInteractable\";\nimport { unstable_useInteractableState as useInteractableState } from \"./useInteractableState\";\n\nexport type Unstable_InteractableToolRenderProps<TState> = {\n  /**\n   * The live state. While `streaming` is true, fields the model has not\n   * finished generating may still be missing.\n   */\n  state: TState;\n  setState: (updater: TState | ((prev: TState) => TState)) => void;\n  /**\n   * This message's version of the instance: its state as of this point in the\n   * conversation, whether it is the most recent edit, and a `restore()` back\n   * to it. `undefined` while streaming.\n   */\n  version: Unstable_InteractableVersionInfo<TState> | undefined;\n  id: string;\n  /** True while the tool call's arguments are still streaming in. */\n  streaming: boolean;\n};\n\nexport type Unstable_InteractableToolConfig<\n  TSchema extends Unstable_InteractableStateSchema,\n> = {\n  description: string;\n  stateSchema: TSchema;\n  render: (\n    props: Unstable_InteractableToolRenderProps<\n      Unstable_InferInteractableState<TSchema>\n    >,\n  ) => ReactNode;\n};\n\nconst noop = () => {};\n\nconst UPDATE_TOOL_PREFIX = \"update_\";\n\n/**\n * Defines a tool that creates a thread-scoped interactable from its arguments,\n * for assignment to a toolkit entry — the entry key is the interactable name:\n *\n * ```tsx\n * notepad: unstable_interactableTool({\n *   description: \"A notepad the user can read and edit.\",\n *   stateSchema: notepadSchema,\n *   render: (props) => <Notepad {...props} />,\n * }),\n * ```\n *\n * `render` shows at the creating call and — installed automatically — at every\n * `update_{name}` call, with streaming previews, instance-id wiring, and\n * registration handled. It receives the live `state`/`setState` plus this\n * message's `version`; whether older messages render frozen history or stay\n * live-editable is the render function's choice.\n *\n * @deprecated Unstable / Experimental (not actually removed).\n */\nexport const unstable_interactableTool = <\n  TSchema extends Unstable_InteractableStateSchema,\n>(\n  config: Unstable_InteractableToolConfig<TSchema>,\n): ToolDefinition<Record<string, unknown>, { success: true }> => {\n  type TState = Unstable_InferInteractableState<TSchema>;\n  type UpdateArgs = { id?: string | undefined } & Record<string, unknown>;\n  type UpdateResult =\n    | { success: true; id: string }\n    | { success: false; error: string };\n\n  const Anchor = ({\n    name,\n    id,\n    initial,\n  }: {\n    name: string;\n    id?: string | undefined;\n    initial: TState;\n  }) => {\n    const [state, { id: resolvedId, setState, version }] = useInteractable(\n      name,\n      {\n        id,\n        description: config.description,\n        stateSchema: config.stateSchema,\n        initialState: initial,\n        updateRender: UpdateToolUI,\n      },\n    );\n    return (\n      <>\n        {config.render({\n          state,\n          setState,\n          version,\n          id: resolvedId,\n          streaming: false,\n        })}\n      </>\n    );\n  };\n\n  const StreamingUpdate = ({ id }: { id: string }) => {\n    const [state, { setState }] = useInteractableState<TState>(id);\n    if (state === undefined) return null;\n    return (\n      <>\n        {config.render({\n          state,\n          setState,\n          version: undefined,\n          id,\n          streaming: true,\n        })}\n      </>\n    );\n  };\n\n  const UpdateToolUI: ToolCallMessagePartComponent<\n    UpdateArgs,\n    UpdateResult\n  > = ({ toolName, args, result }) => {\n    if (!result) {\n      return typeof args.id === \"string\" ? (\n        <StreamingUpdate id={args.id} />\n      ) : null;\n    }\n    if (!result.success) return null;\n    const { id: _id, ...partial } = args;\n    // The interactable name is the creating tool's name (the toolkit entry\n    // key), so the update tool's name reverses by stripping the prefix.\n    return (\n      <Anchor\n        name={toolName.slice(UPDATE_TOOL_PREFIX.length)}\n        initial={partial as TState}\n      />\n    );\n  };\n\n  const InteractableToolUI: ToolCallMessagePartComponent<\n    Record<string, unknown>,\n    { success: true }\n  > = ({ toolName, toolCallId, args, result }) => {\n    const state = args as TState;\n    if (!result) {\n      return (\n        <>\n          {config.render({\n            state,\n            setState: noop,\n            version: undefined,\n            id: toolCallId,\n            streaming: true,\n          })}\n        </>\n      );\n    }\n    return <Anchor name={toolName} id={toolCallId} initial={state} />;\n  };\n\n  return {\n    type: \"frontend\",\n    description: config.description,\n    parameters: config.stateSchema,\n    display: \"standalone\",\n    execute: async () => ({ success: true as const }),\n    render: InteractableToolUI,\n  };\n};\n"],"mappings":"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"}

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

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

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

@@ -1,5 +1,5 @@
-import { useEffect } from "@assistant-ui/tap/react-shim";
 import { useAui } from "@assistant-ui/store";
+import { useEffect } from "@assistant-ui/tap/react-shim";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
 //#region src/react/model-context/useAssistantDataUI.ts
 /**

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

@@ -1,5 +1,5 @@
-import { useEffect } from "@assistant-ui/tap/react-shim";
 import { useAui } from "@assistant-ui/store";
+import { useEffect } from "@assistant-ui/tap/react-shim";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
 //#region src/react/model-context/useAssistantInstructions.ts
 const getInstructions = (instruction) => {

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

@@ -1,6 +1,6 @@
 import { isStandaloneToolDisplay, makeToolCallTextComponent } from "./toolbox.js";
-import { useEffect } from "@assistant-ui/tap/react-shim";
 import { useAui } from "@assistant-ui/store";
+import { useEffect } from "@assistant-ui/tap/react-shim";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
 //#region src/react/model-context/useAssistantTool.ts
 /**

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

@@ -1,5 +1,5 @@
-import { useEffect } from "@assistant-ui/tap/react-shim";
 import { useAui } from "@assistant-ui/store";
+import { useEffect } from "@assistant-ui/tap/react-shim";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
 //#region src/react/model-context/useAssistantToolUI.ts
 /**

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

@@ -1,5 +1,5 @@
-import { useEffect, useRef } from "@assistant-ui/tap/react-shim";
 import { useAui } from "@assistant-ui/store";
+import { useEffect, useRef } from "@assistant-ui/tap/react-shim";
 //#region src/react/model-context/useAuiToolOverrides.ts
 /**
 * Overrides toolkit entries for the current assistant scope.

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

@@ -0,0 +1,73 @@
+import { ToolCallMessagePartComponent } from "../types/MessagePartComponentTypes.js";
+import { Unstable_InteractableStateSchema } from "../types/scopes/interactables.js";
+
+//#region src/react/model-context/useInteractable.d.ts
+/**
+ * The state type described by an interactable's `stateSchema`. Resolves the
+ * output type of a StandardSchemaV1 schema (e.g. Zod); plain JSON Schema
+ * falls back to `unknown`.
+ */
+type Unstable_InferInteractableState<TSchema> = TSchema extends {
+  "~standard": {
+    types?: {
+      output: infer TOutput;
+    } | undefined;
+  };
+} ? TOutput : unknown;
+/**
+ * One message's version of an interactable, for components rendered inside
+ * tool-call parts. Show `state` to display history; call `restore()` to set
+ * the live instance back to it.
+ */
+type Unstable_InteractableVersionInfo<TState> = {
+  /** The interactable's state as it was at this message. */state: TState; /** Whether this message holds the instance's most recent tool-driven version. */
+  isLatest: boolean; /** Sets the live state back to this version. */
+  restore: () => void;
+};
+/**
+ * Unstable / Experimental — the interactables API is still evolving and may change in any release.
+ * @deprecated Unstable / Experimental (not actually removed).
+ */
+type Unstable_InteractableConfig<TSchema extends Unstable_InteractableStateSchema> = {
+  description: string;
+  stateSchema: TSchema;
+  initialState: Unstable_InferInteractableState<TSchema>; /** Unique instance ID; required to address this instance when multiple interactables share a name. Auto-generated if omitted. */
+  id?: string | undefined;
+  /**
+   * Component installed as the tool UI for this interactable's `update_{name}`
+   * tool calls, so a model edit re-renders the interactable at the message
+   * that made it instead of only mutating an earlier one. Prefer
+   * `unstable_interactableTool`, which wires this up. Pass a stable component reference;
+   * changing identity re-registers the tool UI.
+   */
+  updateRender?: ToolCallMessagePartComponent | undefined;
+};
+/**
+ * Registers an interactable with the AI assistant and returns its live state,
+ * like `useState` that the model can also read and update.
+ *
+ * Call this once per place that shows the interactable. Other components can
+ * read and write the same instance by passing its `id` to
+ * `unstable_useInteractableState`.
+ *
+ * For tool-created interactables rendered inside tool-call message parts,
+ * `version` carries this message's version of the instance — its state as of
+ * that point in the conversation, whether it is the most recent tool-driven
+ * version, and a `restore()` back to it. Whether older messages render frozen history or stay
+ * live-editable is the component's choice. Inside an `update_{name}` part the
+ * instance `id` is inferred from the call, so the same component works at the
+ * creating call and at update calls.
+ *
+ * @deprecated Unstable / Experimental (not actually removed).
+ */
+declare const unstable_useInteractable: <TSchema extends Unstable_InteractableStateSchema>(name: string, config: Unstable_InteractableConfig<TSchema>) => readonly [Unstable_InferInteractableState<TSchema>, {
+  id: string;
+  version: Unstable_InteractableVersionInfo<Unstable_InferInteractableState<TSchema>> | undefined;
+  setState: (updater: Unstable_InferInteractableState<TSchema> | ((prev: Unstable_InferInteractableState<TSchema>) => Unstable_InferInteractableState<TSchema>)) => void;
+  isPending: boolean;
+  error: unknown;
+  flush: () => Promise<void>;
+}];
+//#endregion
+export { Unstable_InferInteractableState, Unstable_InteractableConfig, Unstable_InteractableVersionInfo, unstable_useInteractable };
+//# sourceMappingURL=useInteractable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useInteractable.d.ts","names":[],"sources":["../../../src/react/model-context/useInteractable.ts"],"mappings":";;;;;;AAkBA;;;KAAY,+BAAA,YAA2C,OAAO;EAC5D,WAAA;IAAe,KAAA;MAAU,MAAA;IAAA;EAAA;AAAA,IAEvB,OAAA;;;AAAO;AAQX;;KAAY,gCAAA;EAEG,0DAAb,KAAA,EAAO,MAAM,EAAb;EAEA,QAAA;EAEA,OAAA;AAAA;AAAO;AAOT;;;AAPS,KAOG,2BAAA,iBACM,gCAAA;EAEhB,WAAA;EACA,WAAA,EAAa,OAAA;EACb,YAAA,EAAc,+BAAA,CAAgC,OAAA,GAU/B;EARf,EAAA;EAQ2C;;;;;;;EAA3C,YAAA,GAAe,4BAAA;AAAA;;;;;AAA4B;AAsJ7C;;;;;;;;;;;;;cAAa,wBAAA,mBACK,gCAAA,EAEhB,IAAA,UACA,MAAA,EAAQ,2BAAA,CAA4B,OAAA,gBAEpC,+BAAA,CAAgC,OAAA;EAE9B,EAAA;EACA,OAAA,EACI,gCAAA,CACE,+BAAA,CAAgC,OAAA;EAGtC,QAAA,GACE,OAAA,EACI,+BAAA,CAAgC,OAAA,MAE9B,IAAA,EAAM,+BAAA,CAAgC,OAAA,MACnC,+BAAA,CAAgC,OAAA;EAE3C,SAAA;EACA,KAAA;EACA,KAAA,QAAa,OAAA;AAAA"}

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

@@ -0,0 +1,100 @@
+"use client";
+import { interactableToolName, unstable_getInteractableVersions } from "../../model-context/interactable-composer-metadata.js";
+import { unstable_useInteractableState } from "./useInteractableState.js";
+import { useJSONEqual } from "../utils/useJSONEqual.js";
+import { useAui, useAuiState } from "@assistant-ui/store";
+import { useEffect, useId, useMemo, useRef } from "@assistant-ui/tap/react-shim";
+//#region src/react/model-context/useInteractable.ts
+const useInteractable = (name, config) => {
+	const aui = useAui();
+	const autoId = useId().replace(/[^a-zA-Z0-9]/g, "");
+	const inPart = aui.part.source != null;
+	const updateToolName = interactableToolName(name);
+	const part = useAuiState((s) => {
+		if (!inPart) return void 0;
+		const p = s.part;
+		return p.type === "tool-call" ? p : void 0;
+	});
+	let inferredId;
+	if (part?.toolName === updateToolName) {
+		const result = part.result;
+		const args = part.args;
+		if (result?.success !== false) {
+			if (typeof result?.id === "string") inferredId = result.id;
+			else if (typeof args?.id === "string") inferredId = args.id;
+		}
+	}
+	const id = config.id ?? inferredId ?? autoId;
+	const internalScope = part?.toolName === name || part?.toolName === updateToolName ? "thread" : void 0;
+	const stateSchemaRef = useRef(config.stateSchema);
+	stateSchemaRef.current = config.stateSchema;
+	const initialStateRef = useRef(config.initialState);
+	initialStateRef.current = config.initialState;
+	const interactables = useAuiState(() => aui.unstable_interactables());
+	useEffect(() => {
+		return interactables.register({
+			id,
+			name,
+			description: config.description,
+			stateSchema: stateSchemaRef.current,
+			initialState: initialStateRef.current,
+			updateRender: config.updateRender,
+			...internalScope ? { scope: internalScope } : {}
+		});
+	}, [
+		interactables,
+		id,
+		name,
+		config.description,
+		internalScope,
+		config.updateRender
+	]);
+	const myToolCallId = part?.toolCallId;
+	const [registeredState, methods] = unstable_useInteractableState(id);
+	const { setState } = methods;
+	const versionValue = useAuiState(useJSONEqual((s_0) => {
+		if (!internalScope || !myToolCallId) return void 0;
+		const versions = unstable_getInteractableVersions(s_0.thread.messages, id, name);
+		if (!versions.some((v) => v.origin === "create" && v.toolCallId === id)) return;
+		const mine = versions.find((v_0) => v_0.toolCallId === myToolCallId);
+		if (!mine) return void 0;
+		const latestToolCallId = versions.findLast((v_1) => v_1.toolCallId !== void 0)?.toolCallId;
+		return {
+			state: mine.state,
+			isLatest: latestToolCallId === myToolCallId
+		};
+	}));
+	const version = useMemo(() => versionValue && {
+		state: versionValue.state,
+		isLatest: versionValue.isLatest,
+		restore: () => setState(versionValue.state)
+	}, [versionValue, setState]);
+	return [registeredState === void 0 ? config.initialState : registeredState, {
+		id,
+		version,
+		...methods
+	}];
+};
+/**
+* Registers an interactable with the AI assistant and returns its live state,
+* like `useState` that the model can also read and update.
+*
+* Call this once per place that shows the interactable. Other components can
+* read and write the same instance by passing its `id` to
+* `unstable_useInteractableState`.
+*
+* For tool-created interactables rendered inside tool-call message parts,
+* `version` carries this message's version of the instance — its state as of
+* that point in the conversation, whether it is the most recent tool-driven
+* version, and a `restore()` back to it. Whether older messages render frozen history or stay
+* live-editable is the component's choice. Inside an `update_{name}` part the
+* instance `id` is inferred from the call, so the same component works at the
+* creating call and at update calls.
+*
+* @deprecated Unstable / Experimental (not actually removed).
+*/
+const unstable_useInteractable = useInteractable;
+//#endregion
+export { unstable_useInteractable };
+
+//# sourceMappingURL=useInteractable.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useInteractable.js","names":["useEffect","useId","useMemo","useRef","useAui","useAuiState","Unstable_InteractableStateSchema","ToolCallMessagePartComponent","unstable_getInteractableVersions","getInteractableVersions","interactableToolName","unstable_useInteractableState","useInteractableState","useJSONEqual","Unstable_InferInteractableState","TSchema","types","output","TOutput","Unstable_InteractableVersionInfo","state","TState","isLatest","restore","Unstable_InteractableConfig","description","stateSchema","initialState","id","updateRender","useInteractable","name","config","version","setState","updater","prev","isPending","error","flush","Promise","aui","autoId","replace","inPart","part","source","updateToolName","s","undefined","p","type","inferredId","toolName","result","Record","args","success","internalScope","stateSchemaRef","current","initialStateRef","interactables","unstable_interactables","register","scope","Parameters","myToolCallId","toolCallId","registeredState","methods","versionValue","versions","thread","messages","some","v","origin","mine","find","latestToolCallId","findLast","const","unstable_useInteractable"],"sources":["../../../src/react/model-context/useInteractable.ts"],"sourcesContent":["\"use client\";\n\nimport { useEffect, useId, useMemo, useRef } from \"react\";\nimport { useAui, useAuiState } from \"@assistant-ui/store\";\nimport type { Unstable_InteractableStateSchema } from \"../types/scopes/interactables\";\nimport type { ToolCallMessagePartComponent } from \"../types/MessagePartComponentTypes\";\nimport {\n  unstable_getInteractableVersions as getInteractableVersions,\n  interactableToolName,\n} from \"../../model-context/interactable-composer-metadata\";\nimport { unstable_useInteractableState as useInteractableState } from \"./useInteractableState\";\nimport { useJSONEqual } from \"../utils/useJSONEqual\";\n\n/**\n * The state type described by an interactable's `stateSchema`. Resolves the\n * output type of a StandardSchemaV1 schema (e.g. Zod); plain JSON Schema\n * falls back to `unknown`.\n */\nexport type Unstable_InferInteractableState<TSchema> = TSchema extends {\n  \"~standard\": { types?: { output: infer TOutput } | undefined };\n}\n  ? TOutput\n  : unknown;\n\n/**\n * One message's version of an interactable, for components rendered inside\n * tool-call parts. Show `state` to display history; call `restore()` to set\n * the live instance back to it.\n */\nexport type Unstable_InteractableVersionInfo<TState> = {\n  /** The interactable's state as it was at this message. */\n  state: TState;\n  /** Whether this message holds the instance's most recent tool-driven version. */\n  isLatest: boolean;\n  /** Sets the live state back to this version. */\n  restore: () => void;\n};\n\n/**\n * Unstable / Experimental — the interactables API is still evolving and may change in any release.\n * @deprecated Unstable / Experimental (not actually removed).\n */\nexport type Unstable_InteractableConfig<\n  TSchema extends Unstable_InteractableStateSchema,\n> = {\n  description: string;\n  stateSchema: TSchema;\n  initialState: Unstable_InferInteractableState<TSchema>;\n  /** Unique instance ID; required to address this instance when multiple interactables share a name. Auto-generated if omitted. */\n  id?: string | undefined;\n  /**\n   * Component installed as the tool UI for this interactable's `update_{name}`\n   * tool calls, so a model edit re-renders the interactable at the message\n   * that made it instead of only mutating an earlier one. Prefer\n   * `unstable_interactableTool`, which wires this up. Pass a stable component reference;\n   * changing identity re-registers the tool UI.\n   */\n  updateRender?: ToolCallMessagePartComponent | undefined;\n};\n\nconst useInteractable = <TSchema extends Unstable_InteractableStateSchema>(\n  name: string,\n  config: Unstable_InteractableConfig<TSchema>,\n): readonly [\n  Unstable_InferInteractableState<TSchema>,\n  {\n    id: string;\n    /**\n     * This message's version of the instance, when rendered inside a\n     * tool-created interactable message part; `undefined` elsewhere.\n     */\n    version:\n      | Unstable_InteractableVersionInfo<\n          Unstable_InferInteractableState<TSchema>\n        >\n      | undefined;\n    setState: (\n      updater:\n        | Unstable_InferInteractableState<TSchema>\n        | ((\n            prev: Unstable_InferInteractableState<TSchema>,\n          ) => Unstable_InferInteractableState<TSchema>),\n    ) => void;\n    isPending: boolean;\n    error: unknown;\n    flush: () => Promise<void>;\n  },\n] => {\n  const aui = useAui();\n\n  const autoId = useId().replace(/[^a-zA-Z0-9]/g, \"\");\n\n  // Whether this component renders inside a message part is fixed for its\n  // lifetime, so conditioning the selectors on it is safe.\n  const inPart = aui.part.source != null;\n  const updateToolName = interactableToolName(name);\n  const part = useAuiState((s) => {\n    if (!inPart) return undefined;\n    const p = s.part;\n    return p.type === \"tool-call\" ? p : undefined;\n  });\n\n  // Inside an update_{name} part, the instance id comes from the call itself:\n  // the result's resolved id (covers id-less calls), or the id argument.\n  let inferredId: string | undefined;\n  if (part?.toolName === updateToolName) {\n    const result = part.result as Record<string, unknown> | undefined;\n    const args = part.args as Record<string, unknown> | undefined;\n    if (result?.success !== false) {\n      if (typeof result?.id === \"string\") inferredId = result.id;\n      else if (typeof args?.id === \"string\") inferredId = args.id;\n    }\n  }\n\n  const id = config.id ?? inferredId ?? autoId;\n  const internalScope =\n    part?.toolName === name || part?.toolName === updateToolName\n      ? \"thread\"\n      : undefined;\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  const interactables = useAuiState(() => aui.unstable_interactables());\n\n  useEffect(() => {\n    return interactables.register({\n      id,\n      name,\n      description: config.description,\n      stateSchema: stateSchemaRef.current,\n      initialState: initialStateRef.current,\n      updateRender: config.updateRender,\n      ...(internalScope ? { scope: internalScope } : {}),\n    } as Parameters<typeof interactables.register>[0] & {\n      scope?: \"thread\" | undefined;\n    });\n  }, [\n    interactables,\n    id,\n    name,\n    config.description,\n    internalScope,\n    config.updateRender,\n  ]);\n\n  const myToolCallId = part?.toolCallId;\n\n  const [registeredState, methods] =\n    useInteractableState<Unstable_InferInteractableState<TSchema>>(id);\n  const { setState } = methods;\n\n  const versionValue = useAuiState(\n    useJSONEqual((s) => {\n      if (!internalScope || !myToolCallId) return undefined;\n      const versions = getInteractableVersions(s.thread.messages, id, name);\n      if (!versions.some((v) => v.origin === \"create\" && v.toolCallId === id)) {\n        return undefined;\n      }\n      const mine = versions.find((v) => v.toolCallId === myToolCallId);\n      if (!mine) return undefined;\n      const latestToolCallId = versions.findLast(\n        (v) => v.toolCallId !== undefined,\n      )?.toolCallId;\n      return { state: mine.state, isLatest: latestToolCallId === myToolCallId };\n    }),\n  );\n\n  const version = useMemo(\n    () =>\n      versionValue && {\n        state: versionValue.state as Unstable_InferInteractableState<TSchema>,\n        isLatest: versionValue.isLatest,\n        restore: () =>\n          setState(\n            versionValue.state as Unstable_InferInteractableState<TSchema>,\n          ),\n      },\n    [versionValue, setState],\n  );\n\n  const state =\n    registeredState === undefined ? config.initialState : registeredState;\n\n  return [state, { id, version, ...methods }] as const;\n};\n\n/**\n * Registers an interactable with the AI assistant and returns its live state,\n * like `useState` that the model can also read and update.\n *\n * Call this once per place that shows the interactable. Other components can\n * read and write the same instance by passing its `id` to\n * `unstable_useInteractableState`.\n *\n * For tool-created interactables rendered inside tool-call message parts,\n * `version` carries this message's version of the instance — its state as of\n * that point in the conversation, whether it is the most recent tool-driven\n * version, and a `restore()` back to it. Whether older messages render frozen history or stay\n * live-editable is the component's choice. Inside an `update_{name}` part the\n * instance `id` is inferred from the call, so the same component works at the\n * creating call and at update calls.\n *\n * @deprecated Unstable / Experimental (not actually removed).\n */\nexport const unstable_useInteractable: <\n  TSchema extends Unstable_InteractableStateSchema,\n>(\n  name: string,\n  config: Unstable_InteractableConfig<TSchema>,\n) => readonly [\n  Unstable_InferInteractableState<TSchema>,\n  {\n    id: string;\n    version:\n      | Unstable_InteractableVersionInfo<\n          Unstable_InferInteractableState<TSchema>\n        >\n      | undefined;\n    setState: (\n      updater:\n        | Unstable_InferInteractableState<TSchema>\n        | ((\n            prev: Unstable_InferInteractableState<TSchema>,\n          ) => Unstable_InferInteractableState<TSchema>),\n    ) => void;\n    isPending: boolean;\n    error: unknown;\n    flush: () => Promise<void>;\n  },\n] = useInteractable;\n"],"mappings":";;;;;;;AA4DA,MAAM8B,mBACJC,MACAC,WAyBG;CACH,MAAMS,MAAMrC,OAAO;CAEnB,MAAMsC,SAASzC,MAAM,CAAC,CAAC0C,QAAQ,iBAAiB,EAAE;CAIlD,MAAMC,SAASH,IAAII,KAAKC,UAAU;CAClC,MAAMC,iBAAiBrC,qBAAqBqB,IAAI;CAChD,MAAMc,OAAOxC,aAAa2C,MAAM;EAC9B,IAAI,CAACJ,QAAQ,OAAOK,KAAAA;EACpB,MAAMC,IAAIF,EAAEH;EACZ,OAAOK,EAAEC,SAAS,cAAcD,IAAID,KAAAA;CACtC,CAAC;CAID,IAAIG;CACJ,IAAIP,MAAMQ,aAAaN,gBAAgB;EACrC,MAAMO,SAAST,KAAKS;EACpB,MAAME,OAAOX,KAAKW;EAClB,IAAIF,QAAQG,YAAY;OAClB,OAAOH,QAAQ1B,OAAO,UAAUwB,aAAaE,OAAO1B;QACnD,IAAI,OAAO4B,MAAM5B,OAAO,UAAUwB,aAAaI,KAAK5B;EAAAA;CAE7D;CAEA,MAAMA,KAAKI,OAAOJ,MAAMwB,cAAcV;CACtC,MAAMgB,gBACJb,MAAMQ,aAAatB,QAAQc,MAAMQ,aAAaN,iBAC1C,WACAE,KAAAA;CAEN,MAAMU,iBAAiBxD,OAAO6B,OAAON,WAAW;CAChDiC,eAAeC,UAAU5B,OAAON;CAChC,MAAMmC,kBAAkB1D,OAAO6B,OAAOL,YAAY;CAClDkC,gBAAgBD,UAAU5B,OAAOL;CAEjC,MAAMmC,gBAAgBzD,kBAAkBoC,IAAIsB,uBAAuB,CAAC;CAEpE/D,gBAAgB;EACd,OAAO8D,cAAcE,SAAS;GAC5BpC;GACAG;GACAN,aAAaO,OAAOP;GACpBC,aAAaiC,eAAeC;GAC5BjC,cAAckC,gBAAgBD;GAC9B/B,cAAcG,OAAOH;GACrB,GAAI6B,gBAAgB,EAAEO,OAAOP,cAAc,IAAI,CAAC;EAClD,CAEC;CACH,GAAG;EACDI;EACAlC;EACAG;EACAC,OAAOP;EACPiC;EACA1B,OAAOH;CAAY,CACpB;CAED,MAAMsC,eAAetB,MAAMuB;CAE3B,MAAM,CAACC,iBAAiBC,WACtB1D,8BAA+DgB,EAAE;CACnE,MAAM,EAAEM,aAAaoC;CAErB,MAAMC,eAAelE,YACnBQ,cAAcmC,QAAM;EAClB,IAAI,CAACU,iBAAiB,CAACS,cAAc,OAAOlB,KAAAA;EAC5C,MAAMuB,WAAW/D,iCAAwBuC,IAAEyB,OAAOC,UAAU9C,IAAIG,IAAI;EACpE,IAAI,CAACyC,SAASG,MAAMC,MAAMA,EAAEC,WAAW,YAAYD,EAAER,eAAexC,EAAE,GACpE;EAEF,MAAMkD,OAAON,SAASO,MAAMH,QAAMA,IAAER,eAAeD,YAAY;EAC/D,IAAI,CAACW,MAAM,OAAO7B,KAAAA;EAClB,MAAM+B,mBAAmBR,SAASS,UAC/BL,QAAMA,IAAER,eAAenB,KAAAA,CAC1B,CAAC,EAAEmB;EACH,OAAO;GAAEhD,OAAO0D,KAAK1D;GAAOE,UAAU0D,qBAAqBb;EAAa;CAC1E,CAAC,CACH;CAEA,MAAMlC,UAAU/B,cAEZqE,gBAAgB;EACdnD,OAAOmD,aAAanD;EACpBE,UAAUiD,aAAajD;EACvBC,eACEW,SACEqC,aAAanD,KACf;CACJ,GACF,CAACmD,cAAcrC,QAAQ,CACzB;CAKA,OAAO,CAFLmC,oBAAoBpB,KAAAA,IAAYjB,OAAOL,eAAe0C,iBAEzC;EAAEzC;EAAIK;EAAS,GAAGqC;CAAQ,CAAC;AAC5C;;;;;;;;;;;;;;;;;;;AAoBA,MAAaa,2BAyBTrD"}

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

@@ -1,17 +1,20 @@
 //#region src/react/model-context/useInteractableState.d.ts
 type StateUpdater<TState> = TState | ((prev: TState) => TState);
 /**
- * Reads and writes the state of a registered interactable.
+ * Reads and writes the state of an interactable registered elsewhere, by id.
  *
- * Pair with {@link useAssistantInteractable} which handles registration.
+ * Use this from secondary readers (children, siblings); the owning component
+ * registers with `unstable_useInteractable`, which returns state directly. Returns
+ * `undefined` until the owning interactable is registered.
+ *
+ * @deprecated Unstable / Experimental (not actually removed).
  */
-declare const useInteractableState: <TState>(id: string, fallback: TState) => [TState, {
+declare const unstable_useInteractableState: <TState>(id: string) => [TState | undefined, {
   setState: (updater: StateUpdater<TState>) => void;
-  setSelected: (selected: boolean) => void;
   isPending: boolean;
   error: unknown;
   flush: () => Promise<void>;
 }];
 //#endregion
-export { useInteractableState };
+export { unstable_useInteractableState };
 //# sourceMappingURL=useInteractableState.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useInteractableState.d.ts","names":[],"sources":["../../../src/react/model-context/useInteractableState.ts"],"mappings":";KAGK,YAAA,WAAuB,MAAA,KAAW,IAAA,EAAM,MAAA,KAAW,MAAA;;;;;;cAO3C,oBAAA,WACX,EAAA,UACA,QAAA,EAAU,MAAA,MAEV,MAAA;EAEE,QAAA,GAAW,OAAA,EAAS,YAAA,CAAa,MAAA;EACjC,WAAA,GAAc,QAAA;EACd,SAAA;EACA,KAAA;EACA,KAAA,QAAa,OAAA;AAAA"}
+{"version":3,"file":"useInteractableState.d.ts","names":[],"sources":["../../../src/react/model-context/useInteractableState.ts"],"mappings":";KAKK,YAAA,WAAuB,MAAA,KAAW,IAAA,EAAM,MAAA,KAAW,MAAA;;;;;;;;;;cAyD3C,6BAAA,WAAwC,EAAA,cACnD,MAAA;EAEE,QAAA,GAAW,OAAA,EAAS,YAAA,CAAa,MAAA;EACjC,SAAA;EACA,KAAA;EACA,KAAA,QAAa,OAAA;AAAA"}