@assistant-ui/vue 0.0.0 → 0.0.1

package/dist/primitives/ChainOfThoughtPrimitiveParts.js

@@ -0,0 +1,85 @@
+import { useAuiState } from "../useAuiState.js";
+import { AuiProvider } from "../AuiProvider.js";
+import { useAui } from "../useAui.js";
+import { createLastValidCache as createLastValidCache$1, createStaleReporter } from "./lastValidCache.js";
+import { useStableKeys } from "./stableKeys.js";
+import { computed, defineComponent, h, onScopeDispose } from "vue";
+import { AuiConfig, Derived } from "@assistant-ui/store/client";
+import { getMessagePartKeys } from "@assistant-ui/core/internal";
+//#region src/primitives/ChainOfThoughtPrimitiveParts.ts
+const ChainOfThoughtPartByIndexProvider = defineComponent({
+	name: "ChainOfThoughtPartByIndexProvider",
+	props: { index: {
+		type: Number,
+		required: true
+	} },
+	slots: Object,
+	setup(props, { slots }) {
+		const aui = useAui();
+		let disposed = false;
+		onScopeDispose(() => {
+			disposed = true;
+		});
+		const config = computed(() => {
+			const index = props.index;
+			const cache = createLastValidCache$1(createStaleReporter({
+				name: "ChainOfThoughtPartByIndexProvider",
+				index,
+				isCurrent: () => !disposed && index === props.index,
+				isValid: () => index < aui.chainOfThought.getState().parts.length
+			}));
+			return AuiConfig({ part: Derived({
+				source: "chainOfThought",
+				query: {
+					type: "index",
+					index
+				},
+				get: (aui) => {
+					const valid = index < aui.chainOfThought.getState().parts.length;
+					try {
+						return cache.resolve(valid, () => aui.chainOfThought.part({ index }));
+					} catch (error) {
+						return cache.resolve(false, () => {
+							throw error;
+						});
+					}
+				}
+			}) });
+		});
+		return () => h(AuiProvider, {
+			config: config.value,
+			extends: aui
+		}, { default: () => slots.default?.() });
+	}
+});
+const ChainOfThoughtPartView = defineComponent({
+	name: "ChainOfThoughtPartView",
+	slots: Object,
+	setup(_, { slots }) {
+		const part = useAuiState((s) => s.part);
+		return () => slots.default?.({ part: part.value });
+	}
+});
+/**
+* Renders the parts within a chain of thought through the default slot, one
+* invocation per entry of `s.chainOfThought.parts`.
+*
+* Rendering is not gated on `s.chainOfThought.collapsed`; gate visibility in
+* the caller (for example with `AuiIf`), matching the React primitive.
+*/
+const ChainOfThoughtPrimitiveParts = defineComponent({
+	name: "ChainOfThoughtPrimitiveParts",
+	slots: Object,
+	setup(_, { slots }) {
+		const parts = useAuiState((s) => s.chainOfThought.parts);
+		const partKeys = useStableKeys(() => getMessagePartKeys(parts.value));
+		return () => partKeys.value.map((key, index) => h(ChainOfThoughtPartByIndexProvider, {
+			index,
+			key
+		}, { default: () => h(ChainOfThoughtPartView, null, { default: slots.default }) }));
+	}
+});
+//#endregion
+export { ChainOfThoughtPrimitiveParts };
+
+//# sourceMappingURL=ChainOfThoughtPrimitiveParts.js.map

package/dist/primitives/ChainOfThoughtPrimitiveParts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChainOfThoughtPrimitiveParts.js","names":["createLastValidCache"],"sources":["../../src/primitives/ChainOfThoughtPrimitiveParts.ts"],"sourcesContent":["import {\n  computed,\n  defineComponent,\n  h,\n  onScopeDispose,\n  type SlotsType,\n  type VNodeChild,\n} from \"vue\";\nimport type { PartMethods, PartState } from \"@assistant-ui/core/store\";\nimport { getMessagePartKeys } from \"@assistant-ui/core/internal\";\nimport { AuiConfig, Derived } from \"@assistant-ui/store/client\";\nimport { AuiProvider } from \"../AuiProvider\";\nimport { useAui } from \"../useAui\";\nimport { useAuiState } from \"../useAuiState\";\nimport { createLastValidCache, createStaleReporter } from \"./lastValidCache\";\nimport { useStableKeys } from \"./stableKeys\";\n\ntype ChainOfThoughtPartsSlots = {\n  default?: (props: { part: PartState }) => VNodeChild[];\n};\n\nconst ChainOfThoughtPartByIndexProvider = defineComponent({\n  name: \"ChainOfThoughtPartByIndexProvider\",\n  props: {\n    index: {\n      type: Number,\n      required: true,\n    },\n  },\n  slots: Object as SlotsType<{ default?: () => VNodeChild[] }>,\n  setup(props, { slots }) {\n    const aui = useAui();\n    let disposed = false;\n    onScopeDispose(() => {\n      disposed = true;\n    });\n    const config = computed(() => {\n      const index = props.index;\n      const cache = createLastValidCache<PartMethods>(\n        createStaleReporter({\n          name: \"ChainOfThoughtPartByIndexProvider\",\n          index,\n          isCurrent: () => !disposed && index === props.index,\n          isValid: () => index < aui.chainOfThought.getState().parts.length,\n        }),\n      );\n      return AuiConfig({\n        part: Derived({\n          source: \"chainOfThought\",\n          query: { type: \"index\", index },\n          // chainOfThought.part() delegates to a userland getMessagePart, so\n          // validity is not decided by parts.length alone; a lookup throw is\n          // absorbed into the stale cache like an invalid index.\n          get: (aui) => {\n            const valid = index < aui.chainOfThought.getState().parts.length;\n            try {\n              return cache.resolve(valid, () =>\n                aui.chainOfThought.part({ index }),\n              );\n            } catch (error) {\n              return cache.resolve(false, () => {\n                throw error;\n              });\n            }\n          },\n        }),\n      });\n    });\n    return () =>\n      h(\n        AuiProvider,\n        { config: config.value, extends: aui },\n        { default: () => slots.default?.() },\n      );\n  },\n});\n\nconst ChainOfThoughtPartView = defineComponent({\n  name: \"ChainOfThoughtPartView\",\n  slots: Object as SlotsType<ChainOfThoughtPartsSlots>,\n  setup(_, { slots }) {\n    const part = useAuiState((s) => s.part);\n    return () => slots.default?.({ part: part.value });\n  },\n});\n\n/**\n * Renders the parts within a chain of thought through the default slot, one\n * invocation per entry of `s.chainOfThought.parts`.\n *\n * Rendering is not gated on `s.chainOfThought.collapsed`; gate visibility in\n * the caller (for example with `AuiIf`), matching the React primitive.\n */\nexport const ChainOfThoughtPrimitiveParts = defineComponent({\n  name: \"ChainOfThoughtPrimitiveParts\",\n  slots: Object as SlotsType<ChainOfThoughtPartsSlots>,\n  setup(_, { slots }) {\n    const parts = useAuiState((s) => s.chainOfThought.parts);\n    const partKeys = useStableKeys(() => getMessagePartKeys(parts.value));\n    return () =>\n      partKeys.value.map((key, index) =>\n        h(\n          ChainOfThoughtPartByIndexProvider,\n          { index, key },\n          {\n            default: () =>\n              h(ChainOfThoughtPartView, null, { default: slots.default }),\n          },\n        ),\n      );\n  },\n});\n"],"mappings":";;;;;;;;;AAqBA,MAAM,oCAAoC,gBAAgB;CACxD,MAAM;CACN,OAAO,EACL,OAAO;EACL,MAAM;EACN,UAAU;CACZ,EACF;CACA,OAAO;CACP,MAAM,OAAO,EAAE,SAAS;EACtB,MAAM,MAAM,OAAO;EACnB,IAAI,WAAW;EACf,qBAAqB;GACnB,WAAW;EACb,CAAC;EACD,MAAM,SAAS,eAAe;GAC5B,MAAM,QAAQ,MAAM;GACpB,MAAM,QAAQA,uBACZ,oBAAoB;IAClB,MAAM;IACN;IACA,iBAAiB,CAAC,YAAY,UAAU,MAAM;IAC9C,eAAe,QAAQ,IAAI,eAAe,SAAS,CAAC,CAAC,MAAM;GAC7D,CAAC,CACH;GACA,OAAO,UAAU,EACf,MAAM,QAAQ;IACZ,QAAQ;IACR,OAAO;KAAE,MAAM;KAAS;IAAM;IAI9B,MAAM,QAAQ;KACZ,MAAM,QAAQ,QAAQ,IAAI,eAAe,SAAS,CAAC,CAAC,MAAM;KAC1D,IAAI;MACF,OAAO,MAAM,QAAQ,aACnB,IAAI,eAAe,KAAK,EAAE,MAAM,CAAC,CACnC;KACF,SAAS,OAAO;MACd,OAAO,MAAM,QAAQ,aAAa;OAChC,MAAM;MACR,CAAC;KACH;IACF;GACF,CAAC,EACH,CAAC;EACH,CAAC;EACD,aACE,EACE,aACA;GAAE,QAAQ,OAAO;GAAO,SAAS;EAAI,GACrC,EAAE,eAAe,MAAM,UAAU,EAAE,CACrC;CACJ;AACF,CAAC;AAED,MAAM,yBAAyB,gBAAgB;CAC7C,MAAM;CACN,OAAO;CACP,MAAM,GAAG,EAAE,SAAS;EAClB,MAAM,OAAO,aAAa,MAAM,EAAE,IAAI;EACtC,aAAa,MAAM,UAAU,EAAE,MAAM,KAAK,MAAM,CAAC;CACnD;AACF,CAAC;;;;;;;;AASD,MAAa,+BAA+B,gBAAgB;CAC1D,MAAM;CACN,OAAO;CACP,MAAM,GAAG,EAAE,SAAS;EAClB,MAAM,QAAQ,aAAa,MAAM,EAAE,eAAe,KAAK;EACvD,MAAM,WAAW,oBAAoB,mBAAmB,MAAM,KAAK,CAAC;EACpE,aACE,SAAS,MAAM,KAAK,KAAK,UACvB,EACE,mCACA;GAAE;GAAO;EAAI,GACb,EACE,eACE,EAAE,wBAAwB,MAAM,EAAE,SAAS,MAAM,QAAQ,CAAC,EAC9D,CACF,CACF;CACJ;AACF,CAAC"}

