@assistant-ui/react-native 0.1.0

package/dist/runtimes/useRemoteThreadListRuntime.js

@@ -0,0 +1,37 @@
+import { useState, useEffect, useMemo } from "react";
+import { BaseAssistantRuntimeCore, AssistantRuntimeImpl, } from "@assistant-ui/core/internal";
+import { RemoteThreadListThreadListRuntimeCore } from "./RemoteThreadListThreadListRuntimeCore.js";
+import { useAui } from "@assistant-ui/store";
+class RemoteThreadListRuntimeCore extends BaseAssistantRuntimeCore {
+    threads;
+    constructor(options) {
+        super();
+        this.threads = new RemoteThreadListThreadListRuntimeCore(options, this._contextProvider);
+    }
+    get RenderComponent() {
+        return this.threads.__internal_RenderComponent;
+    }
+}
+const useRemoteThreadListRuntimeImpl = (options) => {
+    const [runtime] = useState(() => new RemoteThreadListRuntimeCore(options));
+    useEffect(() => {
+        runtime.threads.__internal_setOptions(options);
+        runtime.threads.__internal_load();
+    }, [runtime, options]);
+    return useMemo(() => new AssistantRuntimeImpl(runtime), [runtime]);
+};
+export const useRemoteThreadListRuntime = (options) => {
+    const aui = useAui();
+    const isNested = aui.threadListItem.source !== null;
+    if (isNested) {
+        if (!options.allowNesting) {
+            throw new Error("useRemoteThreadListRuntime cannot be nested inside another RemoteThreadListRuntime. " +
+                "Set allowNesting: true to allow nesting (the inner runtime will become a no-op).");
+        }
+        // If allowNesting is true and already inside a thread list context,
+        // just call the runtimeHook directly (no-op behavior)
+        return options.runtimeHook();
+    }
+    return useRemoteThreadListRuntimeImpl(options);
+};
+//# sourceMappingURL=useRemoteThreadListRuntime.js.map

package/dist/runtimes/useRemoteThreadListRuntime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRemoteThreadListRuntime.js","sourceRoot":"","sources":["../../src/runtimes/useRemoteThreadListRuntime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AACrD,OAAO,EACL,wBAAwB,EACxB,oBAAoB,GAErB,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAAE,qCAAqC,EAAE,mDAAgD;AAChG,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,MAAM,2BACJ,SAAQ,wBAAwB;IAGhB,OAAO,CAAC;IAExB,YAAY,OAAgC;QAC1C,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,OAAO,GAAG,IAAI,qCAAqC,CACtD,OAAO,EACP,IAAI,CAAC,gBAAgB,CACtB,CAAC;IACJ,CAAC;IAED,IAAW,eAAe;QACxB,OAAO,IAAI,CAAC,OAAO,CAAC,0BAA0B,CAAC;IACjD,CAAC;CACF;AAED,MAAM,8BAA8B,GAAG,CACrC,OAAgC,EACd,EAAE;IACpB,MAAM,CAAC,OAAO,CAAC,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,2BAA2B,CAAC,OAAO,CAAC,CAAC,CAAC;IAC3E,SAAS,CAAC,GAAG,EAAE;QACb,OAAO,CAAC,OAAO,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC;QAC/C,OAAO,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC;IACpC,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;IACvB,OAAO,OAAO,CAAC,GAAG,EAAE,CAAC,IAAI,oBAAoB,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;AACrE,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,0BAA0B,GAAG,CACxC,OAAgC,EACd,EAAE;IACpB,MAAM,GAAG,GAAG,MAAM,EAAE,CAAC;IACrB,MAAM,QAAQ,GAAG,GAAG,CAAC,cAAc,CAAC,MAAM,KAAK,IAAI,CAAC;IAEpD,IAAI,QAAQ,EAAE,CAAC;QACb,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CACb,sFAAsF;gBACpF,kFAAkF,CACrF,CAAC;QACJ,CAAC;QAED,oEAAoE;QACpE,sDAAsD;QACtD,OAAO,OAAO,CAAC,WAAW,EAAE,CAAC;IAC/B,CAAC;IAED,OAAO,8BAA8B,CAAC,OAAO,CAAC,CAAC;AACjD,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@assistant-ui/react-native",
+  "version": "0.1.0",
+  "description": "React Native bindings for assistant-ui",
+  "keywords": [
+    "assistant",
+    "ai",
+    "chat",
+    "react-native",
+    "mobile"
+  ],
+  "author": "AgentbaseAI Inc.",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "aui-source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./internal": {
+      "aui-source": "./src/internal.ts",
+      "types": "./dist/internal.d.ts",
+      "default": "./dist/internal.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "aui-build",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@assistant-ui/core": "^0.1.0",
+    "@assistant-ui/store": "^0.2.0",
+    "@assistant-ui/tap": "^0.5.0",
+    "assistant-stream": "^0.3.3",
+    "zustand": "^5.0.11"
+  },
+  "peerDependencies": {
+    "@types/react": "*",
+    "react": "^18 || ^19",
+    "react-native": "*"
+  },
+  "peerDependenciesMeta": {
+    "@types/react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@assistant-ui/x-buildutils": "workspace:*",
+    "@types/react": "^19.2.14",
+    "react": "^19.2.4",
+    "react-native": "^0.84.0",
+    "vitest": "^4.0.18"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "homepage": "https://www.assistant-ui.com/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/assistant-ui/assistant-ui.git",
+    "directory": "packages/react-native"
+  },
+  "bugs": {
+    "url": "https://github.com/assistant-ui/assistant-ui/issues"
+  }
+}

