@assistant-ui/react 0.14.29 → 0.15.1

package/dist/legacy-runtime/hooks/AttachmentContext.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AttachmentContext.d.ts","names":[],"sources":["../../../src/legacy-runtime/hooks/AttachmentContext.ts"],"mappings":";;;;;iBASgB,qBAAqB;EACnC;IACE;iBACY,qBAAqB;EACnC;IACE;iBAgBY,mCAAmC;EACjD;IACE;iBACY,mCAAmC;EACjD;IACE;iBAaY,iCAAiC;EAC/C;IACE;iBACY,iCAAiC;EAC/C;IACE;iBAcY,4BAA4B;EAC1C;IACE;iBACY,4BAA4B;EAC1C;IACE;;;;cAgBS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGA"}

package/dist/legacy-runtime/hooks/AttachmentContext.js

@@ -1,47 +0,0 @@
-"use client";
-import { createStateHookForRuntime } from "../../context/react/utils/createStateHookForRuntime.js";
-import { useAui, useAuiState } from "@assistant-ui/store";
-import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
-//#region src/legacy-runtime/hooks/AttachmentContext.ts
-function useAttachmentRuntime(options) {
-	const $ = c(2);
-	const aui = useAui();
-	let t0;
-	if ($[0] !== aui) {
-		t0 = () => aui.attachment.source ? aui.attachment().__internal_getRuntime?.() ?? null : null;
-		$[0] = aui;
-		$[1] = t0;
-	} else t0 = $[1];
-	const runtime = useAuiState(t0);
-	if (!runtime && !options?.optional) throw new Error("AttachmentRuntime is not available");
-	return runtime;
-}
-function useThreadComposerAttachmentRuntime(options) {
-	const attachmentRuntime = useAttachmentRuntime(options);
-	if (!attachmentRuntime) return null;
-	if (attachmentRuntime.source !== "thread-composer") throw new Error("This component must be used within a thread's ComposerPrimitive.Attachments component.");
-	return attachmentRuntime;
-}
-function useEditComposerAttachmentRuntime(options) {
-	const attachmentRuntime = useAttachmentRuntime(options);
-	if (!attachmentRuntime) return null;
-	if (attachmentRuntime.source !== "edit-composer") throw new Error("This component must be used within a message's ComposerPrimitive.Attachments component.");
-	return attachmentRuntime;
-}
-function useMessageAttachmentRuntime(options) {
-	const attachmentRuntime = useAttachmentRuntime(options);
-	if (!attachmentRuntime) return null;
-	if (attachmentRuntime.source !== "message") throw new Error("This component must be used within a MessagePrimitive.Attachments component.");
-	return attachmentRuntime;
-}
-/**
-* @deprecated Use {@link useAuiState}: `useAuiState((s) => s.attachment)`. See the {@link https://assistant-ui.com/docs/migrations/v0-12 migration guide}.
-*/
-const useAttachment = createStateHookForRuntime(useAttachmentRuntime);
-const useThreadComposerAttachment = createStateHookForRuntime(useThreadComposerAttachmentRuntime);
-const useEditComposerAttachment = createStateHookForRuntime(useEditComposerAttachmentRuntime);
-const useMessageAttachment = createStateHookForRuntime(useMessageAttachmentRuntime);
-//#endregion
-export { useAttachment, useAttachmentRuntime, useEditComposerAttachment, useEditComposerAttachmentRuntime, useMessageAttachment, useMessageAttachmentRuntime, useThreadComposerAttachment, useThreadComposerAttachmentRuntime };
-
-//# sourceMappingURL=AttachmentContext.js.map