package/dist/primitives/ComposerPrimitiveCancel.d.ts

@@ -0,0 +1,12 @@
+import { type SlotsType, type VNodeChild } from "vue";
+/**
+ * A button that cancels the current run. Disabled while nothing can be
+ * cancelled. A fallthrough click listener runs first and can veto the cancel
+ * with `preventDefault`.
+ */
+export declare const ComposerPrimitiveCancel: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, SlotsType<{
+    default?: () => VNodeChild[];
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=ComposerPrimitiveCancel.d.ts.map

package/dist/primitives/ComposerPrimitiveCancel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComposerPrimitiveCancel.d.ts","sourceRoot":"","sources":["../../src/primitives/ComposerPrimitiveCancel.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,SAAS,EACd,KAAK,UAAU,EAChB,MAAM,KAAK,CAAC;AAMb;;;;GAIG;AACH,eAAO,MAAM,uBAAuB;;;cAGK,MAAM,UAAU,EAAE;yEAoBzD,CAAC"}

package/dist/primitives/ComposerPrimitiveCancel.js

@@ -0,0 +1,33 @@
+import { useAuiState } from "../useAuiState.js";
+import { useAui } from "../useAui.js";
+import { isAttrDisabled } from "./attrDisabled.js";
+import { defineComponent, h, mergeProps } from "vue";
+import { composerCancelDisabled } from "@assistant-ui/core/store/internal";
+//#region src/primitives/ComposerPrimitiveCancel.ts
+/**
+* A button that cancels the current run. Disabled while nothing can be
+* cancelled. A fallthrough click listener runs first and can veto the cancel
+* with `preventDefault`.
+*/
+const ComposerPrimitiveCancel = defineComponent({
+	name: "ComposerPrimitiveCancel",
+	inheritAttrs: false,
+	slots: Object,
+	setup(_, { attrs, slots }) {
+		const aui = useAui();
+		const disabled = useAuiState(composerCancelDisabled);
+		const onClick = (event) => {
+			if (event.defaultPrevented || disabled.value || isAttrDisabled(attrs)) return;
+			aui.composer.cancel();
+		};
+		return () => h("button", mergeProps(attrs, {
+			type: "button",
+			disabled: disabled.value || isAttrDisabled(attrs),
+			onClick
+		}), slots.default?.());
+	}
+});
+//#endregion
+export { ComposerPrimitiveCancel };
+
+//# sourceMappingURL=ComposerPrimitiveCancel.js.map

package/dist/primitives/ComposerPrimitiveCancel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComposerPrimitiveCancel.js","names":[],"sources":["../../src/primitives/ComposerPrimitiveCancel.ts"],"sourcesContent":["import {\n  defineComponent,\n  h,\n  mergeProps,\n  type SlotsType,\n  type VNodeChild,\n} from \"vue\";\nimport { composerCancelDisabled } from \"@assistant-ui/core/store/internal\";\nimport { isAttrDisabled } from \"./attrDisabled\";\nimport { useAui } from \"../useAui\";\nimport { useAuiState } from \"../useAuiState\";\n\n/**\n * A button that cancels the current run. Disabled while nothing can be\n * cancelled. A fallthrough click listener runs first and can veto the cancel\n * with `preventDefault`.\n */\nexport const ComposerPrimitiveCancel = defineComponent({\n  name: \"ComposerPrimitiveCancel\",\n  inheritAttrs: false,\n  slots: Object as SlotsType<{ default?: () => VNodeChild[] }>,\n  setup(_, { attrs, slots }) {\n    const aui = useAui();\n    const disabled = useAuiState(composerCancelDisabled);\n    const onClick = (event: MouseEvent) => {\n      if (event.defaultPrevented || disabled.value || isAttrDisabled(attrs))\n        return;\n      aui.composer.cancel();\n    };\n    return () =>\n      h(\n        \"button\",\n        mergeProps(attrs, {\n          type: \"button\",\n          disabled: disabled.value || isAttrDisabled(attrs),\n          onClick,\n        }),\n        slots.default?.(),\n      );\n  },\n});\n"],"mappings":";;;;;;;;;;;AAiBA,MAAa,0BAA0B,gBAAgB;CACrD,MAAM;CACN,cAAc;CACd,OAAO;CACP,MAAM,GAAG,EAAE,OAAO,SAAS;EACzB,MAAM,MAAM,OAAO;EACnB,MAAM,WAAW,YAAY,sBAAsB;EACnD,MAAM,WAAW,UAAsB;GACrC,IAAI,MAAM,oBAAoB,SAAS,SAAS,eAAe,KAAK,GAClE;GACF,IAAI,SAAS,OAAO;EACtB;EACA,aACE,EACE,UACA,WAAW,OAAO;GAChB,MAAM;GACN,UAAU,SAAS,SAAS,eAAe,KAAK;GAChD;EACF,CAAC,GACD,MAAM,UAAU,CAClB;CACJ;AACF,CAAC"}

