@assistant-ui/react 0.14.23 → 0.14.24

package/dist/primitives/thread.d.ts

@@ -4,15 +4,15 @@ import { ThreadPrimitiveEmpty } from "./thread/ThreadEmpty.js";
 import { ThreadPrimitiveIf } from "./thread/ThreadIf.js";
 import { ThreadPrimitiveViewport } from "./thread/ThreadViewport.js";
 import { ThreadPrimitiveViewportFooter } from "./thread/ThreadViewportFooter.js";
-import { ThreadPrimitiveMessageByIndex, ThreadPrimitiveMessages } from "./thread/ThreadMessages.js";
+import { ThreadPrimitiveMessageByIndex, ThreadPrimitiveMessages, ThreadPrimitiveUnstable_MessageById } from "./thread/ThreadMessages.js";
 import { ThreadPrimitiveScrollToBottom } from "./thread/ThreadScrollToBottom.js";
 import { ThreadPrimitiveSuggestion } from "./thread/ThreadSuggestion.js";
 import { ThreadPrimitiveSuggestionByIndex, ThreadPrimitiveSuggestions } from "./thread/ThreadSuggestions.js";
 
 //#region src/primitives/thread.d.ts
 declare namespace thread_d_exports {
-  export { ThreadPrimitiveEmpty as Empty, ThreadPrimitiveIf as If, ThreadPrimitiveMessageByIndex as MessageByIndex, ThreadPrimitiveMessages as Messages, ThreadPrimitiveRoot as Root, ThreadPrimitiveScrollToBottom as ScrollToBottom, ThreadPrimitiveSuggestion as Suggestion, ThreadPrimitiveSuggestionByIndex as SuggestionByIndex, ThreadPrimitiveSuggestions as Suggestions, ThreadPrimitiveViewport as Viewport, ThreadPrimitiveViewportFooter as ViewportFooter, ThreadPrimitiveViewportProvider as ViewportProvider };
+  export { ThreadPrimitiveEmpty as Empty, ThreadPrimitiveIf as If, ThreadPrimitiveMessageByIndex as MessageByIndex, ThreadPrimitiveMessages as Messages, ThreadPrimitiveRoot as Root, ThreadPrimitiveScrollToBottom as ScrollToBottom, ThreadPrimitiveSuggestion as Suggestion, ThreadPrimitiveSuggestionByIndex as SuggestionByIndex, ThreadPrimitiveSuggestions as Suggestions, ThreadPrimitiveUnstable_MessageById as Unstable_MessageById, ThreadPrimitiveViewport as Viewport, ThreadPrimitiveViewportFooter as ViewportFooter, ThreadPrimitiveViewportProvider as ViewportProvider };
 }
 //#endregion
-export { ThreadPrimitiveEmpty as Empty, ThreadPrimitiveIf as If, ThreadPrimitiveMessageByIndex as MessageByIndex, ThreadPrimitiveMessages as Messages, ThreadPrimitiveRoot as Root, ThreadPrimitiveScrollToBottom as ScrollToBottom, ThreadPrimitiveSuggestion as Suggestion, ThreadPrimitiveSuggestionByIndex as SuggestionByIndex, ThreadPrimitiveSuggestions as Suggestions, ThreadPrimitiveViewport as Viewport, ThreadPrimitiveViewportFooter as ViewportFooter, ThreadPrimitiveViewportProvider as ViewportProvider, thread_d_exports };
+export { ThreadPrimitiveEmpty as Empty, ThreadPrimitiveIf as If, ThreadPrimitiveMessageByIndex as MessageByIndex, ThreadPrimitiveMessages as Messages, ThreadPrimitiveRoot as Root, ThreadPrimitiveScrollToBottom as ScrollToBottom, ThreadPrimitiveSuggestion as Suggestion, ThreadPrimitiveSuggestionByIndex as SuggestionByIndex, ThreadPrimitiveSuggestions as Suggestions, ThreadPrimitiveUnstable_MessageById as Unstable_MessageById, ThreadPrimitiveViewport as Viewport, ThreadPrimitiveViewportFooter as ViewportFooter, ThreadPrimitiveViewportProvider as ViewportProvider, thread_d_exports };
 //# sourceMappingURL=thread.d.ts.map

package/dist/primitives/thread.js

@@ -5,7 +5,7 @@ import { ThreadPrimitiveEmpty } from "./thread/ThreadEmpty.js";
 import { ThreadPrimitiveIf } from "./thread/ThreadIf.js";
 import { ThreadPrimitiveViewport } from "./thread/ThreadViewport.js";
 import { ThreadPrimitiveViewportFooter } from "./thread/ThreadViewportFooter.js";
-import { ThreadPrimitiveMessageByIndex, ThreadPrimitiveMessages } from "./thread/ThreadMessages.js";
+import { ThreadPrimitiveMessageByIndex, ThreadPrimitiveMessages, ThreadPrimitiveUnstable_MessageById } from "./thread/ThreadMessages.js";
 import { ThreadPrimitiveScrollToBottom } from "./thread/ThreadScrollToBottom.js";
 import { ThreadPrimitiveSuggestion } from "./thread/ThreadSuggestion.js";
 import { ThreadPrimitiveSuggestionByIndex, ThreadPrimitiveSuggestions } from "./thread/ThreadSuggestions.js";