package/dist/legacy-runtime/hooks/AttachmentContext.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AttachmentContext.js","names":["c","_c","AttachmentRuntime","createStateHookForRuntime","useAui","useAuiState","useAttachmentRuntime","options","optional","$","aui","t0","attachment","source","__internal_getRuntime","runtime","Error","useThreadComposerAttachmentRuntime","attachmentRuntime","useEditComposerAttachmentRuntime","useMessageAttachmentRuntime","useAttachment","useThreadComposerAttachment","useEditComposerAttachment","useMessageAttachment"],"sources":["../../../src/legacy-runtime/hooks/AttachmentContext.ts"],"sourcesContent":["\"use client\";\n\nimport type { AttachmentRuntime } from \"../runtime/AttachmentRuntime\";\nimport { createStateHookForRuntime } from \"../../context/react/utils/createStateHookForRuntime\";\nimport { useAui, useAuiState } from \"@assistant-ui/store\";\n\n/**\n * @deprecated Use {@link useAui} with `aui.attachment()` instead. See the {@link https://assistant-ui.com/docs/migrations/v0-12 migration guide}.\n */\nexport function useAttachmentRuntime(options?: {\n  optional?: false | undefined;\n}): AttachmentRuntime;\nexport function useAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime | null;\nexport function useAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime | null {\n  const aui = useAui();\n  const runtime = useAuiState(() =>\n    aui.attachment.source\n      ? (aui.attachment().__internal_getRuntime?.() ?? null)\n      : null,\n  );\n  if (!runtime && !options?.optional) {\n    throw new Error(\"AttachmentRuntime is not available\");\n  }\n  return runtime;\n}\n\nexport function useThreadComposerAttachmentRuntime(options?: {\n  optional?: false | undefined;\n}): AttachmentRuntime<\"thread-composer\">;\nexport function useThreadComposerAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"thread-composer\"> | null;\nexport function useThreadComposerAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"thread-composer\"> | null {\n  const attachmentRuntime = useAttachmentRuntime(options);\n  if (!attachmentRuntime) return null;\n  if (attachmentRuntime.source !== \"thread-composer\")\n    throw new Error(\n      \"This component must be used within a thread's ComposerPrimitive.Attachments component.\",\n    );\n  return attachmentRuntime as AttachmentRuntime<\"thread-composer\">;\n}\n\nexport function useEditComposerAttachmentRuntime(options?: {\n  optional?: false | undefined;\n}): AttachmentRuntime<\"edit-composer\">;\nexport function useEditComposerAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"edit-composer\"> | null;\nexport function useEditComposerAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"edit-composer\"> | null {\n  const attachmentRuntime = useAttachmentRuntime(options);\n  if (!attachmentRuntime) return null;\n  if (attachmentRuntime.source !== \"edit-composer\")\n    throw new Error(\n      \"This component must be used within a message's ComposerPrimitive.Attachments component.\",\n    );\n\n  return attachmentRuntime as AttachmentRuntime<\"edit-composer\">;\n}\n\nexport function useMessageAttachmentRuntime(options?: {\n  optional?: false | undefined;\n}): AttachmentRuntime<\"message\">;\nexport function useMessageAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"message\"> | null;\nexport function useMessageAttachmentRuntime(options?: {\n  optional?: boolean | undefined;\n}): AttachmentRuntime<\"message\"> | null {\n  const attachmentRuntime = useAttachmentRuntime(options);\n  if (!attachmentRuntime) return null;\n  if (attachmentRuntime.source !== \"message\")\n    throw new Error(\n      \"This component must be used within a MessagePrimitive.Attachments component.\",\n    );\n  return attachmentRuntime as AttachmentRuntime<\"message\">;\n}\n\n/**\n * @deprecated Use {@link useAuiState}: `useAuiState((s) => s.attachment)`. See the {@link https://assistant-ui.com/docs/migrations/v0-12 migration guide}.\n */\nexport const useAttachment = createStateHookForRuntime(useAttachmentRuntime);\n\nexport const useThreadComposerAttachment = createStateHookForRuntime(\n  useThreadComposerAttachmentRuntime,\n);\nexport const useEditComposerAttachment = createStateHookForRuntime(\n  useEditComposerAttachmentRuntime,\n);\nexport const useMessageAttachment = createStateHookForRuntime(\n  useMessageAttachmentRuntime,\n);\n"],"mappings":";;;;;AAeA,SAAOM,qBAAAC,SAAA;CAAA,MAAAE,IAAAR,EAAA,CAAA;CAGL,MAAAS,MAAYN,OAAO;CAAE,IAAAO;CAAA,IAAAF,EAAA,OAAAC,KAAA;EACOC,WAC1BD,IAAGE,WAAWC,SACTH,IAAGE,WAAY,CAAC,CAAAE,wBAAiC,KAAjD,OADL;EAEQL,EAAA,KAAAC;EAAAD,EAAA,KAAAE;CAAA,OAAAA,KAAAF,EAAA;CAHV,MAAAM,UAAgBV,YAAYM,EAI5B;CACA,IAAI,CAACI,WAAD,CAAaR,SAAOC,UACtB,MAAM,IAAIQ,MAAM,oCAAoC;CACrD,OACMD;AAAO;AAShB,SAAOE,mCAAAV,SAAA;CAGL,MAAAW,oBAA0BZ,qBAAqBC,OAAO;CACtD,IAAI,CAACW,mBAAiB,OAAS;CAC/B,IAAIA,kBAAiBL,WAAY,mBAC/B,MAAM,IAAIG,MACR,wFACF;CAAE,OACGE;AAAyD;AASlE,SAAOC,iCAAAZ,SAAA;CAGL,MAAAW,oBAA0BZ,qBAAqBC,OAAO;CACtD,IAAI,CAACW,mBAAiB,OAAS;CAC/B,IAAIA,kBAAiBL,WAAY,iBAC/B,MAAM,IAAIG,MACR,yFACF;CAAE,OAEGE;AAAuD;AAShE,SAAOE,4BAAAb,SAAA;CAGL,MAAAW,oBAA0BZ,qBAAqBC,OAAO;CACtD,IAAI,CAACW,mBAAiB,OAAS;CAC/B,IAAIA,kBAAiBL,WAAY,WAC/B,MAAM,IAAIG,MACR,8EACF;CAAE,OACGE;AAAiD;;;;AAM1D,MAAaG,gBAAgBlB,0BAA0BG,oBAAoB;AAE3E,MAAagB,8BAA8BnB,0BACzCc,kCACF;AACA,MAAaM,4BAA4BpB,0BACvCgB,gCACF;AACA,MAAaK,uBAAuBrB,0BAClCiB,2BACF"}

package/dist/legacy-runtime/hooks/ComposerContext.d.ts