package/dist/primitives/ComposerPrimitiveInput.d.ts

@@ -0,0 +1,26 @@
+import { type SlotsType } from "vue";
+/**
+ * A textarea bound to the composer text, disabled while the thread is
+ * disabled. Enter submits (Shift+Enter inserts a newline, IME composition is
+ * ignored) unless `submitOnEnter` is false; an Enter that cannot send falls
+ * through to a newline, and a fallthrough keydown listener can veto the
+ * submit with `preventDefault`. While the composer is not editing (an edit
+ * composer before `beginEdit`), the value stays controlled to the empty
+ * composer text.
+ */
+export declare const ComposerPrimitiveInput: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    submitOnEnter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    submitOnEnter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    submitOnEnter: boolean;
+}, SlotsType<Record<string, never>>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=ComposerPrimitiveInput.d.ts.map

package/dist/primitives/ComposerPrimitiveInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComposerPrimitiveInput.d.ts","sourceRoot":"","sources":["../../src/primitives/ComposerPrimitiveInput.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,KAAK,SAAS,EAAE,MAAM,KAAK,CAAC;AAQrE;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;0GA8CjC,CAAC"}

package/dist/primitives/ComposerPrimitiveInput.js

@@ -0,0 +1,57 @@
+import { useAuiState } from "../useAuiState.js";
+import { useAui } from "../useAui.js";
+import { isAttrDisabled } from "./attrDisabled.js";
+import { useComposerSendState } from "./useComposerSendState.js";
+import { defineComponent, h, mergeProps } from "vue";
+import { composerInputDisabled } from "@assistant-ui/core/store/internal";
+import { flushTapSync } from "@assistant-ui/tap";
+//#region src/primitives/ComposerPrimitiveInput.ts
+/**
+* A textarea bound to the composer text, disabled while the thread is
+* disabled. Enter submits (Shift+Enter inserts a newline, IME composition is
+* ignored) unless `submitOnEnter` is false; an Enter that cannot send falls
+* through to a newline, and a fallthrough keydown listener can veto the
+* submit with `preventDefault`. While the composer is not editing (an edit
+* composer before `beginEdit`), the value stays controlled to the empty
+* composer text.
+*/
+const ComposerPrimitiveInput = defineComponent({
+	name: "ComposerPrimitiveInput",
+	inheritAttrs: false,
+	props: { submitOnEnter: {
+		type: Boolean,
+		default: true
+	} },
+	slots: Object,
+	setup(props, { attrs }) {
+		const aui = useAui();
+		const text = useAuiState((s) => s.composer.isEditing ? s.composer.text : "");
+		const threadDisabled = useAuiState(composerInputDisabled);
+		const { disabled, send } = useComposerSendState();
+		const onInput = (event) => {
+			const target = event.target;
+			if (!aui.composer.getState().isEditing) {
+				target.value = text.value;
+				return;
+			}
+			flushTapSync(() => aui.composer.setText(target.value));
+		};
+		const onKeydown = (event) => {
+			if (event.defaultPrevented || !props.submitOnEnter) return;
+			if (event.key !== "Enter" || event.shiftKey || event.isComposing) return;
+			if (disabled.value || threadDisabled.value || isAttrDisabled(attrs)) return;
+			event.preventDefault();
+			send();
+		};
+		return () => h("textarea", mergeProps({ name: "input" }, attrs, {
+			value: text.value,
+			disabled: threadDisabled.value || isAttrDisabled(attrs),
+			onInput,
+			onKeydown
+		}));
+	}
+});
+//#endregion
+export { ComposerPrimitiveInput };
+
+//# sourceMappingURL=ComposerPrimitiveInput.js.map

package/dist/primitives/ComposerPrimitiveInput.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComposerPrimitiveInput.js","names":[],"sources":["../../src/primitives/ComposerPrimitiveInput.ts"],"sourcesContent":["import { defineComponent, h, mergeProps, type SlotsType } from \"vue\";\nimport { flushTapSync } from \"@assistant-ui/tap\";\nimport { composerInputDisabled } from \"@assistant-ui/core/store/internal\";\nimport { isAttrDisabled } from \"./attrDisabled\";\nimport { useAui } from \"../useAui\";\nimport { useAuiState } from \"../useAuiState\";\nimport { useComposerSendState } from \"./useComposerSendState\";\n\n/**\n * A textarea bound to the composer text, disabled while the thread is\n * disabled. Enter submits (Shift+Enter inserts a newline, IME composition is\n * ignored) unless `submitOnEnter` is false; an Enter that cannot send falls\n * through to a newline, and a fallthrough keydown listener can veto the\n * submit with `preventDefault`. While the composer is not editing (an edit\n * composer before `beginEdit`), the value stays controlled to the empty\n * composer text.\n */\nexport const ComposerPrimitiveInput = defineComponent({\n  name: \"ComposerPrimitiveInput\",\n  inheritAttrs: false,\n  props: {\n    submitOnEnter: {\n      type: Boolean,\n      default: true,\n    },\n  },\n  slots: Object as SlotsType<Record<string, never>>,\n  setup(props, { attrs }) {\n    const aui = useAui();\n    const text = useAuiState((s) =>\n      s.composer.isEditing ? s.composer.text : \"\",\n    );\n    const threadDisabled = useAuiState(composerInputDisabled);\n    const { disabled, send } = useComposerSendState();\n\n    const onInput = (event: Event) => {\n      const target = event.target as HTMLTextAreaElement;\n      if (!aui.composer.getState().isEditing) {\n        target.value = text.value;\n        return;\n      }\n      flushTapSync(() => aui.composer.setText(target.value));\n    };\n    const onKeydown = (event: KeyboardEvent) => {\n      if (event.defaultPrevented || !props.submitOnEnter) return;\n      if (event.key !== \"Enter\" || event.shiftKey || event.isComposing) return;\n      if (disabled.value || threadDisabled.value || isAttrDisabled(attrs))\n        return;\n      event.preventDefault();\n      send();\n    };\n\n    return () =>\n      h(\n        \"textarea\",\n        mergeProps({ name: \"input\" }, attrs, {\n          value: text.value,\n          disabled: threadDisabled.value || isAttrDisabled(attrs),\n          onInput,\n          onKeydown,\n        }),\n      );\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;AAiBA,MAAa,yBAAyB,gBAAgB;CACpD,MAAM;CACN,cAAc;CACd,OAAO,EACL,eAAe;EACb,MAAM;EACN,SAAS;CACX,EACF;CACA,OAAO;CACP,MAAM,OAAO,EAAE,SAAS;EACtB,MAAM,MAAM,OAAO;EACnB,MAAM,OAAO,aAAa,MACxB,EAAE,SAAS,YAAY,EAAE,SAAS,OAAO,EAC3C;EACA,MAAM,iBAAiB,YAAY,qBAAqB;EACxD,MAAM,EAAE,UAAU,SAAS,qBAAqB;EAEhD,MAAM,WAAW,UAAiB;GAChC,MAAM,SAAS,MAAM;GACrB,IAAI,CAAC,IAAI,SAAS,SAAS,CAAC,CAAC,WAAW;IACtC,OAAO,QAAQ,KAAK;IACpB;GACF;GACA,mBAAmB,IAAI,SAAS,QAAQ,OAAO,KAAK,CAAC;EACvD;EACA,MAAM,aAAa,UAAyB;GAC1C,IAAI,MAAM,oBAAoB,CAAC,MAAM,eAAe;GACpD,IAAI,MAAM,QAAQ,WAAW,MAAM,YAAY,MAAM,aAAa;GAClE,IAAI,SAAS,SAAS,eAAe,SAAS,eAAe,KAAK,GAChE;GACF,MAAM,eAAe;GACrB,KAAK;EACP;EAEA,aACE,EACE,YACA,WAAW,EAAE,MAAM,QAAQ,GAAG,OAAO;GACnC,OAAO,KAAK;GACZ,UAAU,eAAe,SAAS,eAAe,KAAK;GACtD;GACA;EACF,CAAC,CACH;CACJ;AACF,CAAC"}