@@ -20,11 +20,12 @@ var thread_exports = /* @__PURE__ */ __exportAll({
 	Suggestion: () => ThreadPrimitiveSuggestion,
 	SuggestionByIndex: () => ThreadPrimitiveSuggestionByIndex,
 	Suggestions: () => ThreadPrimitiveSuggestions,
+	Unstable_MessageById: () => ThreadPrimitiveUnstable_MessageById,
 	Viewport: () => ThreadPrimitiveViewport,
 	ViewportFooter: () => ThreadPrimitiveViewportFooter,
 	ViewportProvider: () => ThreadPrimitiveViewportProvider
 });
 //#endregion
-export { ThreadPrimitiveEmpty as Empty, ThreadPrimitiveIf as If, ThreadPrimitiveMessageByIndex as MessageByIndex, ThreadPrimitiveMessages as Messages, ThreadPrimitiveRoot as Root, ThreadPrimitiveScrollToBottom as ScrollToBottom, ThreadPrimitiveSuggestion as Suggestion, ThreadPrimitiveSuggestionByIndex as SuggestionByIndex, ThreadPrimitiveSuggestions as Suggestions, ThreadPrimitiveViewport as Viewport, ThreadPrimitiveViewportFooter as ViewportFooter, ThreadPrimitiveViewportProvider as ViewportProvider, thread_exports };
+export { ThreadPrimitiveEmpty as Empty, ThreadPrimitiveIf as If, ThreadPrimitiveMessageByIndex as MessageByIndex, ThreadPrimitiveMessages as Messages, ThreadPrimitiveRoot as Root, ThreadPrimitiveScrollToBottom as ScrollToBottom, ThreadPrimitiveSuggestion as Suggestion, ThreadPrimitiveSuggestionByIndex as SuggestionByIndex, ThreadPrimitiveSuggestions as Suggestions, ThreadPrimitiveUnstable_MessageById as Unstable_MessageById, ThreadPrimitiveViewport as Viewport, ThreadPrimitiveViewportFooter as ViewportFooter, ThreadPrimitiveViewportProvider as ViewportProvider, thread_exports };
 
 //# sourceMappingURL=thread.js.map

package/dist/primitives/thread.js.map

@@ -1 +1 @@
-{"version":3,"file":"thread.js","names":["ThreadPrimitiveRoot","Root","ThreadPrimitiveEmpty","Empty","ThreadPrimitiveIf","If","ThreadPrimitiveViewport","Viewport","ThreadPrimitiveViewportProvider","ViewportProvider","ThreadPrimitiveViewportFooter","ViewportFooter","ThreadPrimitiveMessages","Messages","ThreadPrimitiveMessageByIndex","MessageByIndex","ThreadPrimitiveScrollToBottom","ScrollToBottom","ThreadPrimitiveSuggestion","Suggestion","ThreadPrimitiveSuggestions","Suggestions","ThreadPrimitiveSuggestionByIndex","SuggestionByIndex"],"sources":["../../src/primitives/thread.ts"],"sourcesContent":["export { ThreadPrimitiveRoot as Root } from \"./thread/ThreadRoot\";\nexport { ThreadPrimitiveEmpty as Empty } from \"./thread/ThreadEmpty\";\nexport { ThreadPrimitiveIf as If } from \"./thread/ThreadIf\";\nexport { ThreadPrimitiveViewport as Viewport } from \"./thread/ThreadViewport\";\nexport { ThreadPrimitiveViewportProvider as ViewportProvider } from \"../context/providers/ThreadViewportProvider\";\nexport { ThreadPrimitiveViewportFooter as ViewportFooter } from \"./thread/ThreadViewportFooter\";\nexport { ThreadPrimitiveMessages as Messages } from \"./thread/ThreadMessages\";\nexport { ThreadPrimitiveMessageByIndex as MessageByIndex } from \"./thread/ThreadMessages\";\nexport { ThreadPrimitiveScrollToBottom as ScrollToBottom } from \"./thread/ThreadScrollToBottom\";\nexport { ThreadPrimitiveSuggestion as Suggestion } from \"./thread/ThreadSuggestion\";\nexport {\n  ThreadPrimitiveSuggestions as Suggestions,\n  ThreadPrimitiveSuggestionByIndex as SuggestionByIndex,\n} from \"./thread/ThreadSuggestions\";\n"],"mappings":""}
+{"version":3,"file":"thread.js","names":["ThreadPrimitiveRoot","Root","ThreadPrimitiveEmpty","Empty","ThreadPrimitiveIf","If","ThreadPrimitiveViewport","Viewport","ThreadPrimitiveViewportProvider","ViewportProvider","ThreadPrimitiveViewportFooter","ViewportFooter","ThreadPrimitiveMessages","Messages","ThreadPrimitiveMessageByIndex","MessageByIndex","ThreadPrimitiveUnstable_MessageById","Unstable_MessageById","ThreadPrimitiveScrollToBottom","ScrollToBottom","ThreadPrimitiveSuggestion","Suggestion","ThreadPrimitiveSuggestions","Suggestions","ThreadPrimitiveSuggestionByIndex","SuggestionByIndex"],"sources":["../../src/primitives/thread.ts"],"sourcesContent":["export { ThreadPrimitiveRoot as Root } from \"./thread/ThreadRoot\";\nexport { ThreadPrimitiveEmpty as Empty } from \"./thread/ThreadEmpty\";\nexport { ThreadPrimitiveIf as If } from \"./thread/ThreadIf\";\nexport { ThreadPrimitiveViewport as Viewport } from \"./thread/ThreadViewport\";\nexport { ThreadPrimitiveViewportProvider as ViewportProvider } from \"../context/providers/ThreadViewportProvider\";\nexport { ThreadPrimitiveViewportFooter as ViewportFooter } from \"./thread/ThreadViewportFooter\";\nexport { ThreadPrimitiveMessages as Messages } from \"./thread/ThreadMessages\";\nexport { ThreadPrimitiveMessageByIndex as MessageByIndex } from \"./thread/ThreadMessages\";\nexport { ThreadPrimitiveUnstable_MessageById as Unstable_MessageById } from \"./thread/ThreadMessages\";\nexport { ThreadPrimitiveScrollToBottom as ScrollToBottom } from \"./thread/ThreadScrollToBottom\";\nexport { ThreadPrimitiveSuggestion as Suggestion } from \"./thread/ThreadSuggestion\";\nexport {\n  ThreadPrimitiveSuggestions as Suggestions,\n  ThreadPrimitiveSuggestionByIndex as SuggestionByIndex,\n} from \"./thread/ThreadSuggestions\";\n"],"mappings":""}