package/src/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 "@assistant-ui/core";
+import type {
+  ExportedMessageRepository,
+  ExportedMessageRepositoryItem,
+} from "@assistant-ui/core/internal";
+import { RuntimeAdapterProvider } from "../context/providers/RuntimeAdapterProvider";
+import type { TitleGenerationAdapter } from "./TitleGenerationAdapter";
+
+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/adapters/TitleGenerationAdapter.ts

@@ -0,0 +1,20 @@
+import type { ThreadMessage } from "@assistant-ui/core";
+
+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/adapters/index.ts

@@ -0,0 +1,5 @@
+export {
+  type TitleGenerationAdapter,
+  createSimpleTitleAdapter,
+} from "./TitleGenerationAdapter";
+export { createLocalStorageAdapter } from "./LocalStorageThreadListAdapter";

package/src/context/AssistantContext.tsx

@@ -0,0 +1,44 @@
+import { type ComponentType, type ReactNode, memo } from "react";
+import { useAui, AuiProvider } from "@assistant-ui/store";
+import type {
+  AssistantRuntime,
+  AssistantRuntimeCore,
+} from "@assistant-ui/core";
+import { RuntimeAdapter } from "../runtimes/runtime-adapter";
+
+export const useAssistantRuntime = (): AssistantRuntime => {
+  const aui = useAui();
+  const runtime = aui.threads().__internal_getAssistantRuntime?.();
+  if (!runtime) {
+    throw new Error(
+      "useAssistantRuntime must be used within an AssistantProvider",
+    );
+  }
+  return runtime;
+};
+
+const getRenderComponent = (runtime: AssistantRuntime) => {
+  return (runtime as { _core?: AssistantRuntimeCore })._core?.RenderComponent as
+    | ComponentType
+    | undefined;
+};
+
+export const AssistantProvider = memo(
+  ({
+    runtime,
+    children,
+  }: {
+    runtime: AssistantRuntime;
+    children: ReactNode;
+  }) => {
+    const aui = useAui({ threads: RuntimeAdapter(runtime) }, { parent: null });
+    const RenderComponent = getRenderComponent(runtime);
+
+    return (
+      <AuiProvider value={aui}>
+        {RenderComponent && <RenderComponent />}
+        {children}
+      </AuiProvider>
+    );
+  },
+);

package/src/context/index.ts

@@ -0,0 +1 @@
+export { AssistantProvider, useAssistantRuntime } from "./AssistantContext";

package/src/context/providers/RuntimeAdapterProvider.tsx