package/dist/primitives/ComposerPrimitiveSend.d.ts

@@ -0,0 +1,13 @@
+import { type SlotsType, type VNodeChild } from "vue";
+/**
+ * A button that sends the composer. Disabled while the composer cannot send,
+ * or while a run is in flight and the runtime does not queue sends. A
+ * fallthrough click listener runs first and can veto the send with
+ * `preventDefault`.
+ */
+export declare const ComposerPrimitiveSend: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, SlotsType<{
+    default?: () => VNodeChild[];
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=ComposerPrimitiveSend.d.ts.map

package/dist/primitives/ComposerPrimitiveSend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComposerPrimitiveSend.d.ts","sourceRoot":"","sources":["../../src/primitives/ComposerPrimitiveSend.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,SAAS,EACd,KAAK,UAAU,EAChB,MAAM,KAAK,CAAC;AAIb;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB;;;cAGO,MAAM,UAAU,EAAE;yEAmBzD,CAAC"}

package/dist/primitives/ComposerPrimitiveSend.js

@@ -0,0 +1,31 @@
+import { isAttrDisabled } from "./attrDisabled.js";
+import { useComposerSendState } from "./useComposerSendState.js";
+import { defineComponent, h, mergeProps } from "vue";
+//#region src/primitives/ComposerPrimitiveSend.ts
+/**
+* A button that sends the composer. Disabled while the composer cannot send,
+* or while a run is in flight and the runtime does not queue sends. A
+* fallthrough click listener runs first and can veto the send with
+* `preventDefault`.
+*/
+const ComposerPrimitiveSend = defineComponent({
+	name: "ComposerPrimitiveSend",
+	inheritAttrs: false,
+	slots: Object,
+	setup(_, { attrs, slots }) {
+		const { disabled, send } = useComposerSendState();
+		const onClick = (event) => {
+			if (event.defaultPrevented || disabled.value || isAttrDisabled(attrs)) return;
+			send();
+		};
+		return () => h("button", mergeProps(attrs, {
+			type: "button",
+			disabled: disabled.value || isAttrDisabled(attrs),
+			onClick
+		}), slots.default?.());
+	}
+});
+//#endregion
+export { ComposerPrimitiveSend };
+
+//# sourceMappingURL=ComposerPrimitiveSend.js.map

package/dist/primitives/ComposerPrimitiveSend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComposerPrimitiveSend.js","names":[],"sources":["../../src/primitives/ComposerPrimitiveSend.ts"],"sourcesContent":["import {\n  defineComponent,\n  h,\n  mergeProps,\n  type SlotsType,\n  type VNodeChild,\n} from \"vue\";\nimport { isAttrDisabled } from \"./attrDisabled\";\nimport { useComposerSendState } from \"./useComposerSendState\";\n\n/**\n * A button that sends the composer. Disabled while the composer cannot send,\n * or while a run is in flight and the runtime does not queue sends. A\n * fallthrough click listener runs first and can veto the send with\n * `preventDefault`.\n */\nexport const ComposerPrimitiveSend = defineComponent({\n  name: \"ComposerPrimitiveSend\",\n  inheritAttrs: false,\n  slots: Object as SlotsType<{ default?: () => VNodeChild[] }>,\n  setup(_, { attrs, slots }) {\n    const { disabled, send } = useComposerSendState();\n    const onClick = (event: MouseEvent) => {\n      if (event.defaultPrevented || disabled.value || isAttrDisabled(attrs))\n        return;\n      send();\n    };\n    return () =>\n      h(\n        \"button\",\n        mergeProps(attrs, {\n          type: \"button\",\n          disabled: disabled.value || isAttrDisabled(attrs),\n          onClick,\n        }),\n        slots.default?.(),\n      );\n  },\n});\n"],"mappings":";;;;;;;;;;AAgBA,MAAa,wBAAwB,gBAAgB;CACnD,MAAM;CACN,cAAc;CACd,OAAO;CACP,MAAM,GAAG,EAAE,OAAO,SAAS;EACzB,MAAM,EAAE,UAAU,SAAS,qBAAqB;EAChD,MAAM,WAAW,UAAsB;GACrC,IAAI,MAAM,oBAAoB,SAAS,SAAS,eAAe,KAAK,GAClE;GACF,KAAK;EACP;EACA,aACE,EACE,UACA,WAAW,OAAO;GAChB,MAAM;GACN,UAAU,SAAS,SAAS,eAAe,KAAK;GAChD;EACF,CAAC,GACD,MAAM,UAAU,CAClB;CACJ;AACF,CAAC"}

package/dist/primitives/MessageByIdProvider.d.ts