package/dist/unstable/useComposerInput.d.ts

@@ -0,0 +1,84 @@
+import { TriggerPopoverAriaProps } from "../primitives/composer/useComposerInputState.js";
+import { ComposerSendOptions } from "@assistant-ui/core/store";
+
+//#region src/unstable/useComposerInput.d.ts
+type Unstable_UseComposerInputOptions = {
+  /**
+   * Disables the input in addition to the composer's own disabled sources
+   * (thread disabled, active dictation). When disabled, `isDisabled` is `true`
+   * and `canSend` is `false`.
+   */
+  disabled?: boolean | undefined;
+};
+type Unstable_ComposerInput = {
+  /** Current composer text, or `""` when the composer is not editing. */value: string;
+  /**
+   * Writes `text` into the composer, mirroring `ComposerPrimitive.Input`:
+   * a no-op unless the composer is editing, committed via `flushTapSync` so the
+   * controlled value stays in sync within the same tick.
+   */
+  setText(text: string): void;
+  /**
+   * Sends the current message when `canSend` is `true`; otherwise a no-op.
+   * Accepts the same options as the composer send action.
+   */
+  send(options?: ComposerSendOptions): void;
+  /**
+   * Whether the input is disabled, combining the `disabled` option with the
+   * composer's own disabled sources (thread disabled, active dictation).
+   */
+  isDisabled: boolean;
+  /**
+   * Whether a send is currently available. Matches `ComposerPrimitive.Send`
+   * gating (non-empty editing composer, not running without queue support) and
+   * is additionally `false` while `isDisabled`.
+   */
+  canSend: boolean;
+};
+/**
+ * @deprecated Under active development and might change without notice.
+ *
+ * Headless bridge to the composer's text value and send action, for building a
+ * custom composer input without `ComposerPrimitive.Input`. It is a thin bridge,
+ * not a second input: it does not own keyboard behavior, autosize, IME or
+ * contentEditable sync, paste/drop attachments, focus management, or rich-text
+ * state. Spread `unstable_useTriggerPopoverAriaProps()` onto your element for
+ * trigger-popover combobox semantics.
+ *
+ * @example
+ * ```tsx
+ * const { value, setText, send, isDisabled, canSend } = unstable_useComposerInput();
+ * <textarea
+ *   value={value}
+ *   disabled={isDisabled}
+ *   onChange={(e) => setText(e.target.value)}
+ *   onKeyDown={(e) => {
+ *     if (e.key === "Enter" && !e.shiftKey && canSend) {
+ *       e.preventDefault();
+ *       send();
+ *     }
+ *   }}
+ * />
+ * ```
+ */
+declare function unstable_useComposerInput(options?: Unstable_UseComposerInputOptions): Unstable_ComposerInput;
+type Unstable_TriggerPopoverAriaProps = TriggerPopoverAriaProps;
+/**
+ * @deprecated Under active development and might change without notice.
+ *
+ * ARIA combobox attributes for the focused element (typically the composer
+ * input) describing the open trigger popover, per the WAI-ARIA editable
+ * combobox pattern. Returns an empty object outside a `TriggerPopoverRoot` or
+ * when no popover is open. Spread these last so they take precedence over any
+ * matching ARIA props you set yourself, mirroring `ComposerPrimitive.Input`.
+ *
+ * @example
+ * ```tsx
+ * const aria = unstable_useTriggerPopoverAriaProps();
+ * <textarea {...aria} />
+ * ```
+ */
+declare function unstable_useTriggerPopoverAriaProps(): Unstable_TriggerPopoverAriaProps;
+//#endregion
+export { Unstable_ComposerInput, Unstable_TriggerPopoverAriaProps, Unstable_UseComposerInputOptions, unstable_useComposerInput, unstable_useTriggerPopoverAriaProps };
+//# sourceMappingURL=useComposerInput.d.ts.map

package/dist/unstable/useComposerInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useComposerInput.d.ts","names":[],"sources":["../../src/unstable/useComposerInput.ts"],"mappings":";;;;KAcY,gCAAA;;AAAZ;;;;EAME,QAAQ;AAAA;AAAA,KAGE,sBAAA;yEAEV,KAAA;EAAA;;;;;EAMA,OAAA,CAAQ,IAAA;EAUR;;;AAMO;EAXP,IAAA,CAAK,OAAA,GAAU,mBAAmB;EAwCK;;;;EAnCvC,UAAA;EAqCC;;AAAsB;AA4BzB;;EA3DE,OAAA;AAAA;AA2DoE;AAiBtE;;;;AAAuF;;;;;;;;;;;;;;;;;;;;;AAjBjB,iBA9BtD,yBAAA,CACd,OAAA,GAAU,gCAAA,GACT,sBAAsB;AAAA,KA4Bb,gCAAA,GAAmC,uBAAuB;;;;;;;;;;;;;;;;iBAiBtD,mCAAA,IAAuC,gCAAgC"}