@@ -0,0 +1,40 @@
+import { createContext, FC, ReactNode, useContext } from "react";
+import type {
+  ThreadHistoryAdapter,
+  AttachmentAdapter,
+} from "@assistant-ui/core";
+
+export type RuntimeAdapters = {
+  history?: ThreadHistoryAdapter | undefined;
+  attachments?: AttachmentAdapter | undefined;
+};
+
+const RuntimeAdaptersContext = createContext<RuntimeAdapters | null>(null);
+
+export namespace RuntimeAdapterProvider {
+  export type Props = {
+    adapters: RuntimeAdapters;
+    children: ReactNode;
+  };
+}
+
+export const RuntimeAdapterProvider: FC<RuntimeAdapterProvider.Props> = ({
+  adapters,
+  children,
+}) => {
+  const context = useContext(RuntimeAdaptersContext);
+  return (
+    <RuntimeAdaptersContext.Provider
+      value={{
+        ...context,
+        ...adapters,
+      }}
+    >
+      {children}
+    </RuntimeAdaptersContext.Provider>
+  );
+};
+
+export const useRuntimeAdapters = () => {
+  return useContext(RuntimeAdaptersContext);
+};

package/src/context/providers/ThreadListItemRuntimeProvider.tsx

@@ -0,0 +1,16 @@
+import { type FC, type PropsWithChildren } from "react";
+import { useAui, AuiProvider } from "@assistant-ui/store";
+import type { ThreadListItemRuntime } from "@assistant-ui/core";
+import { ThreadListItemClient } from "@assistant-ui/core/store/internal";
+
+export const ThreadListItemRuntimeProvider: FC<
+  PropsWithChildren<{
+    runtime: ThreadListItemRuntime;
+  }>
+> = ({ runtime, children }) => {
+  const aui = useAui({
+    threadListItem: ThreadListItemClient({ runtime }),
+  });
+
+  return <AuiProvider value={aui}>{children}</AuiProvider>;
+};

package/src/hooks/index.ts

@@ -0,0 +1,5 @@
+export { useThread } from "./useThread";
+export { useMessage } from "./useMessage";
+export { useComposer } from "./useComposer";
+export { useContentPart } from "./useContentPart";
+export { useThreadList } from "./useThreadList";

package/src/hooks/useComposer.ts

@@ -0,0 +1,14 @@
+import type { ComposerState } from "@assistant-ui/core/store";
+import { useAuiState } from "@assistant-ui/store";
+
+export function useComposer(): ComposerState;
+export function useComposer<TSelected>(
+  selector: (state: ComposerState) => TSelected,
+): TSelected;
+export function useComposer<TSelected = ComposerState>(
+  selector?: (state: ComposerState) => TSelected,
+): TSelected {
+  return useAuiState((s) =>
+    selector ? selector(s.composer) : (s.composer as unknown as TSelected),
+  );
+}

package/src/hooks/useContentPart.ts

@@ -0,0 +1,5 @@
+import { useAuiState } from "@assistant-ui/store";
+
+export function useContentPart(index: number) {
+  return useAuiState((s) => s.message.parts[index]);
+}

package/src/hooks/useMessage.ts

@@ -0,0 +1,14 @@
+import type { MessageState } from "@assistant-ui/core/store";
+import { useAuiState } from "@assistant-ui/store";
+
+export function useMessage(): MessageState;
+export function useMessage<TSelected>(
+  selector: (state: MessageState) => TSelected,
+): TSelected;
+export function useMessage<TSelected = MessageState>(
+  selector?: (state: MessageState) => TSelected,
+): TSelected {
+  return useAuiState((s) =>
+    selector ? selector(s.message) : (s.message as unknown as TSelected),
+  );
+}

package/src/hooks/useThread.ts

@@ -0,0 +1,14 @@
+import type { ThreadState } from "@assistant-ui/core/store";
+import { useAuiState } from "@assistant-ui/store";
+
+export function useThread(): ThreadState;
+export function useThread<TSelected>(
+  selector: (state: ThreadState) => TSelected,
+): TSelected;
+export function useThread<TSelected = ThreadState>(
+  selector?: (state: ThreadState) => TSelected,
+): TSelected {
+  return useAuiState((s) =>
+    selector ? selector(s.thread) : (s.thread as unknown as TSelected),
+  );
+}