@@ -0,0 +1,23 @@
+import { type SlotsType, type VNodeChild } from "vue";
+/**
+ * Scopes the subtree to the thread message with `id`: descendants read the
+ * message through `s.message` and its edit composer through `s.composer`.
+ * The scope follows the message's identity rather than a positional slot, so
+ * it pairs with id-keyed iteration.
+ */
+export declare const MessageByIdProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    id: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    id: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, SlotsType<{
+    default?: () => VNodeChild[];
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=MessageByIdProvider.d.ts.map

package/dist/primitives/MessageByIdProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageByIdProvider.d.ts","sourceRoot":"","sources":["../../src/primitives/MessageByIdProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,SAAS,EACd,KAAK,UAAU,EAChB,MAAM,KAAK,CAAC;AAuBb;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;cAQS,MAAM,UAAU,EAAE;yEA4CzD,CAAC"}

package/dist/primitives/MessageByIdProvider.js

@@ -0,0 +1,70 @@
+import { AuiProvider } from "../AuiProvider.js";
+import { useAui } from "../useAui.js";
+import { createLastValidCache as createLastValidCache$1, createStaleReporter } from "./lastValidCache.js";
+import { computed, defineComponent, h, onScopeDispose } from "vue";
+import { AuiConfig, Derived } from "@assistant-ui/store/client";
+//#region src/primitives/MessageByIdProvider.ts
+const idSets = /* @__PURE__ */ new WeakMap();
+const hasMessage = (aui, id) => {
+	const messages = aui.thread.getState().messages;
+	let set = idSets.get(messages);
+	if (!set) {
+		set = new Set(messages.map((message) => message.id));
+		idSets.set(messages, set);
+	}
+	return set.has(id);
+};
+/**
+* Scopes the subtree to the thread message with `id`: descendants read the
+* message through `s.message` and its edit composer through `s.composer`.
+* The scope follows the message's identity rather than a positional slot, so
+* it pairs with id-keyed iteration.
+*/
+const MessageByIdProvider = defineComponent({
+	name: "MessageByIdProvider",
+	props: { id: {
+		type: String,
+		required: true
+	} },
+	slots: Object,
+	setup(props, { slots }) {
+		const aui = useAui();
+		let disposed = false;
+		onScopeDispose(() => {
+			disposed = true;
+		});
+		const config = computed(() => {
+			const id = props.id;
+			const messageCache = createLastValidCache$1(createStaleReporter({
+				name: "MessageByIdProvider",
+				index: id,
+				isCurrent: () => !disposed && id === props.id,
+				isValid: () => hasMessage(aui, id)
+			}));
+			const composerCache = createLastValidCache$1(null);
+			return AuiConfig({
+				message: Derived({
+					source: "thread",
+					query: {
+						type: "id",
+						id
+					},
+					get: (aui) => messageCache.resolve(hasMessage(aui, id), () => aui.thread.message({ id }))
+				}),
+				composer: Derived({
+					source: "message",
+					query: {},
+					get: (aui) => composerCache.resolve(hasMessage(aui, id), () => aui.thread.message({ id }).composer())
+				})
+			});
+		});
+		return () => h(AuiProvider, {
+			config: config.value,
+			extends: aui
+		}, { default: () => slots.default?.() });
+	}
+});
+//#endregion
+export { MessageByIdProvider };
+
+//# sourceMappingURL=MessageByIdProvider.js.map

package/dist/primitives/MessageByIdProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageByIdProvider.js","names":["createLastValidCache"],"sources":["../../src/primitives/MessageByIdProvider.ts"],"sourcesContent":["import {\n  computed,\n  defineComponent,\n  h,\n  onScopeDispose,\n  type SlotsType,\n  type VNodeChild,\n} from \"vue\";\nimport {\n  AuiConfig,\n  Derived,\n  type AssistantClient,\n} from \"@assistant-ui/store/client\";\nimport type { ComposerMethods, MessageMethods } from \"@assistant-ui/core/store\";\nimport { AuiProvider } from \"../AuiProvider\";\nimport { useAui } from \"../useAui\";\nimport { createLastValidCache, createStaleReporter } from \"./lastValidCache\";\n\nconst idSets = new WeakMap<readonly { id: string }[], Set<string>>();\n\nconst hasMessage = (aui: AssistantClient, id: string) => {\n  const messages = aui.thread.getState().messages;\n  let set = idSets.get(messages);\n  if (!set) {\n    set = new Set(messages.map((message) => message.id));\n    idSets.set(messages, set);\n  }\n  return set.has(id);\n};\n\n/**\n * Scopes the subtree to the thread message with `id`: descendants read the\n * message through `s.message` and its edit composer through `s.composer`.\n * The scope follows the message's identity rather than a positional slot, so\n * it pairs with id-keyed iteration.\n */\nexport const MessageByIdProvider = defineComponent({\n  name: \"MessageByIdProvider\",\n  props: {\n    id: {\n      type: String,\n      required: true,\n    },\n  },\n  slots: Object as SlotsType<{ default?: () => VNodeChild[] }>,\n  setup(props, { slots }) {\n    const aui = useAui();\n    let disposed = false;\n    onScopeDispose(() => {\n      disposed = true;\n    });\n    const config = computed(() => {\n      const id = props.id;\n      const messageCache = createLastValidCache<MessageMethods>(\n        createStaleReporter({\n          name: \"MessageByIdProvider\",\n          index: id,\n          isCurrent: () => !disposed && id === props.id,\n          isValid: () => hasMessage(aui, id),\n        }),\n      );\n      const composerCache = createLastValidCache<ComposerMethods>(null);\n      return AuiConfig({\n        message: Derived({\n          source: \"thread\",\n          query: { type: \"id\", id },\n          get: (aui) =>\n            messageCache.resolve(hasMessage(aui, id), () =>\n              aui.thread.message({ id }),\n            ),\n        }),\n        composer: Derived({\n          source: \"message\",\n          query: {},\n          get: (aui) =>\n            composerCache.resolve(hasMessage(aui, id), () =>\n              aui.thread.message({ id }).composer(),\n            ),\n        }),\n      });\n    });\n    return () =>\n      h(\n        AuiProvider,\n        { config: config.value, extends: aui },\n        { default: () => slots.default?.() },\n      );\n  },\n});\n"],"mappings":";;;;;;AAkBA,MAAM,yBAAS,IAAI,QAAgD;AAEnE,MAAM,cAAc,KAAsB,OAAe;CACvD,MAAM,WAAW,IAAI,OAAO,SAAS,CAAC,CAAC;CACvC,IAAI,MAAM,OAAO,IAAI,QAAQ;CAC7B,IAAI,CAAC,KAAK;EACR,MAAM,IAAI,IAAI,SAAS,KAAK,YAAY,QAAQ,EAAE,CAAC;EACnD,OAAO,IAAI,UAAU,GAAG;CAC1B;CACA,OAAO,IAAI,IAAI,EAAE;AACnB;;;;;;;AAQA,MAAa,sBAAsB,gBAAgB;CACjD,MAAM;CACN,OAAO,EACL,IAAI;EACF,MAAM;EACN,UAAU;CACZ,EACF;CACA,OAAO;CACP,MAAM,OAAO,EAAE,SAAS;EACtB,MAAM,MAAM,OAAO;EACnB,IAAI,WAAW;EACf,qBAAqB;GACnB,WAAW;EACb,CAAC;EACD,MAAM,SAAS,eAAe;GAC5B,MAAM,KAAK,MAAM;GACjB,MAAM,eAAeA,uBACnB,oBAAoB;IAClB,MAAM;IACN,OAAO;IACP,iBAAiB,CAAC,YAAY,OAAO,MAAM;IAC3C,eAAe,WAAW,KAAK,EAAE;GACnC,CAAC,CACH;GACA,MAAM,gBAAgBA,uBAAsC,IAAI;GAChE,OAAO,UAAU;IACf,SAAS,QAAQ;KACf,QAAQ;KACR,OAAO;MAAE,MAAM;MAAM;KAAG;KACxB,MAAM,QACJ,aAAa,QAAQ,WAAW,KAAK,EAAE,SACrC,IAAI,OAAO,QAAQ,EAAE,GAAG,CAAC,CAC3B;IACJ,CAAC;IACD,UAAU,QAAQ;KAChB,QAAQ;KACR,OAAO,CAAC;KACR,MAAM,QACJ,cAAc,QAAQ,WAAW,KAAK,EAAE,SACtC,IAAI,OAAO,QAAQ,EAAE,GAAG,CAAC,CAAC,CAAC,SAAS,CACtC;IACJ,CAAC;GACH,CAAC;EACH,CAAC;EACD,aACE,EACE,aACA;GAAE,QAAQ,OAAO;GAAO,SAAS;EAAI,GACrC,EAAE,eAAe,MAAM,UAAU,EAAE,CACrC;CACJ;AACF,CAAC"}