package/dist/unstable/useComposerInput.js

@@ -0,0 +1,78 @@
+"use client";
+import { useComposerInputDisabled, useComposerInputValue, useTriggerPopoverAriaProps } from "../primitives/composer/useComposerInputState.js";
+import { useAui } from "@assistant-ui/store";
+import { useComposerSend } from "@assistant-ui/core/react";
+import { useCallback } from "@assistant-ui/tap/react-shim";
+import { flushTapSync } from "@assistant-ui/tap";
+//#region src/unstable/useComposerInput.ts
+/**
+* @deprecated Under active development and might change without notice.
+*
+* Headless bridge to the composer's text value and send action, for building a
+* custom composer input without `ComposerPrimitive.Input`. It is a thin bridge,
+* not a second input: it does not own keyboard behavior, autosize, IME or
+* contentEditable sync, paste/drop attachments, focus management, or rich-text
+* state. Spread `unstable_useTriggerPopoverAriaProps()` onto your element for
+* trigger-popover combobox semantics.
+*
+* @example
+* ```tsx
+* const { value, setText, send, isDisabled, canSend } = unstable_useComposerInput();
+* <textarea
+*   value={value}
+*   disabled={isDisabled}
+*   onChange={(e) => setText(e.target.value)}
+*   onKeyDown={(e) => {
+*     if (e.key === "Enter" && !e.shiftKey && canSend) {
+*       e.preventDefault();
+*       send();
+*     }
+*   }}
+* />
+* ```
+*/
+function unstable_useComposerInput(options) {
+	const aui = useAui();
+	const value = useComposerInputValue();
+	const isDisabled = useComposerInputDisabled(options?.disabled);
+	const setText = useCallback((text) => {
+		if (!aui.composer().getState().isEditing) return;
+		flushTapSync(() => {
+			aui.composer().setText(text);
+		});
+	}, [aui]);
+	const { send: rawSend, disabled: sendDisabled } = useComposerSend();
+	const canSend = !sendDisabled && !isDisabled;
+	return {
+		value,
+		setText,
+		send: useCallback((sendOptions) => {
+			if (!canSend) return;
+			rawSend(sendOptions);
+		}, [canSend, rawSend]),
+		isDisabled,
+		canSend
+	};
+}
+/**
+* @deprecated Under active development and might change without notice.
+*
+* ARIA combobox attributes for the focused element (typically the composer
+* input) describing the open trigger popover, per the WAI-ARIA editable
+* combobox pattern. Returns an empty object outside a `TriggerPopoverRoot` or
+* when no popover is open. Spread these last so they take precedence over any
+* matching ARIA props you set yourself, mirroring `ComposerPrimitive.Input`.
+*
+* @example
+* ```tsx
+* const aria = unstable_useTriggerPopoverAriaProps();
+* <textarea {...aria} />
+* ```
+*/
+function unstable_useTriggerPopoverAriaProps() {
+	return useTriggerPopoverAriaProps();
+}
+//#endregion
+export { unstable_useComposerInput, unstable_useTriggerPopoverAriaProps };
+
+//# sourceMappingURL=useComposerInput.js.map