package/src/hooks/useThreadList.ts

@@ -0,0 +1,14 @@
+import type { ThreadsState } from "@assistant-ui/core/store";
+import { useAuiState } from "@assistant-ui/store";
+
+export function useThreadList(): ThreadsState;
+export function useThreadList<TSelected>(
+  selector: (state: ThreadsState) => TSelected,
+): TSelected;
+export function useThreadList<TSelected = ThreadsState>(
+  selector?: (state: ThreadsState) => TSelected,
+): TSelected {
+  return useAuiState((s) =>
+    selector ? selector(s.threads) : (s.threads as unknown as TSelected),
+  );
+}

package/src/index.ts

@@ -0,0 +1,122 @@
+// Re-export core types
+export type {
+  // Message types
+  ThreadMessage,
+  ThreadUserMessage,
+  ThreadAssistantMessage,
+  ThreadSystemMessage,
+  MessageStatus,
+  MessageRole,
+  ThreadMessageLike,
+  AppendMessage,
+  RunConfig,
+  // Message parts
+  TextMessagePart,
+  ReasoningMessagePart,
+  SourceMessagePart,
+  ToolCallMessagePart,
+  ImageMessagePart,
+  FileMessagePart,
+  DataMessagePart,
+  Unstable_AudioMessagePart,
+  ThreadUserMessagePart,
+  ThreadAssistantMessagePart,
+  // Runtime types
+  AssistantRuntime,
+  ThreadRuntime,
+  MessageRuntime,
+  ThreadComposerRuntime,
+  EditComposerRuntime,
+  ComposerRuntime,
+  ThreadListRuntime,
+  ThreadListItemRuntime,
+  // Runtime core types
+  ChatModelAdapter,
+  ChatModelRunOptions,
+  ChatModelRunResult,
+  RuntimeCapabilities,
+  // Attachment types
+  Attachment,
+  PendingAttachment,
+  AttachmentRuntime,
+  // Other
+  Unsubscribe,
+} from "@assistant-ui/core";
+
+// Re-export store scope state types
+export type {
+  ThreadState,
+  ThreadsState,
+  MessageState,
+  ComposerState,
+  AttachmentState,
+  ThreadListItemState,
+} from "@assistant-ui/core/store";
+
+// Store hooks
+export {
+  useAui,
+  useAuiState,
+  useAuiEvent,
+  AuiProvider,
+} from "@assistant-ui/store";
+
+// Context providers and hooks
+export { AssistantProvider, useAssistantRuntime } from "./context";
+
+// State hooks
+export {
+  useThread,
+  useMessage,
+  useComposer,
+  useContentPart,
+  useThreadList,
+} from "./hooks";
+
+// Primitive hooks
+export {
+  useThreadMessages,
+  useThreadIsRunning,
+  useThreadIsEmpty,
+  useComposerSend,
+  useComposerCancel,
+  useMessageReload,
+  useMessageBranching,
+  useActionBarCopy,
+  type UseActionBarCopyOptions,
+  useActionBarEdit,
+  useActionBarReload,
+  useActionBarFeedbackPositive,
+  useActionBarFeedbackNegative,
+  useEditComposerSend,
+  useEditComposerCancel,
+} from "./primitive-hooks";
+
+// Runtime
+export {
+  useLocalRuntime,
+  type LocalRuntimeOptions,
+  useRemoteThreadListRuntime,
+} from "./runtimes";
+
+// Re-export core remote thread list types
+export type {
+  RemoteThreadListAdapter,
+  RemoteThreadListOptions,
+} from "@assistant-ui/core";
+export { InMemoryThreadListAdapter } from "@assistant-ui/core";
+
+// Primitives
+export * from "./primitives/thread";
+export * from "./primitives/composer";
+export * from "./primitives/message";
+export * from "./primitives/threadList";
+export * from "./primitives/actionBar";
+export * from "./primitives/branchPicker";
+
+// Adapters
+export {
+  type TitleGenerationAdapter,
+  createSimpleTitleAdapter,
+  createLocalStorageAdapter,
+} from "./adapters";