@@ -1,141 +0,0 @@
-import { ComposerRuntime } from "../runtime/ComposerRuntime.js";
-//#region src/legacy-runtime/hooks/ComposerContext.d.ts
-/**
- * @deprecated Use {@link useAui} with `aui.composer()` instead. See the {@link https://assistant-ui.com/docs/migrations/v0-12 migration guide}.
- *
- * Hook to access the ComposerRuntime from the current context.
- *
- * The ComposerRuntime provides access to composer state and actions for message
- * composition, including text input, attachments, and sending functionality.
- * This hook automatically resolves to either the message's edit composer or
- * the thread's main composer depending on the context.
- *
- * @param options Configuration options
- * @param options.optional Whether the hook should return null if no context is found
- * @returns The ComposerRuntime instance, or null if optional is true and no context exists
- *
- * @example
- * ```tsx
- * // Before:
- * function ComposerActions() {
- *   const runtime = useComposerRuntime();
- *   const handleSend = () => {
- *     if (runtime.getState().canSend) {
- *       runtime.send();
- *     }
- *   };
- *   const handleCancel = () => {
- *     if (runtime.getState().canCancel) {
- *       runtime.cancel();
- *     }
- *   };
- *   return (
- *     <div>
- *       <button onClick={handleSend}>Send</button>
- *       <button onClick={handleCancel}>Cancel</button>
- *     </div>
- *   );
- * }
- *
- * // After:
- * function ComposerActions() {
- *   const aui = useAui();
- *   const canSend = useAuiState((s) => s.composer.canSend);
- *   const canCancel = useAuiState((s) => s.composer.canCancel);
- *   const handleSend = () => {
- *     if (canSend) {
- *       aui.composer().send();
- *     }
- *   };
- *   const handleCancel = () => {
- *     if (canCancel) {
- *       aui.composer().cancel();
- *     }
- *   };
- *   return (
- *     <div>
- *       <button onClick={handleSend}>Send</button>
- *       <button onClick={handleCancel}>Cancel</button>
- *     </div>
- *   );
- * }
- * ```
- */
-declare function useComposerRuntime(options?: {
-  optional?: false | undefined;
-}): ComposerRuntime;
-declare function useComposerRuntime(options?: {
-  optional?: boolean | undefined;
-}): ComposerRuntime | null;
-/**
- * @deprecated Use {@link useAuiState}: `useAuiState((s) => s.composer)`. See the {@link https://assistant-ui.com/docs/migrations/v0-12 migration guide}.
- *
- * Hook to access the current composer state.
- *
- * This hook provides reactive access to the composer's state, including text content,
- * attachments, editing status, and send/cancel capabilities.
- *
- * @param selector Optional selector function to pick specific state properties
- * @returns The selected composer state or the entire composer state if no selector provided
- *
- * @example
- * ```tsx
- * // Before:
- * function ComposerStatus() {
- *   const text = useComposer((state) => state.text);
- *   const canSend = useComposer((state) => state.canSend);
- *   const attachmentCount = useComposer((state) => state.attachments.length);
- *   return (
- *     <div>
- *       Text: {text.length} chars,
- *       Attachments: {attachmentCount},
- *       Can send: {canSend}
- *     </div>
- *   );
- * }
- *
- * // After:
- * function ComposerStatus() {
- *   const text = useAuiState((s) => s.composer.text);
- *   const canSend = useAuiState((s) => s.composer.canSend);
- *   const attachmentCount = useAuiState((s) => s.composer.attachments.length);
- *   return (
- *     <div>
- *       Text: {text.length} chars,
- *       Attachments: {attachmentCount},
- *       Can send: {canSend}
- *     </div>
- *   );
- * }
- * ```
- */
-declare const useComposer: {
-  (): import("@assistant-ui/core").ComposerState;
-  <TSelected>(selector: (state: import("@assistant-ui/core").ComposerState) => TSelected): TSelected;
-  <TSelected>(selector: ((state: import("@assistant-ui/core").ComposerState) => TSelected) | undefined): import("@assistant-ui/core").ComposerState | TSelected;
-  (options: {
-    optional?: false | undefined;
-  }): import("@assistant-ui/core").ComposerState;
-  (options: {
-    optional?: boolean | undefined;
-  }): import("@assistant-ui/core").ComposerState | null;
-  <TSelected>(options: {
-    optional?: false | undefined;
-    selector: (state: import("@assistant-ui/core").ComposerState) => TSelected;
-  }): TSelected;
-  <TSelected>(options: {
-    optional?: false | undefined;
-    selector: ((state: import("@assistant-ui/core").ComposerState) => TSelected) | undefined;
-  }): import("@assistant-ui/core").ComposerState | TSelected;
-  <TSelected>(options: {
-    optional?: boolean | undefined;
-    selector: (state: import("@assistant-ui/core").ComposerState) => TSelected;
-  }): TSelected | null;
-  <TSelected>(options: {
-    optional?: boolean | undefined;
-    selector: ((state: import("@assistant-ui/core").ComposerState) => TSelected) | undefined;
-  }): import("@assistant-ui/core").ComposerState | TSelected | null;
-};
-//#endregion
-export { useComposer, useComposerRuntime };
-//# sourceMappingURL=ComposerContext.d.ts.map

package/dist/legacy-runtime/hooks/ComposerContext.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ComposerContext.d.ts","names":[],"sources":["../../../src/legacy-runtime/hooks/ComposerContext.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmEgB,mBAAmB;EACjC;IACE;iBACY,mBAAmB;EACjC;IACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0DS"}

package/dist/legacy-runtime/hooks/ComposerContext.js

@@ -1,65 +0,0 @@
-"use client";
-import { createStateHookForRuntime } from "../../context/react/utils/createStateHookForRuntime.js";
-import { useAui, useAuiState } from "@assistant-ui/store";
-import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
-//#region src/legacy-runtime/hooks/ComposerContext.ts
-function useComposerRuntime(options) {
-	const $ = c(2);
-	const aui = useAui();
-	let t0;
-	if ($[0] !== aui) {
-		t0 = () => aui.composer.source ? aui.composer().__internal_getRuntime?.() ?? null : null;
-		$[0] = aui;
-		$[1] = t0;
-	} else t0 = $[1];
-	const runtime = useAuiState(t0);
-	if (!runtime && !options?.optional) throw new Error("ComposerRuntime is not available");
-	return runtime;
-}
-/**
-* @deprecated Use {@link useAuiState}: `useAuiState((s) => s.composer)`. See the {@link https://assistant-ui.com/docs/migrations/v0-12 migration guide}.
-*
-* Hook to access the current composer state.
-*
-* This hook provides reactive access to the composer's state, including text content,
-* attachments, editing status, and send/cancel capabilities.
-*
-* @param selector Optional selector function to pick specific state properties
-* @returns The selected composer state or the entire composer state if no selector provided
-*
-* @example
-* ```tsx
-* // Before:
-* function ComposerStatus() {
-*   const text = useComposer((state) => state.text);
-*   const canSend = useComposer((state) => state.canSend);
-*   const attachmentCount = useComposer((state) => state.attachments.length);
-*   return (
-*     <div>
-*       Text: {text.length} chars,
-*       Attachments: {attachmentCount},
-*       Can send: {canSend}
-*     </div>
-*   );
-* }
-*
-* // After:
-* function ComposerStatus() {
-*   const text = useAuiState((s) => s.composer.text);
-*   const canSend = useAuiState((s) => s.composer.canSend);
-*   const attachmentCount = useAuiState((s) => s.composer.attachments.length);
-*   return (
-*     <div>
-*       Text: {text.length} chars,
-*       Attachments: {attachmentCount},
-*       Can send: {canSend}
-*     </div>
-*   );
-* }
-* ```
-*/
-const useComposer = createStateHookForRuntime(useComposerRuntime);
-//#endregion
-export { useComposer, useComposerRuntime };
-
-//# sourceMappingURL=ComposerContext.js.map

