@assistant-ui/react 0.14.23 → 0.14.26

package/dist/utils/useToolArgsFieldStatus.d.ts

@@ -1,5 +1,7 @@
 //#region src/utils/useToolArgsFieldStatus.d.ts
 declare const useToolArgsFieldStatus: (fieldPath: (string | number)[]) => {
+  type: string;
+} | {
   readonly type: "running";
 } | {
   readonly type: "complete";
@@ -7,8 +9,6 @@ declare const useToolArgsFieldStatus: (fieldPath: (string | number)[]) => {
   readonly type: "incomplete";
   readonly reason: "cancelled" | "length" | "content-filter" | "other" | "error";
   readonly error?: unknown;
-} | {
-  type: string;
 };
 //#endregion
 export { useToolArgsFieldStatus };

package/dist/utils/useToolArgsFieldStatus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useToolArgsFieldStatus.d.ts","names":[],"sources":["../../src/utils/useToolArgsFieldStatus.ts"],"mappings":";cAKa,sBAAA,GAA0B,SAAA;EAAA"}
+{"version":3,"file":"useToolArgsFieldStatus.d.ts","names":[],"sources":["../../src/utils/useToolArgsFieldStatus.ts"],"mappings":";cAKa,sBAAA,GAA0B,SAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/react",
-  "version": "0.14.23",
+  "version": "0.14.26",
   "description": "Open-source TypeScript/React library for building production-grade AI chat experiences",
   "keywords": [
     "ai",
@@ -55,21 +55,23 @@
   ],
   "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.20",
+    "@assistant-ui/store": "^0.2.19",
+    "@assistant-ui/tap": "^0.9.3",
     "@radix-ui/primitive": "^1.1.4",
+    "@radix-ui/react-collection": "^1.1.10",
     "@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-controllable-state": "^1.2.3",
     "@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.25",
+    "nanoid": "^5.1.15",
+    "radix-ui": "^1.6.0",
     "react-textarea-autosize": "^8.5.9",
-    "safe-content-frame": "^0.0.21",
+    "safe-content-frame": "^0.0.22",
     "zod": "^4.4.3",
     "zustand": "^5.0.14"
   },
@@ -90,15 +92,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.8",
+    "@assistant-ui/x-buildutils": "0.0.17"
   },
   "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/messagePart/MessagePartText.tsx