package/dist/primitives/MessagePrimitiveParts.d.ts

@@ -0,0 +1,50 @@
+import { type SlotsType, type VNodeChild } from "vue";
+import { type PartMethods } from "@assistant-ui/core/store";
+import type { AssistantState } from "@assistant-ui/store/client";
+export declare const clearPartWarningsForTesting: () => void;
+/**
+ * The value of the single `tool` prop passed to a tool UI registered in the
+ * `tools` scope. React spreads the part state as individual props; in Vue any
+ * prop the component does not declare falls through to `$attrs` and gets
+ * stringified onto its root element, so the Vue face passes one `tool` object
+ * instead, which a component always declares in full. The tools scope
+ * declares renderers as React's `ToolCallMessagePartComponent`, so the Vue
+ * face bridges the seam with casts at registration and render; a genuine
+ * React renderer arriving through a shared toolkit type-checks at `setToolUI`
+ * and then fails when invoked as a Vue component. This type is the Vue-facing
+ * contract for custom components. Toolkit `renderText` descriptors resolve
+ * through the neutral resolver and render string or number results directly;
+ * a react-element-valued descriptor is react-only and renders nothing here.
+ */
+export type ToolUIProps = {
+    part: Extract<AssistantState["part"], {
+        type: "tool-call";
+    }>;
+    addResult: PartMethods["addToolResult"];
+    resume: PartMethods["resumeToolCall"];
+    respondToApproval: PartMethods["respondToToolApproval"];
+    unstable_recordInteraction?: PartMethods["unstable_recordInteraction"];
+};
+/** The value of the single `data` prop passed to a Vue data renderer. */
+export type DataUIProps<T = unknown> = {
+    part: Omit<Extract<AssistantState["part"], {
+        type: "data";
+    }>, "data"> & {
+        data: T;
+    };
+};
+/**
+ * Renders the current message's content parts in order, each scoped through
+ * {@link PartByIndexProvider}. A `tool-call` part first resolves a renderer
+ * registered in the `tools` scope by tool name (`aui.tools.setToolUI`, or a
+ * `Tools({ toolkit })` config entry) and renders it with a single `tool` prop
+ * of type {@link ToolUIProps}.
+ * Otherwise a slot named after the part type (`text`, `reasoning`,
+ * `tool-call`, ...) renders that part; the `default` slot is the fallback for
+ * types without a named slot, except text, which always renders its text
+ * unless a `text` slot overrides it.
+ */
+export declare const MessagePrimitiveParts: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, SlotsType<Record<string, (() => VNodeChild[]) | undefined>>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=MessagePrimitiveParts.d.ts.map

package/dist/primitives/MessagePrimitiveParts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessagePrimitiveParts.d.ts","sourceRoot":"","sources":["../../src/primitives/MessagePrimitiveParts.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,SAAS,EACd,KAAK,UAAU,EAChB,MAAM,KAAK,CAAC;AAGb,OAAO,EAEL,KAAK,WAAW,EACjB,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAQjE,eAAO,MAAM,2BAA2B,YAA4B,CAAC;AAErE;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE;QAAE,IAAI,EAAE,WAAW,CAAA;KAAE,CAAC,CAAC;IAC7D,SAAS,EAAE,WAAW,CAAC,eAAe,CAAC,CAAC;IACxC,MAAM,EAAE,WAAW,CAAC,gBAAgB,CAAC,CAAC;IACtC,iBAAiB,EAAE,WAAW,CAAC,uBAAuB,CAAC,CAAC;IACxD,0BAA0B,CAAC,EAAE,WAAW,CAAC,4BAA4B,CAAC,CAAC;CACxE,CAAC;AAEF,yEAAyE;AACzE,MAAM,MAAM,WAAW,CAAC,CAAC,GAAG,OAAO,IAAI;IACrC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE,MAAM,CAAC,GAAG;QACtE,IAAI,EAAE,CAAC,CAAC;KACT,CAAC;CACH,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB;;oMAEiB,UAAU,EAAE,sFAmG7D,CAAC"}

package/dist/primitives/MessagePrimitiveParts.js

@@ -0,0 +1,93 @@
+import { useAuiState } from "../useAuiState.js";
+import { useAui } from "../useAui.js";
+import { PartByIndexProvider } from "./PartByIndexProvider.js";
+import { useStableKeys } from "./stableKeys.js";
+import { defineComponent, h } from "vue";
+import { isDevelopment } from "@assistant-ui/core/store/internal";
+import { isMcpAppUri } from "@assistant-ui/core";
+import { getMessagePartKeys } from "@assistant-ui/core/internal";
+import { resolveToolCallText } from "@assistant-ui/core/store";
+//#region src/primitives/MessagePrimitiveParts.ts
+const warnedTypes = /* @__PURE__ */ new Set();
+const clearPartWarningsForTesting = () => warnedTypes.clear();
+/**
+* Renders the current message's content parts in order, each scoped through
+* {@link PartByIndexProvider}. A `tool-call` part first resolves a renderer
+* registered in the `tools` scope by tool name (`aui.tools.setToolUI`, or a
+* `Tools({ toolkit })` config entry) and renders it with a single `tool` prop
+* of type {@link ToolUIProps}.
+* Otherwise a slot named after the part type (`text`, `reasoning`,
+* `tool-call`, ...) renders that part; the `default` slot is the fallback for
+* types without a named slot, except text, which always renders its text
+* unless a `text` slot overrides it.
+*/
+const MessagePrimitiveParts = defineComponent({
+	name: "MessagePrimitiveParts",
+	slots: Object,
+	setup(_, { slots }) {
+		const parts = useAuiState((s) => s.message.parts);
+		const partKeys = useStableKeys(() => getMessagePartKeys(parts.value));
+		const PartView = defineComponent({
+			name: "MessagePartView",
+			setup() {
+				const aui = useAui();
+				const type = useAuiState((s) => s.part.type);
+				const text = useAuiState((s) => s.part.type === "text" ? s.part.text : "");
+				const toolUI = useAuiState((s) => {
+					if (s.part.type !== "tool-call") return null;
+					return s.optional.tools?.toolUIs[s.part.toolName]?.[0] ?? null;
+				});
+				const mcpAppRender = useAuiState((s) => s.part.type === "tool-call" && isMcpAppUri(s.part.mcp?.app?.resourceUri) ? s.optional.tools?.mcpApp?.render ?? null : null);
+				const toolPart = useAuiState((s) => s.part.type === "tool-call" ? s.part : null);
+				const dataRenderer = useAuiState((s) => {
+					if (s.part.type !== "data") return null;
+					return s.optional.dataRenderers?.renderers[s.part.name]?.[0] ?? null ?? s.optional.dataRenderers?.fallbacks[0] ?? null;
+				});
+				const dataPart = useAuiState((s) => s.part.type === "data" ? s.part : null);
+				return () => {
+					if (type.value === "tool-call") {
+						const registration = toolUI.value;
+						const part = toolPart.value;
+						if (registration?.renderText && part) {
+							const resolved = resolveToolCallText(registration.renderText, part);
+							if (typeof resolved === "string" || typeof resolved === "number") return resolved;
+							return null;
+						}
+						const Render = registration?.render ?? mcpAppRender.value;
+						if (Render && part) return h(Render, { tool: {
+							part,
+							addResult: aui.part.addToolResult,
+							resume: aui.part.resumeToolCall,
+							respondToApproval: aui.part.respondToToolApproval,
+							...aui.part.unstable_recordInteraction && { unstable_recordInteraction: aui.part.unstable_recordInteraction }
+						} });
+					}
+					if (type.value === "data") {
+						const Render = dataRenderer.value;
+						const part = dataPart.value;
+						if (Render && part) return h(Render, { data: { part } });
+					}
+					if (type.value === "text") {
+						const slot = slots.text;
+						return slot ? slot() : h("p", { style: { whiteSpace: "pre-line" } }, text.value);
+					}
+					const slot = slots[type.value] ?? slots.default;
+					if (slot) return slot();
+					if (isDevelopment && !warnedTypes.has(type.value)) {
+						warnedTypes.add(type.value);
+						console.warn(`MessagePrimitiveParts: no slot for part type "${type.value}"; the part renders nothing. Add a #${type.value} or #default slot.`);
+					}
+					return null;
+				};
+			}
+		});
+		return () => partKeys.value.map((key, index) => h(PartByIndexProvider, {
+			index,
+			key
+		}, { default: () => h(PartView) }));
+	}
+});
+//#endregion
+export { MessagePrimitiveParts, clearPartWarningsForTesting };
+
+//# sourceMappingURL=MessagePrimitiveParts.js.map