package/dist/legacy-runtime/hooks/ComposerContext.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ComposerContext.js","names":["c","_c","useAui","useAuiState","ComposerRuntime","createStateHookForRuntime","useComposerRuntime","options","optional","$","aui","t0","composer","source","__internal_getRuntime","runtime","Error","useComposer"],"sources":["../../../src/legacy-runtime/hooks/ComposerContext.ts"],"sourcesContent":["\"use client\";\n\nimport { useAui, useAuiState } from \"@assistant-ui/store\";\nimport type { ComposerRuntime } from \"../runtime/ComposerRuntime\";\nimport { createStateHookForRuntime } from \"../../context/react/utils/createStateHookForRuntime\";\n\n/**\n * @deprecated Use {@link useAui} with `aui.composer()` instead. See the {@link https://assistant-ui.com/docs/migrations/v0-12 migration guide}.\n *\n * Hook to access the ComposerRuntime from the current context.\n *\n * The ComposerRuntime provides access to composer state and actions for message\n * composition, including text input, attachments, and sending functionality.\n * This hook automatically resolves to either the message's edit composer or\n * the thread's main composer depending on the context.\n *\n * @param options Configuration options\n * @param options.optional Whether the hook should return null if no context is found\n * @returns The ComposerRuntime instance, or null if optional is true and no context exists\n *\n * @example\n * ```tsx\n * // Before:\n * function ComposerActions() {\n *   const runtime = useComposerRuntime();\n *   const handleSend = () => {\n *     if (runtime.getState().canSend) {\n *       runtime.send();\n *     }\n *   };\n *   const handleCancel = () => {\n *     if (runtime.getState().canCancel) {\n *       runtime.cancel();\n *     }\n *   };\n *   return (\n *     <div>\n *       <button onClick={handleSend}>Send</button>\n *       <button onClick={handleCancel}>Cancel</button>\n *     </div>\n *   );\n * }\n *\n * // After:\n * function ComposerActions() {\n *   const aui = useAui();\n *   const canSend = useAuiState((s) => s.composer.canSend);\n *   const canCancel = useAuiState((s) => s.composer.canCancel);\n *   const handleSend = () => {\n *     if (canSend) {\n *       aui.composer().send();\n *     }\n *   };\n *   const handleCancel = () => {\n *     if (canCancel) {\n *       aui.composer().cancel();\n *     }\n *   };\n *   return (\n *     <div>\n *       <button onClick={handleSend}>Send</button>\n *       <button onClick={handleCancel}>Cancel</button>\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useComposerRuntime(options?: {\n  optional?: false | undefined;\n}): ComposerRuntime;\nexport function useComposerRuntime(options?: {\n  optional?: boolean | undefined;\n}): ComposerRuntime | null;\nexport function useComposerRuntime(options?: {\n  optional?: boolean | undefined;\n}): ComposerRuntime | null {\n  const aui = useAui();\n  const runtime = useAuiState(() =>\n    aui.composer.source\n      ? (aui.composer().__internal_getRuntime?.() ?? null)\n      : null,\n  );\n  if (!runtime && !options?.optional) {\n    throw new Error(\"ComposerRuntime is not available\");\n  }\n  return runtime;\n}\n\n/**\n * @deprecated Use {@link useAuiState}: `useAuiState((s) => s.composer)`. See the {@link https://assistant-ui.com/docs/migrations/v0-12 migration guide}.\n *\n * Hook to access the current composer state.\n *\n * This hook provides reactive access to the composer's state, including text content,\n * attachments, editing status, and send/cancel capabilities.\n *\n * @param selector Optional selector function to pick specific state properties\n * @returns The selected composer state or the entire composer state if no selector provided\n *\n * @example\n * ```tsx\n * // Before:\n * function ComposerStatus() {\n *   const text = useComposer((state) => state.text);\n *   const canSend = useComposer((state) => state.canSend);\n *   const attachmentCount = useComposer((state) => state.attachments.length);\n *   return (\n *     <div>\n *       Text: {text.length} chars,\n *       Attachments: {attachmentCount},\n *       Can send: {canSend}\n *     </div>\n *   );\n * }\n *\n * // After:\n * function ComposerStatus() {\n *   const text = useAuiState((s) => s.composer.text);\n *   const canSend = useAuiState((s) => s.composer.canSend);\n *   const attachmentCount = useAuiState((s) => s.composer.attachments.length);\n *   return (\n *     <div>\n *       Text: {text.length} chars,\n *       Attachments: {attachmentCount},\n *       Can send: {canSend}\n *     </div>\n *   );\n * }\n * ```\n */\nexport const useComposer = createStateHookForRuntime(useComposerRuntime);\n"],"mappings":";;;;;AAyEA,SAAOM,mBAAAC,SAAA;CAAA,MAAAE,IAAAR,EAAA,CAAA;CAGL,MAAAS,MAAYR,OAAO;CAAE,IAAAS;CAAA,IAAAF,EAAA,OAAAC,KAAA;EACOC,WAC1BD,IAAGE,SAASC,SACPH,IAAGE,SAAU,CAAC,CAAAE,wBAAiC,KAA/C,OADL;EAEQL,EAAA,KAAAC;EAAAD,EAAA,KAAAE;CAAA,OAAAA,KAAAF,EAAA;CAHV,MAAAM,UAAgBZ,YAAYQ,EAI5B;CACA,IAAI,CAACI,WAAD,CAAaR,SAAOC,UACtB,MAAM,IAAIQ,MAAM,kCAAkC;CACnD,OACMD;AAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6ChB,MAAaE,cAAcZ,0BAA0BC,kBAAkB"}