@@ -20,6 +20,7 @@ export namespace MessagePartPrimitiveText {
      * Whether to enable smooth text streaming animation.
      * When enabled, text appears with a typing effect as it streams in.
      * Pass a `SmoothOptions` object to tune the reveal rate.
+     * Auto-disables under `prefers-reduced-motion: reduce`.
      * @default true
      */
     smooth?: boolean | SmoothOptions;

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 {

package/src/primitives/threadList/ThreadListRoot.tsx

@@ -6,6 +6,7 @@ import {
   type ComponentRef,
   forwardRef,
 } from "react";
+import { ThreadListCollection } from "../threadListFocusGroup";
 
 type PrimitiveDivProps = ComponentPropsWithoutRef<typeof Primitive.div>;
 
@@ -18,7 +19,13 @@ export const ThreadListPrimitiveRoot = forwardRef<
   ThreadListPrimitiveRoot.Element,
   ThreadListPrimitiveRoot.Props
 >((props, ref) => {
-  return <Primitive.div {...props} ref={ref} />;
+  return (
+    <ThreadListCollection.Provider scope={undefined}>
+      <ThreadListCollection.Slot scope={undefined}>
+        <Primitive.div {...props} ref={ref} />
+      </ThreadListCollection.Slot>
+    </ThreadListCollection.Provider>
+  );
 });
 
 ThreadListPrimitiveRoot.displayName = "ThreadListPrimitive.Root";

package/src/primitives/threadListFocusGroup.ts

@@ -0,0 +1,24 @@
+"use client";
+
+import { createCollection } from "@radix-ui/react-collection";
+import { createContext, useContext, type RefObject } from "react";
+
+const [collection, useThreadListCollection] =
+  createCollection<HTMLButtonElement>("ThreadList");
+
+export const ThreadListCollection = collection;
+export { useThreadListCollection };
+
+type ThreadListItemFocus = {
+  triggerRef: RefObject<HTMLButtonElement | null>;
+  moreRef: RefObject<HTMLButtonElement | null>;
+};
+
+const ThreadListItemFocusContext = createContext<ThreadListItemFocus | null>(
+  null,
+);
+
+export const ThreadListItemFocusProvider = ThreadListItemFocusContext.Provider;
+
+export const useThreadListItemFocus = (): ThreadListItemFocus | null =>
+  useContext(ThreadListItemFocusContext);

package/src/primitives/threadListItem/ThreadListItemRoot.tsx

@@ -5,8 +5,17 @@ import {
   type ComponentRef,
   forwardRef,
   type ComponentPropsWithoutRef,
+  type KeyboardEvent,
+  useMemo,
+  useRef,
 } from "react";
 import { useAuiState } from "@assistant-ui/store";
+import { composeEventHandlers } from "@radix-ui/primitive";
+import { Direction } from "radix-ui";
+import {
+  ThreadListItemFocusProvider,
+  useThreadListCollection,
+} from "../threadListFocusGroup";
 
 type PrimitiveDivProps = ComponentPropsWithoutRef<typeof Primitive.div>;
 
@@ -23,12 +32,51 @@ export const ThreadListItemPrimitiveRoot = forwardRef<
     (s) => s.threads.mainThreadId === s.threadListItem.id,
   );
 
+  const triggerRef = useRef<HTMLButtonElement | null>(null);
+  const moreRef = useRef<HTMLButtonElement | null>(null);
+  const focus = useMemo(() => ({ triggerRef, moreRef }), []);
+
+  const getItems = useThreadListCollection(undefined);
+  const direction = Direction.useDirection();
+
+  const onKeyDown = (event: KeyboardEvent<HTMLDivElement>) => {
+    const forwardKey = direction === "rtl" ? "ArrowLeft" : "ArrowRight";
+    const backKey = direction === "rtl" ? "ArrowRight" : "ArrowLeft";
+    const trigger = triggerRef.current;
+    const more = moreRef.current;
+
+    if (trigger && event.target === trigger) {
+      if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+        const triggers = getItems()
+          .map((item) => item.ref.current)
+          .filter((node): node is HTMLButtonElement => node !== null);
+        const next =
+          triggers[
+            triggers.indexOf(trigger) + (event.key === "ArrowDown" ? 1 : -1)
+          ];
+        if (next) {
+          next.focus();
+          event.preventDefault();
+        }
+      } else if (event.key === forwardKey && more) {
+        more.focus();
+        event.preventDefault();
+      }
+    } else if (more && event.target === more && event.key === backKey) {
+      trigger?.focus();
+      event.preventDefault();
+    }
+  };
+
   return (
-    <Primitive.div
-      {...(isMain ? { "data-active": "true", "aria-current": "true" } : null)}
-      {...props}
-      ref={ref}
-    />
+    <ThreadListItemFocusProvider value={focus}>
+      <Primitive.div
+        {...(isMain ? { "data-active": "true", "aria-current": "true" } : null)}
+        {...props}
+        onKeyDown={composeEventHandlers(props.onKeyDown, onKeyDown)}
+        ref={ref}
+      />
+    </ThreadListItemFocusProvider>
   );
 });
 

package/src/primitives/threadListItem/ThreadListItemTrigger.tsx

@@ -0,0 +1,45 @@
+"use client";
+
+import { forwardRef } from "react";
+import { useComposedRefs } from "@radix-ui/react-compose-refs";
+import {
+  type ActionButtonElement,
+  type ActionButtonProps,
+  createActionButton,
+} from "../../utils/createActionButton";
+import { useThreadListItemTrigger as useThreadListItemTriggerBehavior } from "@assistant-ui/core/react";
+import {
+  ThreadListCollection,
+  useThreadListItemFocus,
+} from "../threadListFocusGroup";
+
+const useThreadListItemTrigger = () => {
+  const { switchTo } = useThreadListItemTriggerBehavior();
+  return switchTo;
+};
+
+export namespace ThreadListItemPrimitiveTrigger {
+  export type Element = ActionButtonElement;
+  export type Props = ActionButtonProps<typeof useThreadListItemTrigger>;
+}
+
+const ThreadListItemTriggerButton = createActionButton(
+  "ThreadListItemPrimitive.Trigger",
+  useThreadListItemTrigger,
+);
+
+export const ThreadListItemPrimitiveTrigger = forwardRef<
+  ThreadListItemPrimitiveTrigger.Element,
+  ThreadListItemPrimitiveTrigger.Props
+>((props, forwardedRef) => {
+  const focus = useThreadListItemFocus();
+  const ref = useComposedRefs(forwardedRef, focus?.triggerRef);
+
+  return (
+    <ThreadListCollection.ItemSlot scope={undefined}>
+      <ThreadListItemTriggerButton {...props} ref={ref} />
+    </ThreadListCollection.ItemSlot>
+  );
+});
+
+ThreadListItemPrimitiveTrigger.displayName = "ThreadListItemPrimitive.Trigger";