package/dist/primitives/MessagePrimitiveParts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessagePrimitiveParts.js","names":[],"sources":["../../src/primitives/MessagePrimitiveParts.ts"],"sourcesContent":["import {\n  defineComponent,\n  h,\n  type Component,\n  type SlotsType,\n  type VNodeChild,\n} from \"vue\";\nimport { isMcpAppUri } from \"@assistant-ui/core\";\nimport { getMessagePartKeys } from \"@assistant-ui/core/internal\";\nimport {\n  resolveToolCallText,\n  type PartMethods,\n} from \"@assistant-ui/core/store\";\nimport { isDevelopment } from \"@assistant-ui/core/store/internal\";\nimport type { AssistantState } from \"@assistant-ui/store/client\";\nimport { useAui } from \"../useAui\";\nimport { useAuiState } from \"../useAuiState\";\nimport { PartByIndexProvider } from \"./PartByIndexProvider\";\nimport { useStableKeys } from \"./stableKeys\";\n\nconst warnedTypes = new Set<string>();\n\nexport const clearPartWarningsForTesting = () => warnedTypes.clear();\n\n/**\n * The value of the single `tool` prop passed to a tool UI registered in the\n * `tools` scope. React spreads the part state as individual props; in Vue any\n * prop the component does not declare falls through to `$attrs` and gets\n * stringified onto its root element, so the Vue face passes one `tool` object\n * instead, which a component always declares in full. The tools scope\n * declares renderers as React's `ToolCallMessagePartComponent`, so the Vue\n * face bridges the seam with casts at registration and render; a genuine\n * React renderer arriving through a shared toolkit type-checks at `setToolUI`\n * and then fails when invoked as a Vue component. This type is the Vue-facing\n * contract for custom components. Toolkit `renderText` descriptors resolve\n * through the neutral resolver and render string or number results directly;\n * a react-element-valued descriptor is react-only and renders nothing here.\n */\nexport type ToolUIProps = {\n  part: Extract<AssistantState[\"part\"], { type: \"tool-call\" }>;\n  addResult: PartMethods[\"addToolResult\"];\n  resume: PartMethods[\"resumeToolCall\"];\n  respondToApproval: PartMethods[\"respondToToolApproval\"];\n  unstable_recordInteraction?: PartMethods[\"unstable_recordInteraction\"];\n};\n\n/** The value of the single `data` prop passed to a Vue data renderer. */\nexport type DataUIProps<T = unknown> = {\n  part: Omit<Extract<AssistantState[\"part\"], { type: \"data\" }>, \"data\"> & {\n    data: T;\n  };\n};\n\n/**\n * Renders the current message's content parts in order, each scoped through\n * {@link PartByIndexProvider}. A `tool-call` part first resolves a renderer\n * registered in the `tools` scope by tool name (`aui.tools.setToolUI`, or a\n * `Tools({ toolkit })` config entry) and renders it with a single `tool` prop\n * of type {@link ToolUIProps}.\n * Otherwise a slot named after the part type (`text`, `reasoning`,\n * `tool-call`, ...) renders that part; the `default` slot is the fallback for\n * types without a named slot, except text, which always renders its text\n * unless a `text` slot overrides it.\n */\nexport const MessagePrimitiveParts = defineComponent({\n  name: \"MessagePrimitiveParts\",\n  slots: Object as SlotsType<Record<string, (() => VNodeChild[]) | undefined>>,\n  setup(_, { slots }) {\n    const parts = useAuiState((s) => s.message.parts);\n    const partKeys = useStableKeys(() => getMessagePartKeys(parts.value));\n    const PartView = defineComponent({\n      name: \"MessagePartView\",\n      setup() {\n        const aui = useAui();\n        const type = useAuiState((s) => s.part.type);\n        const text = useAuiState((s) =>\n          s.part.type === \"text\" ? s.part.text : \"\",\n        );\n        const toolUI = useAuiState((s) => {\n          if (s.part.type !== \"tool-call\") return null;\n          return s.optional.tools?.toolUIs[s.part.toolName]?.[0] ?? null;\n        });\n        const mcpAppRender = useAuiState((s) =>\n          s.part.type === \"tool-call\" &&\n          isMcpAppUri(s.part.mcp?.app?.resourceUri)\n            ? (s.optional.tools?.mcpApp?.render ?? null)\n            : null,\n        );\n        const toolPart = useAuiState((s) =>\n          s.part.type === \"tool-call\" ? s.part : null,\n        );\n        const dataRenderer = useAuiState((s) => {\n          if (s.part.type !== \"data\") return null;\n          const named =\n            s.optional.dataRenderers?.renderers[s.part.name]?.[0] ?? null;\n          return named ?? s.optional.dataRenderers?.fallbacks[0] ?? null;\n        });\n        const dataPart = useAuiState((s) =>\n          s.part.type === \"data\" ? s.part : null,\n        );\n        return () => {\n          if (type.value === \"tool-call\") {\n            const registration = toolUI.value;\n            const part = toolPart.value;\n            if (registration?.renderText && part) {\n              const resolved = resolveToolCallText(\n                registration.renderText,\n                part,\n              );\n              if (\n                typeof resolved === \"string\" ||\n                typeof resolved === \"number\"\n              ) {\n                return resolved;\n              }\n              return null;\n            }\n            const Render = registration?.render ?? mcpAppRender.value;\n            if (Render && part) {\n              return h(Render as unknown as Component, {\n                tool: {\n                  part,\n                  addResult: aui.part.addToolResult,\n                  resume: aui.part.resumeToolCall,\n                  respondToApproval: aui.part.respondToToolApproval,\n                  ...(aui.part.unstable_recordInteraction && {\n                    unstable_recordInteraction:\n                      aui.part.unstable_recordInteraction,\n                  }),\n                } satisfies ToolUIProps,\n              });\n            }\n          }\n          if (type.value === \"data\") {\n            const Render = dataRenderer.value;\n            const part = dataPart.value;\n            if (Render && part) {\n              return h(Render as unknown as Component, {\n                data: { part } satisfies DataUIProps,\n              });\n            }\n          }\n          if (type.value === \"text\") {\n            const slot = slots.text;\n            return slot\n              ? slot()\n              : h(\"p\", { style: { whiteSpace: \"pre-line\" } }, text.value);\n          }\n          const slot = slots[type.value] ?? slots.default;\n          if (slot) return slot();\n          if (isDevelopment && !warnedTypes.has(type.value)) {\n            warnedTypes.add(type.value);\n            console.warn(\n              `MessagePrimitiveParts: no slot for part type \"${type.value}\"; the part renders nothing. Add a #${type.value} or #default slot.`,\n            );\n          }\n          return null;\n        };\n      },\n    });\n    return () =>\n      partKeys.value.map((key, index) =>\n        h(PartByIndexProvider, { index, key }, { default: () => h(PartView) }),\n      );\n  },\n});\n"],"mappings":";;;;;;;;;;AAoBA,MAAM,8BAAc,IAAI,IAAY;AAEpC,MAAa,oCAAoC,YAAY,MAAM;;;;;;;;;;;;AA0CnE,MAAa,wBAAwB,gBAAgB;CACnD,MAAM;CACN,OAAO;CACP,MAAM,GAAG,EAAE,SAAS;EAClB,MAAM,QAAQ,aAAa,MAAM,EAAE,QAAQ,KAAK;EAChD,MAAM,WAAW,oBAAoB,mBAAmB,MAAM,KAAK,CAAC;EACpE,MAAM,WAAW,gBAAgB;GAC/B,MAAM;GACN,QAAQ;IACN,MAAM,MAAM,OAAO;IACnB,MAAM,OAAO,aAAa,MAAM,EAAE,KAAK,IAAI;IAC3C,MAAM,OAAO,aAAa,MACxB,EAAE,KAAK,SAAS,SAAS,EAAE,KAAK,OAAO,EACzC;IACA,MAAM,SAAS,aAAa,MAAM;KAChC,IAAI,EAAE,KAAK,SAAS,aAAa,OAAO;KACxC,OAAO,EAAE,SAAS,OAAO,QAAQ,EAAE,KAAK,SAAS,GAAG,MAAM;IAC5D,CAAC;IACD,MAAM,eAAe,aAAa,MAChC,EAAE,KAAK,SAAS,eAChB,YAAY,EAAE,KAAK,KAAK,KAAK,WAAW,IACnC,EAAE,SAAS,OAAO,QAAQ,UAAU,OACrC,IACN;IACA,MAAM,WAAW,aAAa,MAC5B,EAAE,KAAK,SAAS,cAAc,EAAE,OAAO,IACzC;IACA,MAAM,eAAe,aAAa,MAAM;KACtC,IAAI,EAAE,KAAK,SAAS,QAAQ,OAAO;KAGnC,OADE,EAAE,SAAS,eAAe,UAAU,EAAE,KAAK,KAAK,GAAG,MAAM,QAC3C,EAAE,SAAS,eAAe,UAAU,MAAM;IAC5D,CAAC;IACD,MAAM,WAAW,aAAa,MAC5B,EAAE,KAAK,SAAS,SAAS,EAAE,OAAO,IACpC;IACA,aAAa;KACX,IAAI,KAAK,UAAU,aAAa;MAC9B,MAAM,eAAe,OAAO;MAC5B,MAAM,OAAO,SAAS;MACtB,IAAI,cAAc,cAAc,MAAM;OACpC,MAAM,WAAW,oBACf,aAAa,YACb,IACF;OACA,IACE,OAAO,aAAa,YACpB,OAAO,aAAa,UAEpB,OAAO;OAET,OAAO;MACT;MACA,MAAM,SAAS,cAAc,UAAU,aAAa;MACpD,IAAI,UAAU,MACZ,OAAO,EAAE,QAAgC,EACvC,MAAM;OACJ;OACA,WAAW,IAAI,KAAK;OACpB,QAAQ,IAAI,KAAK;OACjB,mBAAmB,IAAI,KAAK;OAC5B,GAAI,IAAI,KAAK,8BAA8B,EACzC,4BACE,IAAI,KAAK,2BACb;MACF,EACF,CAAC;KAEL;KACA,IAAI,KAAK,UAAU,QAAQ;MACzB,MAAM,SAAS,aAAa;MAC5B,MAAM,OAAO,SAAS;MACtB,IAAI,UAAU,MACZ,OAAO,EAAE,QAAgC,EACvC,MAAM,EAAE,KAAK,EACf,CAAC;KAEL;KACA,IAAI,KAAK,UAAU,QAAQ;MACzB,MAAM,OAAO,MAAM;MACnB,OAAO,OACH,KAAK,IACL,EAAE,KAAK,EAAE,OAAO,EAAE,YAAY,WAAW,EAAE,GAAG,KAAK,KAAK;KAC9D;KACA,MAAM,OAAO,MAAM,KAAK,UAAU,MAAM;KACxC,IAAI,MAAM,OAAO,KAAK;KACtB,IAAI,iBAAiB,CAAC,YAAY,IAAI,KAAK,KAAK,GAAG;MACjD,YAAY,IAAI,KAAK,KAAK;MAC1B,QAAQ,KACN,iDAAiD,KAAK,MAAM,sCAAsC,KAAK,MAAM,mBAC/G;KACF;KACA,OAAO;IACT;GACF;EACF,CAAC;EACD,aACE,SAAS,MAAM,KAAK,KAAK,UACvB,EAAE,qBAAqB;GAAE;GAAO;EAAI,GAAG,EAAE,eAAe,EAAE,QAAQ,EAAE,CAAC,CACvE;CACJ;AACF,CAAC"}

package/dist/primitives/PartByIndexProvider.d.ts

@@ -0,0 +1,21 @@
+import { type SlotsType, type VNodeChild } from "vue";
+/**
+ * Scopes the subtree to the message part at `index`: descendants read the
+ * part through `s.part`.
+ */
+export declare const PartByIndexProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    index: {
+        type: NumberConstructor;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    index: {
+        type: NumberConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, SlotsType<{
+    default?: () => VNodeChild[];
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=PartByIndexProvider.d.ts.map

package/dist/primitives/PartByIndexProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PartByIndexProvider.d.ts","sourceRoot":"","sources":["../../src/primitives/PartByIndexProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,SAAS,EACd,KAAK,UAAU,EAChB,MAAM,KAAK,CAAC;AAOb;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;cAQS,MAAM,UAAU,EAAE;yEAmCzD,CAAC"}