package/dist/unstable/useComposerInput.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useComposerInput.js","names":["useCallback","useAui","flushTapSync","useComposerSend","ComposerSendOptions","TriggerPopoverAriaProps","useComposerInputDisabled","useComposerInputValue","useTriggerPopoverAriaProps","Unstable_UseComposerInputOptions","disabled","Unstable_ComposerInput","value","setText","text","send","options","isDisabled","canSend","unstable_useComposerInput","aui","composer","getState","isEditing","rawSend","sendDisabled","sendOptions","Unstable_TriggerPopoverAriaProps","unstable_useTriggerPopoverAriaProps"],"sources":["../../src/unstable/useComposerInput.ts"],"sourcesContent":["\"use client\";\n\nimport { useCallback } from \"react\";\nimport { useAui } from \"@assistant-ui/store\";\nimport { flushTapSync } from \"@assistant-ui/tap\";\nimport { useComposerSend } from \"@assistant-ui/core/react\";\nimport type { ComposerSendOptions } from \"@assistant-ui/core/store\";\nimport {\n  type TriggerPopoverAriaProps,\n  useComposerInputDisabled,\n  useComposerInputValue,\n  useTriggerPopoverAriaProps,\n} from \"../primitives/composer/useComposerInputState\";\n\nexport type Unstable_UseComposerInputOptions = {\n  /**\n   * Disables the input in addition to the composer's own disabled sources\n   * (thread disabled, active dictation). When disabled, `isDisabled` is `true`\n   * and `canSend` is `false`.\n   */\n  disabled?: boolean | undefined;\n};\n\nexport type Unstable_ComposerInput = {\n  /** Current composer text, or `\"\"` when the composer is not editing. */\n  value: string;\n  /**\n   * Writes `text` into the composer, mirroring `ComposerPrimitive.Input`:\n   * a no-op unless the composer is editing, committed via `flushTapSync` so the\n   * controlled value stays in sync within the same tick.\n   */\n  setText(text: string): void;\n  /**\n   * Sends the current message when `canSend` is `true`; otherwise a no-op.\n   * Accepts the same options as the composer send action.\n   */\n  send(options?: ComposerSendOptions): void;\n  /**\n   * Whether the input is disabled, combining the `disabled` option with the\n   * composer's own disabled sources (thread disabled, active dictation).\n   */\n  isDisabled: boolean;\n  /**\n   * Whether a send is currently available. Matches `ComposerPrimitive.Send`\n   * gating (non-empty editing composer, not running without queue support) and\n   * is additionally `false` while `isDisabled`.\n   */\n  canSend: boolean;\n};\n\n/**\n * @deprecated Under active development and might change without notice.\n *\n * Headless bridge to the composer's text value and send action, for building a\n * custom composer input without `ComposerPrimitive.Input`. It is a thin bridge,\n * not a second input: it does not own keyboard behavior, autosize, IME or\n * contentEditable sync, paste/drop attachments, focus management, or rich-text\n * state. Spread `unstable_useTriggerPopoverAriaProps()` onto your element for\n * trigger-popover combobox semantics.\n *\n * @example\n * ```tsx\n * const { value, setText, send, isDisabled, canSend } = unstable_useComposerInput();\n * <textarea\n *   value={value}\n *   disabled={isDisabled}\n *   onChange={(e) => setText(e.target.value)}\n *   onKeyDown={(e) => {\n *     if (e.key === \"Enter\" && !e.shiftKey && canSend) {\n *       e.preventDefault();\n *       send();\n *     }\n *   }}\n * />\n * ```\n */\nexport function unstable_useComposerInput(\n  options?: Unstable_UseComposerInputOptions,\n): Unstable_ComposerInput {\n  const aui = useAui();\n  const value = useComposerInputValue();\n  const isDisabled = useComposerInputDisabled(options?.disabled);\n\n  const setText = useCallback(\n    (text: string) => {\n      if (!aui.composer().getState().isEditing) return;\n      flushTapSync(() => {\n        aui.composer().setText(text);\n      });\n    },\n    [aui],\n  );\n\n  const { send: rawSend, disabled: sendDisabled } = useComposerSend();\n  const canSend = !sendDisabled && !isDisabled;\n  const send = useCallback(\n    (sendOptions?: ComposerSendOptions) => {\n      if (!canSend) return;\n      rawSend(sendOptions);\n    },\n    [canSend, rawSend],\n  );\n\n  return { value, setText, send, isDisabled, canSend };\n}\n\nexport type Unstable_TriggerPopoverAriaProps = TriggerPopoverAriaProps;\n\n/**\n * @deprecated Under active development and might change without notice.\n *\n * ARIA combobox attributes for the focused element (typically the composer\n * input) describing the open trigger popover, per the WAI-ARIA editable\n * combobox pattern. Returns an empty object outside a `TriggerPopoverRoot` or\n * when no popover is open. Spread these last so they take precedence over any\n * matching ARIA props you set yourself, mirroring `ComposerPrimitive.Input`.\n *\n * @example\n * ```tsx\n * const aria = unstable_useTriggerPopoverAriaProps();\n * <textarea {...aria} />\n * ```\n */\nexport function unstable_useTriggerPopoverAriaProps(): Unstable_TriggerPopoverAriaProps {\n  return useTriggerPopoverAriaProps();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4EA,SAAgBmB,0BACdH,SACwB;CACxB,MAAMI,MAAMnB,OAAO;CACnB,MAAMW,QAAQL,sBAAsB;CACpC,MAAMU,aAAaX,yBAAyBU,SAASN,QAAQ;CAE7D,MAAMG,UAAUb,aACbc,SAAiB;EAChB,IAAI,CAACM,IAAIC,SAAS,CAAC,CAACC,SAAS,CAAC,CAACC,WAAW;EAC1CrB,mBAAmB;GACjBkB,IAAIC,SAAS,CAAC,CAACR,QAAQC,IAAI;EAC7B,CAAC;CACH,GACA,CAACM,GAAG,CACN;CAEA,MAAM,EAAEL,MAAMS,SAASd,UAAUe,iBAAiBtB,gBAAgB;CAClE,MAAMe,UAAU,CAACO,gBAAgB,CAACR;CASlC,OAAO;EAAEL;EAAOC;EAASE,MARZf,aACV0B,gBAAsC;GACrC,IAAI,CAACR,SAAS;GACdM,QAAQE,WAAW;EACrB,GACA,CAACR,SAASM,OAAO,CAGMT;EAAME;EAAYC;CAAQ;AACrD;;;;;;;;;;;;;;;;AAmBA,SAAgBU,sCAAwE;CACtF,OAAOpB,2BAA2B;AACpC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/react",
-  "version": "0.14.23",
+  "version": "0.14.24",
   "description": "Open-source TypeScript/React library for building production-grade AI chat experiences",
   "keywords": [
     "ai",
@@ -55,19 +55,19 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@assistant-ui/core": "^0.2.18",
-    "@assistant-ui/store": "^0.2.18",
-    "@assistant-ui/tap": "^0.9.2",
+    "@assistant-ui/core": "^0.2.19",
+    "@assistant-ui/store": "^0.2.19",
+    "@assistant-ui/tap": "^0.9.3",
     "@radix-ui/primitive": "^1.1.4",
     "@radix-ui/react-compose-refs": "^1.1.3",
     "@radix-ui/react-context": "^1.1.4",
-    "@radix-ui/react-primitive": "^2.1.5",
+    "@radix-ui/react-primitive": "^2.1.6",
     "@radix-ui/react-use-callback-ref": "^1.1.2",
     "@radix-ui/react-use-escape-keydown": "^1.1.2",
-    "assistant-cloud": "^0.1.33",
-    "assistant-stream": "^0.3.23",
-    "nanoid": "^5.1.11",
-    "radix-ui": "^1.5.0",
+    "assistant-cloud": "^0.1.34",
+    "assistant-stream": "^0.3.24",
+    "nanoid": "^5.1.15",
+    "radix-ui": "^1.6.0",
     "react-textarea-autosize": "^8.5.9",
     "safe-content-frame": "^0.0.21",
     "zod": "^4.4.3",
@@ -90,15 +90,15 @@
   "devDependencies": {
     "@testing-library/react": "^16.3.2",
     "@types/json-schema": "^7.0.15",
-    "@types/node": "^25.9.3",
+    "@types/node": "^26.0.0",
     "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
     "jsdom": "^29.1.1",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
-    "vitest": "^4.1.8",
-    "@assistant-ui/vite": "0.0.5",
-    "@assistant-ui/x-buildutils": "0.0.15"
+    "vitest": "^4.1.9",
+    "@assistant-ui/vite": "0.0.6",
+    "@assistant-ui/x-buildutils": "0.0.16"
   },
   "publishConfig": {
     "access": "public",

package/src/index.ts

@@ -136,6 +136,7 @@ export type {
   ExternalStoreSharedOptions,
   ExternalStoreThreadListAdapter,
   ExternalStoreThreadData,
+  ExternalStoreBranchChange,
 } from "@assistant-ui/core";
 export {
   createMessageQueue,
@@ -215,6 +216,26 @@ export {
   useAssistantInteractable,
   type AssistantInteractableProps,
   useInteractableState,
+  unstable_Interactables,
+  unstable_useInteractable,
+  type Unstable_InteractableConfig,
+  type Unstable_InferInteractableState,
+  type Unstable_InteractableVersionInfo,
+  unstable_useInteractableState,
+  unstable_useInteractableVersions,
+  unstable_interactableTool,
+  type Unstable_InteractableToolConfig,
+  type Unstable_InteractableToolRenderProps,
+  type Unstable_InteractableStateSchema,
+  type Unstable_InteractablesState,
+  type Unstable_InteractableDefinition,
+  type Unstable_InteractableRegistration,
+  type Unstable_InteractablesMethods,
+  type Unstable_InteractablePersistedState,
+  type Unstable_InteractablePersistenceAdapter,
+  type Unstable_InteractablePersistenceStatus,
+  type Unstable_InteractablesClientSchema,
+  type Unstable_InteractablesConfig,
   useToolArgsStatus,
   type ToolArgsStatus,
 } from "@assistant-ui/core/react";
@@ -228,6 +249,14 @@ export type {
 
 export { mergeModelContexts } from "@assistant-ui/core";
 
+export {
+  unstable_getInteractableSnapshots,
+  unstable_formatInteractableSnapshot,
+  unstable_getInteractableVersions,
+  type Unstable_InteractableSnapshotEntry,
+  type Unstable_InteractableVersion,
+} from "@assistant-ui/core";
+
 export type { Tool } from "assistant-stream";
 
 export { tool } from "@assistant-ui/core";
@@ -280,6 +309,7 @@ export * as ThreadListItemMorePrimitive from "./primitives/threadListItemMore";
 export * as SelectionToolbarPrimitive from "./primitives/selectionToolbar";
 
 export { groupPartByType, type GroupByContext } from "@assistant-ui/core/react";
+export { unstable_useThreadMessageIds } from "@assistant-ui/core/react";
 export { useMessagePartText } from "./primitives/messagePart/useMessagePartText";
 export { useMessagePartReasoning } from "./primitives/messagePart/useMessagePartReasoning";
 export { useMessagePartSource } from "./primitives/messagePart/useMessagePartSource";
@@ -447,6 +477,15 @@ export {
   type Unstable_ComposerInputHistory,
 } from "./unstable/useComposerInputHistory";
 
+// Unstable - headless composer input bridge (value/send without ComposerPrimitive.Input)
+export {
+  unstable_useComposerInput,
+  unstable_useTriggerPopoverAriaProps,
+  type Unstable_UseComposerInputOptions,
+  type Unstable_ComposerInput,
+  type Unstable_TriggerPopoverAriaProps,
+} from "./unstable/useComposerInput";
+
 export type { Assistant } from "./augmentations";
 
 // --- mcp-apps ---

package/src/legacy-runtime/runtime-cores/assistant-transport/commandQueue.ts

@@ -19,14 +19,17 @@ export const useCommandQueue = (opts: { onQueue: () => void }) => {
   const [, rerender] = useState(0);
   const queueStateRef = useRef<CommandQueueState>(createInitialQueueState());
 
-  const enqueue = (command: AssistantTransportCommand) => {
+  const enqueue = (
+    command: AssistantTransportCommand,
+    options?: { schedule?: boolean },
+  ) => {
     queueStateRef.current = {
       queued: [...queueStateRef.current.queued, command],
       inTransit: queueStateRef.current.inTransit,
     };
     rerender((prev) => prev + 1);
 
-    onQueueRef.current();
+    if (options?.schedule !== false) onQueueRef.current();
   };
 
   const flush = (): QueuedCommand[] => {

package/src/legacy-runtime/runtime-cores/assistant-transport/transport-scheduling.test.ts

@@ -99,6 +99,28 @@ describe("assistant transport scheduling contracts", () => {
     expect(result.current.runBatchesRef.current[1]).toHaveLength(1);
   });
 
+  it("can enqueue without scheduling until a run is started", async () => {
+    const { result } = renderHook(() => useTransportSchedulingHarness());
+
+    act(() => {
+      result.current.commandQueue.enqueue(createMessageCommand("staged"), {
+        schedule: false,
+      });
+    });
+
+    await Promise.resolve();
+    expect(result.current.runBatchesRef.current).toHaveLength(0);
+
+    act(() => {
+      result.current.runManager.schedule();
+    });
+
+    await waitFor(() => {
+      expect(result.current.runBatchesRef.current).toHaveLength(1);
+    });
+    expect(result.current.runBatchesRef.current[0]).toHaveLength(1);
+  });
+
   it("cancel returns combined in-flight and queued commands", async () => {
     const onCancel = vi.fn();
     const { result } = renderHook(() =>

package/src/legacy-runtime/runtime-cores/assistant-transport/useAssistantTransportRuntime.ts

@@ -316,13 +316,23 @@ const useAssistantTransportThreadRuntime = <T>(
     onNew: async (message: AppendMessage): Promise<void> => {
       parentIdRef.current = message.parentId;
       const command = convertAppendMessageToCommand(message);
-      commandQueue.enqueue(command);
+      commandQueue.enqueue(command, {
+        schedule: message.startRun ?? message.role === "user",
+      });
     },
     ...(options.capabilities?.edit && {
       onEdit: async (message: AppendMessage): Promise<void> => {
         parentIdRef.current = message.parentId;
         const command = convertAppendMessageToCommand(message);
-        commandQueue.enqueue(command);
+        commandQueue.enqueue(command, {
+          schedule: message.startRun ?? message.role === "user",
+        });
+      },
+    }),
+    ...(commandQueue.state.queued.length > 0 && {
+      onReload: async (parentId: string | null) => {
+        parentIdRef.current = parentId;
+        runManager.schedule();
       },
     }),
     onCancel: async () => {

package/src/primitives/composer/ComposerInput.tsx

@@ -21,10 +21,14 @@ import TextareaAutosize, {
 import { useEscapeKeydown } from "@radix-ui/react-use-escape-keydown";
 import { useOnScrollToBottom } from "../../utils/hooks/useOnScrollToBottom";
 import { useMediaQuery } from "../../utils/hooks/useMediaQuery";
-import { useAuiState, useAui } from "@assistant-ui/store";
+import { useAui } from "@assistant-ui/store";
 import { flushTapSync } from "@assistant-ui/tap";
 import { useComposerInputPluginRegistryOptional } from "./ComposerInputPluginContext";
-import { useTriggerPopoverActiveAriaOptional } from "./trigger/TriggerPopoverRootContext";
+import {
+  useComposerInputDisabled,
+  useComposerInputValue,
+  useTriggerPopoverAriaProps,
+} from "./useComposerInputState";
 
 const TOUCH_PRIMARY_QUERY = "(pointer: coarse) and (not (any-pointer: fine))";
 
@@ -167,7 +171,6 @@ export const ComposerPrimitiveInput = forwardRef<
   ) => {
     const aui = useAui();
     const pluginRegistry = useComposerInputPluginRegistryOptional();
-    const activeAria = useTriggerPopoverActiveAriaOptional();
 
     const declaredSubmitMode =
       submitMode ?? (submitOnEnter === false ? "none" : "enter");
@@ -181,15 +184,8 @@ export const ComposerPrimitiveInput = forwardRef<
         ? "none"
         : declaredSubmitMode;
 
-    const value = useAuiState((s) => {
-      if (!s.composer.isEditing) return "";
-      return s.composer.text;
-    });
-
-    const isDisabled =
-      useAuiState(
-        (s) => s.thread.isDisabled || s.composer.dictation?.inputDisabled,
-      ) || disabledProp;
+    const value = useComposerInputValue();
+    const isDisabled = useComposerInputDisabled(disabledProp);
     const textareaRef = useRef<HTMLTextAreaElement>(null);
     const ref = useComposedRefs(forwardedRef, textareaRef);
     // suppress text/cursor broadcasts during IME composition
@@ -322,14 +318,7 @@ export const ComposerPrimitiveInput = forwardRef<
       return aui.on("threadListItem.switchedTo", focus);
     }, [unstable_focusOnThreadSwitched, focus, aui]);
 
-    const ariaComboboxProps = activeAria
-      ? {
-          "aria-controls": activeAria.popoverId,
-          "aria-expanded": true as const,
-          "aria-haspopup": "listbox" as const,
-          "aria-activedescendant": activeAria.highlightedItemId,
-        }
-      : {};
+    const ariaComboboxProps = useTriggerPopoverAriaProps();
 
     const inputProps = {
       name: "input" as const,

package/src/primitives/composer/trigger/triggerKeyboardResource.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi } from "vitest";
-import { createTapRoot, useResource } from "@assistant-ui/tap";
+import { createTapRoot, flushTapSync, useResource } from "@assistant-ui/tap";
 import type {
   Unstable_TriggerCategory,
   Unstable_TriggerItem,
@@ -23,8 +23,6 @@ const makeKeyEvent = (key: string, shiftKey = false) => ({
   preventDefault: vi.fn(),
 });
 
-const tick = () => new Promise<void>((resolve) => setTimeout(resolve, 0));
-
 const render = (
   overrides: Partial<Parameters<typeof TriggerKeyboardResource>[0]> = {},
 ) => {
@@ -106,55 +104,53 @@ describe("TriggerKeyboardResource", () => {
     expect(props.selectItem).not.toHaveBeenCalled();
   });
 
-  it("moves the highlight forward on ArrowDown", async () => {
+  it("moves the highlight forward on ArrowDown", () => {
     const { sub } = render();
 
-    const consumed = sub.getValue().handleKeyDown(makeKeyEvent("ArrowDown"));
-    await tick();
+    const consumed = flushTapSync(() =>
+      sub.getValue().handleKeyDown(makeKeyEvent("ArrowDown")),
+    );
 
     expect(consumed).toBe(true);
     expect(sub.getValue().highlightedIndex).toBe(1);
   });
 
-  it("wraps the highlight to the top on ArrowDown past the last entry", async () => {
+  it("wraps the highlight to the top on ArrowDown past the last entry", () => {
     const { sub } = render();
     const handle = sub.getValue().handleKeyDown;
 
-    handle(makeKeyEvent("ArrowDown"));
-    handle(makeKeyEvent("ArrowDown"));
-    handle(makeKeyEvent("ArrowDown"));
-    await tick();
+    flushTapSync(() => {
+      handle(makeKeyEvent("ArrowDown"));
+      handle(makeKeyEvent("ArrowDown"));
+      handle(makeKeyEvent("ArrowDown"));
+    });
 
     expect(sub.getValue().highlightedIndex).toBe(0);
   });
 
-  it("moves the highlight backward on ArrowUp", async () => {
+  it("moves the highlight backward on ArrowUp", () => {
     const { sub } = render();
     const handle = sub.getValue().handleKeyDown;
 
-    handle(makeKeyEvent("ArrowDown"));
-    await tick();
-    handle(makeKeyEvent("ArrowUp"));
-    await tick();
+    flushTapSync(() => handle(makeKeyEvent("ArrowDown")));
+    flushTapSync(() => handle(makeKeyEvent("ArrowUp")));
 
     expect(sub.getValue().highlightedIndex).toBe(0);
   });
 
-  it("wraps the highlight to the bottom on ArrowUp from the first entry", async () => {
+  it("wraps the highlight to the bottom on ArrowUp from the first entry", () => {
     const { sub } = render();
 
-    sub.getValue().handleKeyDown(makeKeyEvent("ArrowUp"));
-    await tick();
+    flushTapSync(() => sub.getValue().handleKeyDown(makeKeyEvent("ArrowUp")));
 
     expect(sub.getValue().highlightedIndex).toBe(2);
   });
 
-  it("keeps the highlight at 0 on ArrowDown when navigableList is empty", async () => {
+  it("keeps the highlight at 0 on ArrowDown when navigableList is empty", () => {
     const { sub } = render({ navigableList: [] });
     const e = makeKeyEvent("ArrowDown");
 
-    const consumed = sub.getValue().handleKeyDown(e);
-    await tick();
+    const consumed = flushTapSync(() => sub.getValue().handleKeyDown(e));
 
     expect(consumed).toBe(true);
     expect(e.preventDefault).toHaveBeenCalled();

package/src/primitives/composer/useComposerInputState.ts

@@ -0,0 +1,34 @@
+"use client";
+
+import { useAuiState } from "@assistant-ui/store";
+import { useTriggerPopoverActiveAriaOptional } from "./trigger/TriggerPopoverRootContext";
+
+export type TriggerPopoverAriaProps = {
+  "aria-controls"?: string;
+  "aria-expanded"?: true;
+  "aria-haspopup"?: "listbox";
+  "aria-activedescendant"?: string | undefined;
+};
+
+export function useComposerInputValue() {
+  return useAuiState((s) => (s.composer.isEditing ? s.composer.text : ""));
+}
+
+export function useComposerInputDisabled(disabled?: boolean | undefined) {
+  const composerDisabled = useAuiState(
+    (s) => s.thread.isDisabled || s.composer.dictation?.inputDisabled,
+  );
+  return Boolean(composerDisabled) || Boolean(disabled);
+}
+
+export function useTriggerPopoverAriaProps(): TriggerPopoverAriaProps {
+  const activeAria = useTriggerPopoverActiveAriaOptional();
+  if (!activeAria) return {};
+
+  return {
+    "aria-controls": activeAria.popoverId,
+    "aria-expanded": true,
+    "aria-haspopup": "listbox",
+    "aria-activedescendant": activeAria.highlightedItemId,
+  };
+}

package/src/primitives/thread/ThreadMessages.tsx

@@ -4,4 +4,5 @@ export {
   ThreadPrimitiveMessages,
   ThreadPrimitiveMessagesImpl,
   ThreadPrimitiveMessageByIndex,
+  ThreadPrimitiveUnstable_MessageById,
 } from "@assistant-ui/core/react";

package/src/primitives/thread.ts

@@ -6,6 +6,7 @@ export { ThreadPrimitiveViewportProvider as ViewportProvider } from "../context/
 export { ThreadPrimitiveViewportFooter as ViewportFooter } from "./thread/ThreadViewportFooter";
 export { ThreadPrimitiveMessages as Messages } from "./thread/ThreadMessages";
 export { ThreadPrimitiveMessageByIndex as MessageByIndex } from "./thread/ThreadMessages";
+export { ThreadPrimitiveUnstable_MessageById as Unstable_MessageById } from "./thread/ThreadMessages";
 export { ThreadPrimitiveScrollToBottom as ScrollToBottom } from "./thread/ThreadScrollToBottom";
 export { ThreadPrimitiveSuggestion as Suggestion } from "./thread/ThreadSuggestion";
 export {