package/dist/legacy-runtime/hooks/MessageContext.d.ts

@@ -1,155 +0,0 @@
-import { MessageRuntime } from "../runtime/MessageRuntime.js";
-//#region src/legacy-runtime/hooks/MessageContext.d.ts
-/**
- * @deprecated Use {@link useAui} with `aui.message()` instead. See the {@link https://assistant-ui.com/docs/migrations/v0-12 migration guide}.
- *
- * Hook to access the MessageRuntime from the current context.
- *
- * The MessageRuntime provides access to message-level state and actions,
- * including message content, status, editing capabilities, and branching.
- *
- * @param options Configuration options
- * @param options.optional Whether the hook should return null if no context is found
- * @returns The MessageRuntime instance, or null if optional is true and no context exists
- *
- * @example
- * ```tsx
- * // Before:
- * function MessageActions() {
- *   const runtime = useMessageRuntime();
- *   const handleReload = () => {
- *     runtime.reload();
- *   };
- *   const handleEdit = () => {
- *     runtime.startEdit();
- *   };
- *   return (
- *     <div>
- *       <button onClick={handleReload}>Reload</button>
- *       <button onClick={handleEdit}>Edit</button>
- *     </div>
- *   );
- * }
- *
- * // After:
- * function MessageActions() {
- *   const aui = useAui();
- *   const handleReload = () => {
- *     aui.message().reload();
- *   };
- *   const handleEdit = () => {
- *     aui.message().startEdit();
- *   };
- *   return (
- *     <div>
- *       <button onClick={handleReload}>Reload</button>
- *       <button onClick={handleEdit}>Edit</button>
- *     </div>
- *   );
- * }
- * ```
- */
-declare function useMessageRuntime(options?: {
-  optional?: false | undefined;
-}): MessageRuntime;
-declare function useMessageRuntime(options?: {
-  optional?: boolean | undefined;
-}): MessageRuntime | null;
-/**
- * @deprecated Use {@link useAuiState}: `useAuiState((s) => s.message)`. See the {@link https://assistant-ui.com/docs/migrations/v0-12 migration guide}.
- *
- * Hook to access the current message state.
- *
- * This hook provides reactive access to the message's state, including content,
- * role, status, and other message-level properties.
- *
- * @param selector Optional selector function to pick specific state properties
- * @returns The selected message state or the entire message state if no selector provided
- *
- * @example
- * ```tsx
- * // Before:
- * function MessageContent() {
- *   const role = useMessage((state) => state.role);
- *   const content = useMessage((state) => state.content);
- *   const isLoading = useMessage((state) => state.status.type === "running");
- *   return (
- *     <div className={`message-${role}`}>
- *       {isLoading ? "Loading..." : content.map(part => part.text).join("")}
- *     </div>
- *   );
- * }
- *
- * // After:
- * function MessageContent() {
- *   const role = useAuiState((s) => s.message.role);
- *   const content = useAuiState((s) => s.message.content);
- *   const isLoading = useAuiState((s) => s.message.status.type === "running");
- *   return (
- *     <div className={`message-${role}`}>
- *       {isLoading ? "Loading..." : content.map(part => part.text).join("")}
- *     </div>
- *   );
- * }
- * ```
- */
-declare const useMessage: {
-  (): import("@assistant-ui/core").MessageState;
-  <TSelected>(selector: (state: import("@assistant-ui/core").MessageState) => TSelected): TSelected;
-  <TSelected>(selector: ((state: import("@assistant-ui/core").MessageState) => TSelected) | undefined): import("@assistant-ui/core").MessageState | TSelected;
-  (options: {
-    optional?: false | undefined;
-  }): import("@assistant-ui/core").MessageState;
-  (options: {
-    optional?: boolean | undefined;
-  }): import("@assistant-ui/core").MessageState | null;
-  <TSelected>(options: {
-    optional?: false | undefined;
-    selector: (state: import("@assistant-ui/core").MessageState) => TSelected;
-  }): TSelected;
-  <TSelected>(options: {
-    optional?: false | undefined;
-    selector: ((state: import("@assistant-ui/core").MessageState) => TSelected) | undefined;
-  }): import("@assistant-ui/core").MessageState | TSelected;
-  <TSelected>(options: {
-    optional?: boolean | undefined;
-    selector: (state: import("@assistant-ui/core").MessageState) => TSelected;
-  }): TSelected | null;
-  <TSelected>(options: {
-    optional?: boolean | undefined;
-    selector: ((state: import("@assistant-ui/core").MessageState) => TSelected) | undefined;
-  }): import("@assistant-ui/core").MessageState | TSelected | null;
-};
-/**
- * @deprecated Use {@link useAuiState}: `useAuiState((s) => s.message.composer)`. See the {@link https://assistant-ui.com/docs/migrations/v0-12 migration guide}.
- */
-declare const useEditComposer: {
-  (): import("@assistant-ui/core").EditComposerState;
-  <TSelected>(selector: (state: import("@assistant-ui/core").EditComposerState) => TSelected): TSelected;
-  <TSelected>(selector: ((state: import("@assistant-ui/core").EditComposerState) => TSelected) | undefined): import("@assistant-ui/core").EditComposerState | TSelected;
-  (options: {
-    optional?: false | undefined;
-  }): import("@assistant-ui/core").EditComposerState;
-  (options: {
-    optional?: boolean | undefined;
-  }): import("@assistant-ui/core").EditComposerState | null;
-  <TSelected>(options: {
-    optional?: false | undefined;
-    selector: (state: import("@assistant-ui/core").EditComposerState) => TSelected;
-  }): TSelected;
-  <TSelected>(options: {
-    optional?: false | undefined;
-    selector: ((state: import("@assistant-ui/core").EditComposerState) => TSelected) | undefined;
-  }): import("@assistant-ui/core").EditComposerState | TSelected;
-  <TSelected>(options: {
-    optional?: boolean | undefined;
-    selector: (state: import("@assistant-ui/core").EditComposerState) => TSelected;
-  }): TSelected | null;
-  <TSelected>(options: {
-    optional?: boolean | undefined;
-    selector: ((state: import("@assistant-ui/core").EditComposerState) => TSelected) | undefined;
-  }): import("@assistant-ui/core").EditComposerState | TSelected | null;
-};
-//#endregion
-export { useEditComposer, useMessage, useMessageRuntime };
-//# sourceMappingURL=MessageContext.d.ts.map

