@assistant-ui/core 0.1.3 → 0.1.7

package/src/react/RuntimeAdapter.ts

@@ -5,7 +5,8 @@ import {
   baseRuntimeAdapterTransformScopes,
 } from "../store/internal";
 import { attachTransformScopes } from "@assistant-ui/store";
-import { DataRenderers, Tools } from "./model-context";
+import { DataRenderers } from "./client/DataRenderers";
+import { Tools } from "./client/Tools";
 
 export const RuntimeAdapter = resource((runtime: AssistantRuntime) =>
   tapResource(RuntimeAdapterResource(runtime)),

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/client/DataRenderers.ts

@@ -1,7 +1,7 @@
 import { resource, tapState, tapCallback } from "@assistant-ui/tap";
 import { type ClientOutput } from "@assistant-ui/store";
-import { DataRenderersState } from "../types/scopes";
-import { DataMessagePartComponent } from "../types";
+import { DataRenderersState } from "../types/scopes/dataRenderers";
+import { DataMessagePartComponent } from "../types/MessagePartComponentTypes";
 
 export const DataRenderers = resource((): ClientOutput<"dataRenderers"> => {
   const [state, setState] = tapState<DataRenderersState>(() => ({

package/src/react/client/Tools.ts

@@ -4,10 +4,10 @@ import {
   type ClientOutput,
   attachTransformScopes,
 } from "@assistant-ui/store";
-import { ToolsState } from "../types/scopes";
+import { ToolsState } from "../types/scopes/tools";
 import type { Tool } from "assistant-stream";
 import { type Toolkit } from "../model-context/toolbox";
-import { ToolCallMessagePartComponent } from "../types";
+import { ToolCallMessagePartComponent } from "../types/MessagePartComponentTypes";
 import { ModelContext } from "../../store";
 
 export const Tools = resource(

package/src/react/index.ts

@@ -1,11 +1,119 @@
 /// <reference path="./types/store-augmentation.ts" />
 
-export * from "./model-context";
-export * from "./client";
-export * from "./types";
-export * from "./providers";
+// model-context
+export {
+  makeAssistantTool,
+  type AssistantTool,
+} from "./model-context/makeAssistantTool";
+export {
+  type AssistantToolUI,
+  makeAssistantToolUI,
+} from "./model-context/makeAssistantToolUI";
+export {
+  type AssistantDataUI,
+  makeAssistantDataUI,
+} from "./model-context/makeAssistantDataUI";
+export { useAssistantInstructions } from "./model-context/useAssistantInstructions";
+export {
+  useAssistantTool,
+  type AssistantToolProps,
+} from "./model-context/useAssistantTool";
+export {
+  useAssistantToolUI,
+  type AssistantToolUIProps,
+} from "./model-context/useAssistantToolUI";
+export {
+  useAssistantDataUI,
+  type AssistantDataUIProps,
+} from "./model-context/useAssistantDataUI";
+export { useInlineRender } from "./model-context/useInlineRender";
+export type { Toolkit, ToolDefinition } from "./model-context/toolbox";
+
+// client
+export { Tools } from "./client/Tools";
+export { DataRenderers } from "./client/DataRenderers";
+
+// types
+export type {
+  EmptyMessagePartComponent,
+  EmptyMessagePartProps,
+  TextMessagePartComponent,
+  TextMessagePartProps,
+  ReasoningMessagePartComponent,
+  ReasoningMessagePartProps,
+  SourceMessagePartComponent,
+  SourceMessagePartProps,
+  ImageMessagePartComponent,
+  ImageMessagePartProps,
+  FileMessagePartComponent,
+  FileMessagePartProps,
+  Unstable_AudioMessagePartComponent,
+  Unstable_AudioMessagePartProps,
+  DataMessagePartComponent,
+  DataMessagePartProps,
+  ToolCallMessagePartComponent,
+  ToolCallMessagePartProps,
+  ReasoningGroupProps,
+  ReasoningGroupComponent,
+  QuoteMessagePartComponent,
+  QuoteMessagePartProps,
+} from "./types/MessagePartComponentTypes";
+export type {
+  ToolsState,
+  ToolsMethods,
+  ToolsClientSchema,
+} from "./types/scopes/tools";
+export type {
+  DataRenderersState,
+  DataRenderersMethods,
+  DataRenderersClientSchema,
+} from "./types/scopes/dataRenderers";
+
+// providers
+export {
+  MessageAttachmentByIndexProvider,
+  ComposerAttachmentByIndexProvider,
+} from "./providers/AttachmentByIndexProvider";
+export { ThreadListItemRuntimeProvider } from "./providers/ThreadListItemRuntimeProvider";
+export { MessageByIndexProvider } from "./providers/MessageByIndexProvider";
+export { PartByIndexProvider } from "./providers/PartByIndexProvider";
+export { TextMessagePartProvider } from "./providers/TextMessagePartProvider";
+export { ChainOfThoughtByIndicesProvider } from "./providers/ChainOfThoughtByIndicesProvider";
+export { ThreadListItemByIndexProvider } from "./providers/ThreadListItemByIndexProvider";
+export { ChainOfThoughtPartByIndexProvider } from "./providers/ChainOfThoughtPartByIndexProvider";
+export {
+  SuggestionByIndexProvider,
+  type SuggestionByIndexProviderProps,
+} from "./providers/SuggestionByIndexProvider";
+export { ReadonlyThreadProvider } from "./providers/ReadonlyThreadProvider";
+
+// RuntimeAdapter
 export { RuntimeAdapter } from "./RuntimeAdapter";
-export * from "./runtimes";
+
+// runtimes
+export {
+  RuntimeAdapterProvider,
+  useRuntimeAdapters,
+  type RuntimeAdapters,
+} from "./runtimes/RuntimeAdapterProvider";
+export {
+  useToolInvocations,
+  type ToolExecutionStatus,
+  type AssistantTransportState,
+  type AddToolResultCommand,
+} from "./runtimes/useToolInvocations";
+export { useExternalStoreRuntime } from "./runtimes/useExternalStoreRuntime";
+export {
+  useExternalMessageConverter,
+  convertExternalMessages,
+} from "./runtimes/external-message-converter";
+export { createMessageConverter } from "./runtimes/createMessageConverter";
+export { RemoteThreadListHookInstanceManager } from "./runtimes/RemoteThreadListHookInstanceManager";
+export { RemoteThreadListThreadListRuntimeCore } from "./runtimes/RemoteThreadListThreadListRuntimeCore";
+export { useRemoteThreadListRuntime } from "./runtimes/useRemoteThreadListRuntime";
+export { useCloudThreadListAdapter } from "./runtimes/cloud/useCloudThreadListAdapter";
+export { useAssistantCloudThreadHistoryAdapter } from "./runtimes/cloud/AssistantCloudThreadHistoryAdapter";
+export { CloudFileAttachmentAdapter } from "./runtimes/cloud/CloudFileAttachmentAdapter";
 
 // AssistantProvider base
 export {
@@ -25,7 +133,9 @@ export {
   MessagePartComponent,
   MessagePrimitivePartByIndex,
   defaultComponents as messagePartsDefaultComponents,
+  type EnrichedPartState,
 } from "./primitives/message/MessageParts";
+export { MessagePrimitiveQuote } from "./primitives/message/MessageQuote";
 export {
   MessagePrimitiveAttachments,
   MessagePrimitiveAttachmentByIndex,
@@ -39,6 +149,10 @@ export {
   ThreadListPrimitiveItemByIndex,
 } from "./primitives/threadList/ThreadListItems";
 export { ChainOfThoughtPrimitiveParts } from "./primitives/chainOfThought/ChainOfThoughtParts";
+export {
+  PartPrimitiveMessages,
+  PartPrimitiveMessagesImpl,
+} from "./primitives/part/PartMessages";
 export { ThreadListItemPrimitiveTitle } from "./primitives/threadListItem/ThreadListItemTitle";
 export {
   ThreadPrimitiveSuggestions,
@@ -49,3 +163,51 @@ export {
   ComposerPrimitiveIf,
   type UseComposerIfProps,
 } from "./primitives/composer/ComposerIf";
+export { getMessageQuote } from "./utils/getMessageQuote";
+
+// Primitive hooks (shared behavior logic)
+export { useThreadMessages } from "./primitive-hooks/useThreadMessages";
+export { useThreadIsRunning } from "./primitive-hooks/useThreadIsRunning";
+export { useThreadIsEmpty } from "./primitive-hooks/useThreadIsEmpty";
+export { useComposerSend } from "./primitive-hooks/useComposerSend";
+export { useComposerCancel } from "./primitive-hooks/useComposerCancel";
+export { useComposerDictate } from "./primitive-hooks/useComposerDictate";
+export { useComposerAddAttachment } from "./primitive-hooks/useComposerAddAttachment";
+export { useMessageReload } from "./primitive-hooks/useMessageReload";
+export { useMessageBranching } from "./primitive-hooks/useMessageBranching";
+export {
+  useActionBarCopy,
+  type UseActionBarCopyOptions,
+} from "./primitive-hooks/useActionBarCopy";
+export { useActionBarEdit } from "./primitive-hooks/useActionBarEdit";
+export { useActionBarReload } from "./primitive-hooks/useActionBarReload";
+export {
+  useActionBarFeedbackPositive,
+  useActionBarFeedbackNegative,
+} from "./primitive-hooks/useActionBarFeedback";
+export { useActionBarSpeak } from "./primitive-hooks/useActionBarSpeak";
+export { useActionBarStopSpeaking } from "./primitive-hooks/useActionBarStopSpeaking";
+export { useBranchPickerNext } from "./primitive-hooks/useBranchPickerNext";
+export { useBranchPickerPrevious } from "./primitive-hooks/useBranchPickerPrevious";
+export {
+  useSuggestionTrigger,
+  type UseSuggestionTriggerOptions,
+} from "./primitive-hooks/useSuggestionTrigger";
+export { useThreadListItemArchive } from "./primitive-hooks/useThreadListItemArchive";
+export { useThreadListItemDelete } from "./primitive-hooks/useThreadListItemDelete";
+export { useThreadListItemUnarchive } from "./primitive-hooks/useThreadListItemUnarchive";
+export { useThreadListItemTrigger } from "./primitive-hooks/useThreadListItemTrigger";
+export { useThreadListNew } from "./primitive-hooks/useThreadListNew";
+export { useEditComposerCancel } from "./primitive-hooks/useEditComposerCancel";
+export { useEditComposerSend } from "./primitive-hooks/useEditComposerSend";
+export { useMessageError } from "./primitive-hooks/useMessageError";
+
+// Shared AssistantRuntimeProvider
+export { AssistantRuntimeProvider } from "./AssistantRuntimeProvider";
+
+// Shared runtimes
+export {
+  useLocalRuntime,
+  splitLocalRuntimeOptions,
+  type LocalRuntimeOptions,
+} from "./runtimes/useLocalRuntime";

package/src/react/model-context/useInlineRender.ts

@@ -1,5 +1,5 @@
 import { FC, useCallback, useEffect, useState } from "react";
-import { ToolCallMessagePartProps } from "../types";
+import { ToolCallMessagePartProps } from "../types/MessagePartComponentTypes";
 import { create } from "zustand";
 
 export const useInlineRender = <TArgs, TResult>(

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/useActionBarSpeak.ts

@@ -0,0 +1,20 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useActionBarSpeak = () => {
+  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 speak = useCallback(async () => {
+    aui.message().speak();
+  }, [aui]);
+
+  return { speak, disabled };
+};

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

@@ -0,0 +1,13 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useActionBarStopSpeaking = () => {
+  const aui = useAui();
+  const disabled = useAuiState((s) => s.message.speech == null);
+
+  const stopSpeaking = useCallback(() => {
+    aui.message().stopSpeaking();
+  }, [aui]);
+
+  return { stopSpeaking, disabled };
+};

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

@@ -0,0 +1,19 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useBranchPickerNext = () => {
+  const aui = useAui();
+  const disabled = useAuiState((s) => {
+    if (s.message.branchNumber >= s.message.branchCount) return true;
+    if (s.thread.isRunning && !s.thread.capabilities.switchBranchDuringRun) {
+      return true;
+    }
+    return false;
+  });
+
+  const next = useCallback(() => {
+    aui.message().switchToBranch({ position: "next" });
+  }, [aui]);
+
+  return { next, disabled };
+};

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

@@ -0,0 +1,19 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useBranchPickerPrevious = () => {
+  const aui = useAui();
+  const disabled = useAuiState((s) => {
+    if (s.message.branchNumber <= 1) return true;
+    if (s.thread.isRunning && !s.thread.capabilities.switchBranchDuringRun) {
+      return true;
+    }
+    return false;
+  });
+
+  const previous = useCallback(() => {
+    aui.message().switchToBranch({ position: "previous" });
+  }, [aui]);
+
+  return { previous, 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 };
+};