@assistant-ui/core 0.1.2 → 0.1.5

package/dist/utils/json/is-json.js

@@ -0,0 +1,33 @@
+export function isRecord(value) {
+    return value != null && typeof value === "object" && !Array.isArray(value);
+}
+export function isJSONValue(value, currentDepth = 0) {
+    // Protect against too deep recursion
+    if (currentDepth > 100) {
+        return false;
+    }
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean") {
+        return true;
+    }
+    // Handle special number cases
+    if (typeof value === "number") {
+        return !Number.isNaN(value) && Number.isFinite(value);
+    }
+    if (Array.isArray(value)) {
+        return value.every((item) => isJSONValue(item, currentDepth + 1));
+    }
+    if (isRecord(value)) {
+        return Object.entries(value).every(([key, val]) => typeof key === "string" && isJSONValue(val, currentDepth + 1));
+    }
+    return false;
+}
+export function isJSONArray(value) {
+    return Array.isArray(value) && value.every(isJSONValue);
+}
+export function isJSONObject(value) {
+    return (isRecord(value) &&
+        Object.entries(value).every(([key, val]) => typeof key === "string" && isJSONValue(val)));
+}
+//# sourceMappingURL=is-json.js.map

package/dist/utils/json/is-json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-json.js","sourceRoot":"","sources":["../../../src/utils/json/is-json.ts"],"names":[],"mappings":"AAMA,MAAM,UAAU,QAAQ,CAAC,KAAc;IACrC,OAAO,KAAK,IAAI,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC7E,CAAC;AAED,MAAM,UAAU,WAAW,CACzB,KAAc,EACd,eAAuB,CAAC;IAExB,qCAAqC;IACrC,IAAI,YAAY,GAAG,GAAG,EAAE,CAAC;QACvB,OAAO,KAAK,CAAC;IACf,CAAC;IAED,IACE,KAAK,KAAK,IAAI;QACd,OAAO,KAAK,KAAK,QAAQ;QACzB,OAAO,KAAK,KAAK,SAAS,EAC1B,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,8BAA8B;IAC9B,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACxD,CAAC;IAED,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,WAAW,CAAC,IAAI,EAAE,YAAY,GAAG,CAAC,CAAC,CAAC,CAAC;IACpE,CAAC;IAED,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QACpB,OAAO,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,KAAK,CAChC,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,CACb,OAAO,GAAG,KAAK,QAAQ,IAAI,WAAW,CAAC,GAAG,EAAE,YAAY,GAAG,CAAC,CAAC,CAChE,CAAC;IACJ,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,KAAc;IACxC,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;AAC1D,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,KAAc;IACzC,OAAO,CACL,QAAQ,CAAC,KAAK,CAAC;QACf,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,KAAK,CACzB,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,OAAO,GAAG,KAAK,QAAQ,IAAI,WAAW,CAAC,GAAG,CAAC,CAC5D,CACF,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/core",
-  "version": "0.1.2",
+  "version": "0.1.5",
   "description": "Framework-agnostic core runtime for assistant-ui",
   "keywords": [
     "assistant",
@@ -53,25 +53,25 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "assistant-stream": "^0.3.4",
+    "assistant-stream": "^0.3.5",
     "nanoid": "^5.1.6"
   },
   "peerDependencies": {
-    "@assistant-ui/store": "^0.2.1",
-    "@assistant-ui/tap": "^0.5.1",
+    "@assistant-ui/store": "^0.2.2",
+    "@assistant-ui/tap": "^0.5.2",
     "@types/react": "*",
     "react": "^18 || ^19",
-    "zod": "^4.0.0",
+    "assistant-cloud": "^0.1.21",
     "zustand": "^5.0.11"
   },
   "peerDependenciesMeta": {
     "@types/react": {
       "optional": true
     },
-    "react": {
+    "assistant-cloud": {
       "optional": true
     },
-    "zod": {
+    "react": {
       "optional": true
     },
     "zustand": {
@@ -83,9 +83,10 @@
     "react": "^19.2.4",
     "vitest": "^4.0.18",
     "zustand": "^5.0.11",
-    "@assistant-ui/store": "0.2.1",
-    "@assistant-ui/tap": "0.5.1",
-    "@assistant-ui/x-buildutils": "0.0.1"
+    "assistant-cloud": "0.1.21",
+    "@assistant-ui/store": "0.2.2",
+    "@assistant-ui/tap": "0.5.2",
+    "@assistant-ui/x-buildutils": "0.0.2"
   },
   "publishConfig": {
     "access": "public",

package/src/model-context/frame/provider.ts

@@ -1,7 +1,6 @@
 import { ModelContextProvider, ModelContext } from "../types";
 import type { Unsubscribe } from "../../types";
-import { Tool } from "assistant-stream";
-import { z } from "zod";
+import { Tool, toJSONSchema } from "assistant-stream";
 import {
   FrameMessage,
   FRAME_MESSAGE_CHANNEL,
@@ -11,10 +10,7 @@ import {
 
 const serializeTool = (tool: Tool<any, any>): SerializedTool => ({
   ...(tool.description && { description: tool.description }),
-  parameters:
-    tool.parameters instanceof z.ZodType
-      ? ((z as any).toJSONSchema?.(tool.parameters) ?? tool.parameters)
-      : tool.parameters,
+  parameters: tool.parameters ? toJSONSchema(tool.parameters) : undefined,
   ...(tool.disabled !== undefined && { disabled: tool.disabled }),
   ...(tool.type && { type: tool.type }),
 });

package/src/react/AssistantRuntimeProvider.tsx

@@ -0,0 +1,33 @@
+import { type ReactNode, memo } from "react";
+import { useAui, type AssistantClient } from "@assistant-ui/store";
+import type { AssistantRuntime } from "../runtime/api/assistant-runtime";
+import { AssistantProviderBase } from "./AssistantProvider";
+
+export const useAssistantRuntime = (): AssistantRuntime => {
+  const aui = useAui();
+  const runtime = aui.threads().__internal_getAssistantRuntime?.();
+  if (!runtime) {
+    throw new Error(
+      "useAssistantRuntime must be used within an AssistantRuntimeProvider",
+    );
+  }
+  return runtime;
+};
+
+export const AssistantRuntimeProvider = memo(
+  ({
+    runtime,
+    aui,
+    children,
+  }: {
+    runtime: AssistantRuntime;
+    aui?: AssistantClient | null;
+    children: ReactNode;
+  }) => {
+    return (
+      <AssistantProviderBase runtime={runtime} aui={aui ?? null}>
+        {children}
+      </AssistantProviderBase>
+    );
+  },
+);

package/src/react/adapters/LocalStorageThreadListAdapter.tsx

@@ -0,0 +1,227 @@
+import { type AssistantStream, createAssistantStream } from "assistant-stream";
+import { FC, PropsWithChildren, useMemo } from "react";
+import { useAui } from "@assistant-ui/store";
+import type {
+  RemoteThreadInitializeResponse,
+  RemoteThreadListAdapter,
+  RemoteThreadListResponse,
+  RemoteThreadMetadata,
+  ThreadHistoryAdapter,
+  ThreadMessage,
+} from "../../index";
+import type {
+  ExportedMessageRepository,
+  ExportedMessageRepositoryItem,
+} from "../../internal";
+import { RuntimeAdapterProvider } from "../runtimes/RuntimeAdapterProvider";
+import type { TitleGenerationAdapter } from "./TitleGenerationAdapter";
+
+export type AsyncStorageLike = {
+  getItem(key: string): Promise<string | null>;
+  setItem(key: string, value: string): Promise<void>;
+  removeItem(key: string): Promise<void>;
+};
+
+type LocalStorageAdapterOptions = {
+  storage: AsyncStorageLike;
+  prefix?: string | undefined;
+  titleGenerator?: TitleGenerationAdapter | undefined;
+};
+
+type StoredThreadMetadata = {
+  remoteId: string;
+  externalId?: string;
+  status: "regular" | "archived";
+  title?: string;
+};
+
+class AsyncStorageHistoryAdapter implements ThreadHistoryAdapter {
+  constructor(
+    private storage: AsyncStorageLike,
+    private aui: ReturnType<typeof useAui>,
+    private prefix: string,
+  ) {}
+
+  private _messagesKey(remoteId: string) {
+    return `${this.prefix}messages:${remoteId}`;
+  }
+
+  async load(): Promise<ExportedMessageRepository> {
+    const remoteId = this.aui.threadListItem().getState().remoteId;
+    if (!remoteId) return { messages: [] };
+
+    const raw = await this.storage.getItem(this._messagesKey(remoteId));
+    if (!raw) return { messages: [] };
+    return JSON.parse(raw) as ExportedMessageRepository;
+  }
+
+  async append(item: ExportedMessageRepositoryItem): Promise<void> {
+    const { remoteId } = await this.aui.threadListItem().initialize();
+
+    const key = this._messagesKey(remoteId);
+    const raw = await this.storage.getItem(key);
+    const repo: ExportedMessageRepository = raw
+      ? (JSON.parse(raw) as ExportedMessageRepository)
+      : { messages: [] };
+
+    const idx = repo.messages.findIndex(
+      (m) => m.message.id === item.message.id,
+    );
+    if (idx >= 0) {
+      repo.messages[idx] = item;
+    } else {
+      repo.messages.push(item);
+    }
+    repo.headId = item.message.id;
+
+    await this.storage.setItem(key, JSON.stringify(repo));
+  }
+}
+
+const createHistoryProvider = (
+  storage: AsyncStorageLike,
+  prefix: string,
+): FC<PropsWithChildren> => {
+  const Provider: FC<PropsWithChildren> = ({ children }) => {
+    const aui = useAui();
+    const history = useMemo(
+      () => new AsyncStorageHistoryAdapter(storage, aui, prefix),
+      [aui],
+    );
+    const adapters = useMemo(() => ({ history }), [history]);
+
+    return (
+      <RuntimeAdapterProvider adapters={adapters}>
+        {children}
+      </RuntimeAdapterProvider>
+    );
+  };
+  return Provider;
+};
+
+export const createLocalStorageAdapter = (
+  options: LocalStorageAdapterOptions,
+): RemoteThreadListAdapter => {
+  const { storage, prefix = "@assistant-ui:", titleGenerator } = options;
+
+  const threadsKey = `${prefix}threads`;
+  const messagesKey = (threadId: string) => `${prefix}messages:${threadId}`;
+
+  const loadThreadMetadata = async (): Promise<StoredThreadMetadata[]> => {
+    const raw = await storage.getItem(threadsKey);
+    return raw ? (JSON.parse(raw) as StoredThreadMetadata[]) : [];
+  };
+
+  const saveThreadMetadata = async (
+    threads: StoredThreadMetadata[],
+  ): Promise<void> => {
+    await storage.setItem(threadsKey, JSON.stringify(threads));
+  };
+
+  const adapter: RemoteThreadListAdapter = {
+    unstable_Provider: createHistoryProvider(storage, prefix),
+
+    async list(): Promise<RemoteThreadListResponse> {
+      const threads = await loadThreadMetadata();
+      return {
+        threads: threads.map((t) => ({
+          remoteId: t.remoteId,
+          externalId: t.externalId,
+          status: t.status,
+          title: t.title,
+        })),
+      };
+    },
+
+    async initialize(
+      threadId: string,
+    ): Promise<RemoteThreadInitializeResponse> {
+      const remoteId = threadId;
+      const threads = await loadThreadMetadata();
+
+      // Only add if not already present
+      if (!threads.some((t) => t.remoteId === remoteId)) {
+        threads.unshift({
+          remoteId,
+          status: "regular",
+        });
+        await saveThreadMetadata(threads);
+      }
+
+      return { remoteId, externalId: undefined };
+    },
+
+    async rename(remoteId: string, newTitle: string): Promise<void> {
+      const threads = await loadThreadMetadata();
+      const thread = threads.find((t) => t.remoteId === remoteId);
+      if (thread) {
+        thread.title = newTitle;
+        await saveThreadMetadata(threads);
+      }
+    },
+
+    async archive(remoteId: string): Promise<void> {
+      const threads = await loadThreadMetadata();
+      const thread = threads.find((t) => t.remoteId === remoteId);
+      if (thread) {
+        thread.status = "archived";
+        await saveThreadMetadata(threads);
+      }
+    },
+
+    async unarchive(remoteId: string): Promise<void> {
+      const threads = await loadThreadMetadata();
+      const thread = threads.find((t) => t.remoteId === remoteId);
+      if (thread) {
+        thread.status = "regular";
+        await saveThreadMetadata(threads);
+      }
+    },
+
+    async delete(remoteId: string): Promise<void> {
+      const threads = await loadThreadMetadata();
+      const filtered = threads.filter((t) => t.remoteId !== remoteId);
+      await saveThreadMetadata(filtered);
+      await storage.removeItem(messagesKey(remoteId));
+    },
+
+    async fetch(threadId: string): Promise<RemoteThreadMetadata> {
+      const threads = await loadThreadMetadata();
+      const thread = threads.find((t) => t.remoteId === threadId);
+      if (!thread) throw new Error("Thread not found");
+      return {
+        remoteId: thread.remoteId,
+        externalId: thread.externalId,
+        status: thread.status,
+        title: thread.title,
+      };
+    },
+
+    async generateTitle(
+      remoteId: string,
+      messages: readonly ThreadMessage[],
+    ): Promise<AssistantStream> {
+      if (titleGenerator) {
+        const title = await titleGenerator.generateTitle(messages);
+
+        // Update the stored title
+        const threads = await loadThreadMetadata();
+        const thread = threads.find((t) => t.remoteId === remoteId);
+        if (thread) {
+          thread.title = title;
+          await saveThreadMetadata(threads);
+        }
+
+        // Return a stream with a single text part
+        return createAssistantStream((controller) => {
+          controller.appendText(title);
+        });
+      }
+
+      // No title generator — return empty stream
+      return createAssistantStream(() => {});
+    },
+  };
+
+  return adapter;
+};

package/src/react/adapters/TitleGenerationAdapter.ts

@@ -0,0 +1,20 @@
+import type { ThreadMessage } from "../../types/message";
+
+export type TitleGenerationAdapter = {
+  generateTitle(messages: readonly ThreadMessage[]): Promise<string>;
+};
+
+export const createSimpleTitleAdapter = (): TitleGenerationAdapter => {
+  return {
+    async generateTitle(messages) {
+      const firstUserMessage = messages.find((m) => m.role === "user");
+      if (!firstUserMessage) return "New Thread";
+
+      const textPart = firstUserMessage.content.find((p) => p.type === "text");
+      if (!textPart || textPart.type !== "text") return "New Thread";
+
+      const text = textPart.text.trim();
+      return text.length > 50 ? `${text.slice(0, 47)}...` : text;
+    },
+  };
+};

package/src/react/index.ts

@@ -1,10 +1,11 @@
-import "./types/store-augmentation";
+/// <reference path="./types/store-augmentation.ts" />
 
 export * from "./model-context";
 export * from "./client";
 export * from "./types";
 export * from "./providers";
 export { RuntimeAdapter } from "./RuntimeAdapter";
+export * from "./runtimes";
 
 // AssistantProvider base
 export {
@@ -48,3 +49,18 @@ export {
   ComposerPrimitiveIf,
   type UseComposerIfProps,
 } from "./primitives/composer/ComposerIf";
+
+// Primitive hooks (shared behavior logic)
+export * from "./primitive-hooks";
+
+// Shared AssistantRuntimeProvider
+export {
+  AssistantRuntimeProvider,
+  useAssistantRuntime,
+} from "./AssistantRuntimeProvider";
+
+// Shared runtimes
+export {
+  useLocalRuntime,
+  type LocalRuntimeOptions,
+} from "./runtimes/useLocalRuntime";

package/src/react/primitive-hooks/index.ts

@@ -0,0 +1,20 @@
+export { useThreadMessages } from "./useThreadMessages";
+export { useThreadIsRunning } from "./useThreadIsRunning";
+export { useThreadIsEmpty } from "./useThreadIsEmpty";
+export { useComposerSend } from "./useComposerSend";
+export { useComposerCancel } from "./useComposerCancel";
+export { useMessageReload } from "./useMessageReload";
+export { useMessageBranching } from "./useMessageBranching";
+export {
+  useActionBarCopy,
+  type UseActionBarCopyOptions,
+} from "./useActionBarCopy";
+export { useActionBarEdit } from "./useActionBarEdit";
+export { useActionBarReload } from "./useActionBarReload";
+export {
+  useActionBarFeedbackPositive,
+  useActionBarFeedbackNegative,
+} from "./useActionBarFeedback";
+export { useComposerAddAttachment } from "./useComposerAddAttachment";
+export { useEditComposerCancel } from "./useEditComposerCancel";
+export { useEditComposerSend } from "./useEditComposerSend";

package/src/react/primitive-hooks/useActionBarCopy.ts

@@ -0,0 +1,38 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export type UseActionBarCopyOptions = {
+  copiedDuration?: number | undefined;
+  copyToClipboard?: ((text: string) => void | Promise<void>) | undefined;
+};
+
+export const useActionBarCopy = ({
+  copiedDuration = 3000,
+  copyToClipboard,
+}: UseActionBarCopyOptions = {}) => {
+  const aui = useAui();
+  const disabled = useAuiState((s) => {
+    return !(
+      (s.message.role !== "assistant" ||
+        s.message.status?.type !== "running") &&
+      s.message.parts.some((c) => c.type === "text" && c.text.length > 0)
+    );
+  });
+  const isCopied = useAuiState((s) => s.message.isCopied);
+  const isEditing = useAuiState((s) => s.composer.isEditing);
+  const composerValue = useAuiState((s) => s.composer.text);
+
+  const copy = useCallback(() => {
+    const valueToCopy = isEditing ? composerValue : aui.message().getCopyText();
+    if (!valueToCopy) return;
+
+    const write = copyToClipboard ?? (() => {});
+    const result = write(valueToCopy);
+    Promise.resolve(result).then(() => {
+      aui.message().setIsCopied(true);
+      setTimeout(() => aui.message().setIsCopied(false), copiedDuration);
+    });
+  }, [aui, isEditing, composerValue, copiedDuration, copyToClipboard]);
+
+  return { copy, disabled, isCopied };
+};

package/src/react/primitive-hooks/useActionBarEdit.ts

@@ -0,0 +1,13 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useActionBarEdit = () => {
+  const aui = useAui();
+  const disabled = useAuiState((s) => s.composer.isEditing);
+
+  const edit = useCallback(() => {
+    aui.composer().beginEdit();
+  }, [aui]);
+
+  return { edit, disabled };
+};

package/src/react/primitive-hooks/useActionBarFeedback.ts

@@ -0,0 +1,28 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useActionBarFeedbackPositive = () => {
+  const aui = useAui();
+  const isSubmitted = useAuiState(
+    (s) => s.message.metadata.submittedFeedback?.type === "positive",
+  );
+
+  const submit = useCallback(() => {
+    aui.message().submitFeedback({ type: "positive" });
+  }, [aui]);
+
+  return { submit, isSubmitted };
+};
+
+export const useActionBarFeedbackNegative = () => {
+  const aui = useAui();
+  const isSubmitted = useAuiState(
+    (s) => s.message.metadata.submittedFeedback?.type === "negative",
+  );
+
+  const submit = useCallback(() => {
+    aui.message().submitFeedback({ type: "negative" });
+  }, [aui]);
+
+  return { submit, isSubmitted };
+};

package/src/react/primitive-hooks/useActionBarReload.ts

@@ -0,0 +1,18 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useActionBarReload = () => {
+  const aui = useAui();
+  const disabled = useAuiState(
+    (s) =>
+      s.thread.isRunning ||
+      s.thread.isDisabled ||
+      s.message.role !== "assistant",
+  );
+
+  const reload = useCallback(() => {
+    aui.message().reload();
+  }, [aui]);
+
+  return { reload, disabled };
+};

package/src/react/primitive-hooks/useComposerAddAttachment.ts

@@ -0,0 +1,17 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+import type { CreateAttachment } from "../../types/attachment";
+
+export const useComposerAddAttachment = () => {
+  const aui = useAui();
+  const disabled = useAuiState((s) => !s.composer.isEditing);
+
+  const addAttachment = useCallback(
+    (file: File | CreateAttachment) => {
+      return aui.composer().addAttachment(file);
+    },
+    [aui],
+  );
+
+  return { addAttachment, disabled };
+};

package/src/react/primitive-hooks/useComposerCancel.ts

@@ -0,0 +1,13 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useComposerCancel = () => {
+  const aui = useAui();
+  const disabled = useAuiState((s) => !s.composer.canCancel);
+
+  const cancel = useCallback(() => {
+    aui.composer().cancel();
+  }, [aui]);
+
+  return { cancel, disabled };
+};

package/src/react/primitive-hooks/useComposerSend.ts

@@ -0,0 +1,15 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useComposerSend = () => {
+  const aui = useAui();
+  const disabled = useAuiState(
+    (s) => s.thread.isRunning || !s.composer.isEditing || s.composer.isEmpty,
+  );
+
+  const send = useCallback(() => {
+    aui.composer().send();
+  }, [aui]);
+
+  return { send, disabled };
+};

package/src/react/primitive-hooks/useEditComposerCancel.ts

@@ -0,0 +1,12 @@
+import { useCallback } from "react";
+import { useAui } from "@assistant-ui/store";
+
+export const useEditComposerCancel = () => {
+  const aui = useAui();
+
+  const cancel = useCallback(() => {
+    aui.composer().cancel();
+  }, [aui]);
+
+  return { cancel };
+};

package/src/react/primitive-hooks/useEditComposerSend.ts

@@ -0,0 +1,13 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useEditComposerSend = () => {
+  const aui = useAui();
+  const disabled = useAuiState((s) => s.composer.isEmpty);
+
+  const send = useCallback(() => {
+    aui.composer().send();
+  }, [aui]);
+
+  return { send, disabled };
+};

package/src/react/primitive-hooks/useMessageBranching.ts

@@ -0,0 +1,18 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useMessageBranching = () => {
+  const aui = useAui();
+  const branchNumber = useAuiState((s) => s.message.branchNumber);
+  const branchCount = useAuiState((s) => s.message.branchCount);
+
+  const goToPrev = useCallback(() => {
+    aui.message().switchToBranch({ position: "previous" });
+  }, [aui]);
+
+  const goToNext = useCallback(() => {
+    aui.message().switchToBranch({ position: "next" });
+  }, [aui]);
+
+  return { branchNumber, branchCount, goToPrev, goToNext };
+};

package/src/react/primitive-hooks/useMessageReload.ts

@@ -0,0 +1,13 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useMessageReload = () => {
+  const aui = useAui();
+  const canReload = useAuiState((s) => s.message.role === "assistant");
+
+  const reload = useCallback(() => {
+    aui.message().reload();
+  }, [aui]);
+
+  return { reload, canReload };
+};

package/src/react/primitive-hooks/useThreadIsEmpty.ts

@@ -0,0 +1,5 @@
+import { useAuiState } from "@assistant-ui/store";
+
+export const useThreadIsEmpty = (): boolean => {
+  return useAuiState((s) => s.thread.isEmpty);
+};

package/src/react/primitive-hooks/useThreadIsRunning.ts

@@ -0,0 +1,5 @@
+import { useAuiState } from "@assistant-ui/store";
+
+export const useThreadIsRunning = (): boolean => {
+  return useAuiState((s) => s.thread.isRunning);
+};