package/dist/legacy-runtime/hooks/MessageContext.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MessageContext.d.ts","names":[],"sources":["../../../src/legacy-runtime/hooks/MessageContext.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwDgB,kBAAkB;EAChC;IACE;iBACY,kBAAkB;EAChC;IACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsDS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cASA"}

package/dist/legacy-runtime/hooks/MessageContext.js

@@ -1,68 +0,0 @@
-"use client";
-import { createStateHookForRuntime } from "../../context/react/utils/createStateHookForRuntime.js";
-import { useAui, useAuiState } from "@assistant-ui/store";
-import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
-//#region src/legacy-runtime/hooks/MessageContext.ts
-function useMessageRuntime(options) {
-	const $ = c(2);
-	const aui = useAui();
-	let t0;
-	if ($[0] !== aui) {
-		t0 = () => aui.message.source ? aui.message().__internal_getRuntime?.() ?? null : null;
-		$[0] = aui;
-		$[1] = t0;
-	} else t0 = $[1];
-	const runtime = useAuiState(t0);
-	if (!runtime && !options?.optional) throw new Error("MessageRuntime is not available");
-	return runtime;
-}
-/**
-* @deprecated Use {@link useAuiState}: `useAuiState((s) => s.message)`. See the {@link https://assistant-ui.com/docs/migrations/v0-12 migration guide}.
-*
-* Hook to access the current message state.
-*
-* This hook provides reactive access to the message's state, including content,
-* role, status, and other message-level properties.
-*
-* @param selector Optional selector function to pick specific state properties
-* @returns The selected message state or the entire message state if no selector provided
-*
-* @example
-* ```tsx
-* // Before:
-* function MessageContent() {
-*   const role = useMessage((state) => state.role);
-*   const content = useMessage((state) => state.content);
-*   const isLoading = useMessage((state) => state.status.type === "running");
-*   return (
-*     <div className={`message-${role}`}>
-*       {isLoading ? "Loading..." : content.map(part => part.text).join("")}
-*     </div>
-*   );
-* }
-*
-* // After:
-* function MessageContent() {
-*   const role = useAuiState((s) => s.message.role);
-*   const content = useAuiState((s) => s.message.content);
-*   const isLoading = useAuiState((s) => s.message.status.type === "running");
-*   return (
-*     <div className={`message-${role}`}>
-*       {isLoading ? "Loading..." : content.map(part => part.text).join("")}
-*     </div>
-*   );
-* }
-* ```
-*/
-const useMessage = createStateHookForRuntime(useMessageRuntime);
-const useEditComposerRuntime = (opt) => {
-	return useMessageRuntime(opt)?.composer ?? null;
-};
-/**
-* @deprecated Use {@link useAuiState}: `useAuiState((s) => s.message.composer)`. See the {@link https://assistant-ui.com/docs/migrations/v0-12 migration guide}.
-*/
-const useEditComposer = createStateHookForRuntime(useEditComposerRuntime);
-//#endregion
-export { useEditComposer, useMessage, useMessageRuntime };
-
-//# sourceMappingURL=MessageContext.js.map

package/dist/legacy-runtime/hooks/MessageContext.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"MessageContext.js","names":["c","_c","MessageRuntime","useAui","useAuiState","createStateHookForRuntime","EditComposerRuntime","useMessageRuntime","options","optional","$","aui","t0","message","source","__internal_getRuntime","runtime","Error","useMessage","useEditComposerRuntime","opt","composer","useEditComposer"],"sources":["../../../src/legacy-runtime/hooks/MessageContext.ts"],"sourcesContent":["\"use client\";\n\nimport type { MessageRuntime } from \"../runtime/MessageRuntime\";\nimport { useAui, useAuiState } from \"@assistant-ui/store\";\nimport { createStateHookForRuntime } from \"../../context/react/utils/createStateHookForRuntime\";\nimport type { EditComposerRuntime } from \"@assistant-ui/core\";\n\n/**\n * @deprecated Use {@link useAui} with `aui.message()` instead. See the {@link https://assistant-ui.com/docs/migrations/v0-12 migration guide}.\n *\n * Hook to access the MessageRuntime from the current context.\n *\n * The MessageRuntime provides access to message-level state and actions,\n * including message content, status, editing capabilities, and branching.\n *\n * @param options Configuration options\n * @param options.optional Whether the hook should return null if no context is found\n * @returns The MessageRuntime instance, or null if optional is true and no context exists\n *\n * @example\n * ```tsx\n * // Before:\n * function MessageActions() {\n *   const runtime = useMessageRuntime();\n *   const handleReload = () => {\n *     runtime.reload();\n *   };\n *   const handleEdit = () => {\n *     runtime.startEdit();\n *   };\n *   return (\n *     <div>\n *       <button onClick={handleReload}>Reload</button>\n *       <button onClick={handleEdit}>Edit</button>\n *     </div>\n *   );\n * }\n *\n * // After:\n * function MessageActions() {\n *   const aui = useAui();\n *   const handleReload = () => {\n *     aui.message().reload();\n *   };\n *   const handleEdit = () => {\n *     aui.message().startEdit();\n *   };\n *   return (\n *     <div>\n *       <button onClick={handleReload}>Reload</button>\n *       <button onClick={handleEdit}>Edit</button>\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useMessageRuntime(options?: {\n  optional?: false | undefined;\n}): MessageRuntime;\nexport function useMessageRuntime(options?: {\n  optional?: boolean | undefined;\n}): MessageRuntime | null;\nexport function useMessageRuntime(options?: {\n  optional?: boolean | undefined;\n}) {\n  const aui = useAui();\n  const runtime = useAuiState(() =>\n    aui.message.source\n      ? (aui.message().__internal_getRuntime?.() ?? null)\n      : null,\n  );\n  if (!runtime && !options?.optional) {\n    throw new Error(\"MessageRuntime is not available\");\n  }\n  return runtime;\n}\n\n/**\n * @deprecated Use {@link useAuiState}: `useAuiState((s) => s.message)`. See the {@link https://assistant-ui.com/docs/migrations/v0-12 migration guide}.\n *\n * Hook to access the current message state.\n *\n * This hook provides reactive access to the message's state, including content,\n * role, status, and other message-level properties.\n *\n * @param selector Optional selector function to pick specific state properties\n * @returns The selected message state or the entire message state if no selector provided\n *\n * @example\n * ```tsx\n * // Before:\n * function MessageContent() {\n *   const role = useMessage((state) => state.role);\n *   const content = useMessage((state) => state.content);\n *   const isLoading = useMessage((state) => state.status.type === \"running\");\n *   return (\n *     <div className={`message-${role}`}>\n *       {isLoading ? \"Loading...\" : content.map(part => part.text).join(\"\")}\n *     </div>\n *   );\n * }\n *\n * // After:\n * function MessageContent() {\n *   const role = useAuiState((s) => s.message.role);\n *   const content = useAuiState((s) => s.message.content);\n *   const isLoading = useAuiState((s) => s.message.status.type === \"running\");\n *   return (\n *     <div className={`message-${role}`}>\n *       {isLoading ? \"Loading...\" : content.map(part => part.text).join(\"\")}\n *     </div>\n *   );\n * }\n * ```\n */\nexport const useMessage = createStateHookForRuntime(useMessageRuntime);\n\nconst useEditComposerRuntime = (opt: {\n  optional: boolean | undefined;\n}): EditComposerRuntime | null => useMessageRuntime(opt)?.composer ?? null;\n\n/**\n * @deprecated Use {@link useAuiState}: `useAuiState((s) => s.message.composer)`. See the {@link https://assistant-ui.com/docs/migrations/v0-12 migration guide}.\n */\nexport const useEditComposer = createStateHookForRuntime(\n  useEditComposerRuntime,\n);\n"],"mappings":";;;;;AA8DA,SAAOO,kBAAAC,SAAA;CAAA,MAAAE,IAAAT,EAAA,CAAA;CAGL,MAAAU,MAAYR,OAAO;CAAE,IAAAS;CAAA,IAAAF,EAAA,OAAAC,KAAA;EACOC,WAC1BD,IAAGE,QAAQC,SACNH,IAAGE,QAAS,CAAC,CAAAE,wBAAiC,KAA9C,OADL;EAEQL,EAAA,KAAAC;EAAAD,EAAA,KAAAE;CAAA,OAAAA,KAAAF,EAAA;CAHV,MAAAM,UAAgBZ,YAAYQ,EAI5B;CACA,IAAI,CAACI,WAAD,CAAaR,SAAOC,UACtB,MAAM,IAAIQ,MAAM,iCAAiC;CAClD,OACMD;AAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyChB,MAAaE,aAAab,0BAA0BE,iBAAiB;AAErE,MAAMY,0BAAyBC,QAAA;CAAA,OAEGb,kBAAkBa,GAAa,CAAC,EAAAC,YAAhC;AAAwC;;;;AAK1E,MAAaC,kBAAkBjB,0BAC7Bc,sBACF"}

package/dist/legacy-runtime/hooks/MessagePartContext.d.ts

@@ -1,44 +0,0 @@
-import { MessagePartRuntime } from "../runtime/MessagePartRuntime.js";
-//#region src/legacy-runtime/hooks/MessagePartContext.d.ts
-/**
- * @deprecated Use {@link useAui} with `aui.part()` instead. See the {@link https://assistant-ui.com/docs/migrations/v0-12 migration guide}.
- */
-declare function useMessagePartRuntime(options?: {
-  optional?: false | undefined;
-}): MessagePartRuntime;
-declare function useMessagePartRuntime(options?: {
-  optional?: boolean | undefined;
-}): MessagePartRuntime | null;
-/**
- * @deprecated Use {@link useAuiState}: `useAuiState((s) => s.part)`. See the {@link https://assistant-ui.com/docs/migrations/v0-12 migration guide}.
- */
-declare const useMessagePart: {
-  (): import("@assistant-ui/core").MessagePartState;
-  <TSelected>(selector: (state: import("@assistant-ui/core").MessagePartState) => TSelected): TSelected;
-  <TSelected>(selector: ((state: import("@assistant-ui/core").MessagePartState) => TSelected) | undefined): import("@assistant-ui/core").MessagePartState | TSelected;
-  (options: {
-    optional?: false | undefined;
-  }): import("@assistant-ui/core").MessagePartState;
-  (options: {
-    optional?: boolean | undefined;
-  }): import("@assistant-ui/core").MessagePartState | null;
-  <TSelected>(options: {
-    optional?: false | undefined;
-    selector: (state: import("@assistant-ui/core").MessagePartState) => TSelected;
-  }): TSelected;
-  <TSelected>(options: {
-    optional?: false | undefined;
-    selector: ((state: import("@assistant-ui/core").MessagePartState) => TSelected) | undefined;
-  }): import("@assistant-ui/core").MessagePartState | TSelected;
-  <TSelected>(options: {
-    optional?: boolean | undefined;
-    selector: (state: import("@assistant-ui/core").MessagePartState) => TSelected;
-  }): TSelected | null;
-  <TSelected>(options: {
-    optional?: boolean | undefined;
-    selector: ((state: import("@assistant-ui/core").MessagePartState) => TSelected) | undefined;
-  }): import("@assistant-ui/core").MessagePartState | TSelected | null;
-};
-//#endregion
-export { useMessagePart, useMessagePartRuntime };
-//# sourceMappingURL=MessagePartContext.d.ts.map

package/dist/legacy-runtime/hooks/MessagePartContext.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MessagePartContext.d.ts","names":[],"sources":["../../../src/legacy-runtime/hooks/MessagePartContext.ts"],"mappings":";;;;;iBASgB,sBAAsB;EACpC;IACE;iBACY,sBAAsB;EACpC;IACE;;;;cAiBS"}

package/dist/legacy-runtime/hooks/MessagePartContext.js

@@ -1,26 +0,0 @@
-"use client";
-import { createStateHookForRuntime } from "../../context/react/utils/createStateHookForRuntime.js";
-import { useAui, useAuiState } from "@assistant-ui/store";
-import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
-//#region src/legacy-runtime/hooks/MessagePartContext.ts
-function useMessagePartRuntime(options) {
-	const $ = c(2);
-	const aui = useAui();
-	let t0;
-	if ($[0] !== aui) {
-		t0 = () => aui.part.source ? aui.part().__internal_getRuntime?.() ?? null : null;
-		$[0] = aui;
-		$[1] = t0;
-	} else t0 = $[1];
-	const runtime = useAuiState(t0);
-	if (!runtime && !options?.optional) throw new Error("MessagePartRuntime is not available");
-	return runtime;
-}
-/**
-* @deprecated Use {@link useAuiState}: `useAuiState((s) => s.part)`. See the {@link https://assistant-ui.com/docs/migrations/v0-12 migration guide}.
-*/
-const useMessagePart = createStateHookForRuntime(useMessagePartRuntime);
-//#endregion
-export { useMessagePart, useMessagePartRuntime };
-
-//# sourceMappingURL=MessagePartContext.js.map

package/dist/legacy-runtime/hooks/MessagePartContext.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"MessagePartContext.js","names":["c","_c","MessagePartRuntime","createStateHookForRuntime","useAui","useAuiState","useMessagePartRuntime","options","optional","$","aui","t0","part","source","__internal_getRuntime","runtime","Error","useMessagePart"],"sources":["../../../src/legacy-runtime/hooks/MessagePartContext.ts"],"sourcesContent":["\"use client\";\n\nimport type { MessagePartRuntime } from \"../runtime/MessagePartRuntime\";\nimport { createStateHookForRuntime } from \"../../context/react/utils/createStateHookForRuntime\";\nimport { useAui, useAuiState } from \"@assistant-ui/store\";\n\n/**\n * @deprecated Use {@link useAui} with `aui.part()` instead. See the {@link https://assistant-ui.com/docs/migrations/v0-12 migration guide}.\n */\nexport function useMessagePartRuntime(options?: {\n  optional?: false | undefined;\n}): MessagePartRuntime;\nexport function useMessagePartRuntime(options?: {\n  optional?: boolean | undefined;\n}): MessagePartRuntime | null;\nexport function useMessagePartRuntime(options?: {\n  optional?: boolean | undefined;\n}) {\n  const aui = useAui();\n  const runtime = useAuiState(() =>\n    aui.part.source ? (aui.part().__internal_getRuntime?.() ?? null) : null,\n  );\n  if (!runtime && !options?.optional) {\n    throw new Error(\"MessagePartRuntime is not available\");\n  }\n  return runtime;\n}\n\n/**\n * @deprecated Use {@link useAuiState}: `useAuiState((s) => s.part)`. See the {@link https://assistant-ui.com/docs/migrations/v0-12 migration guide}.\n */\nexport const useMessagePart = createStateHookForRuntime(useMessagePartRuntime);\n"],"mappings":";;;;;AAeA,SAAOM,sBAAAC,SAAA;CAAA,MAAAE,IAAAR,EAAA,CAAA;CAGL,MAAAS,MAAYN,OAAO;CAAE,IAAAO;CAAA,IAAAF,EAAA,OAAAC,KAAA;EACOC,WAC1BD,IAAGE,KAAKC,SAAWH,IAAGE,KAAM,CAAC,CAAAE,wBAAiC,KAA3C,OAAnB;EAAuEL,EAAA,KAAAC;EAAAD,EAAA,KAAAE;CAAA,OAAAA,KAAAF,EAAA;CADzE,MAAAM,UAAgBV,YAAYM,EAE5B;CACA,IAAI,CAACI,WAAD,CAAaR,SAAOC,UACtB,MAAM,IAAIQ,MAAM,qCAAqC;CACtD,OACMD;AAAO;;;;AAMhB,MAAaE,iBAAiBd,0BAA0BG,qBAAqB"}