@assistant-ui/react 0.7.45 → 0.7.47

package/src/context/react/AttachmentContext.ts

@@ -1,124 +1,24 @@
 "use client";
 
-import { createContext, useContext } from "react";
+import { createContext } from "react";
 import { ReadonlyStore } from "../ReadonlyStore";
-import { createContextStoreHook } from "./utils/createContextStoreHook";
-import {
-  AttachmentRuntime,
-  AttachmentState,
-} from "../../api/AttachmentRuntime";
+import { AttachmentRuntime } from "../../api/AttachmentRuntime";
 import { UseBoundStore } from "zustand";
+import { createContextHook } from "./utils/createContextHook";
+import { createStateHookForRuntime } from "./utils/createStateHookForRuntime";
 
 export type AttachmentContextValue = {
-  source: "thread-composer" | "edit-composer" | "message";
-  useAttachment: UseBoundStore<ReadonlyStore<AttachmentState>>;
   useAttachmentRuntime: UseBoundStore<ReadonlyStore<AttachmentRuntime>>;
 };
 
-type ThreadComposerAttachmentContextValue = {
-  source: "thread-composer";
-  useAttachment: UseBoundStore<
-    ReadonlyStore<AttachmentState & { source: "thread-composer" }>
-  >;
-  useAttachmentRuntime: UseBoundStore<
-    ReadonlyStore<AttachmentRuntime & { type: "thread-composer" }>
-  >;
-};
-type EditComposerAttachmentContextValue = {
-  source: "edit-composer";
-  useAttachment: UseBoundStore<
-    ReadonlyStore<AttachmentState & { source: "edit-composer" }>
-  >;
-  useAttachmentRuntime: UseBoundStore<
-    ReadonlyStore<AttachmentRuntime & { type: "edit-composer" }>
-  >;
-};
-
-type MessageAttachmentContextValue = {
-  source: "message";
-  useAttachment: UseBoundStore<
-    ReadonlyStore<AttachmentState & { source: "message" }>
-  >;
-  useAttachmentRuntime: UseBoundStore<
-    ReadonlyStore<AttachmentRuntime & { type: "message" }>
-  >;
-};
-
 export const AttachmentContext = createContext<AttachmentContextValue | null>(
   null,
 );
 
-export function useAttachmentContext(options?: {
-  optional?: false | undefined;
-}): AttachmentContextValue;
-export function useAttachmentContext(options?: {
-  optional?: boolean | undefined;
-}): AttachmentContextValue | null;
-export function useAttachmentContext(options?: {
-  optional?: boolean | undefined;
-}) {
-  const context = useContext(AttachmentContext);
-  if (!options?.optional && !context)
-    throw new Error(
-      "This component must be used within a ComposerPrimitive.Attachments or MessagePrimitive.Attachments component.",
-    );
-
-  return context;
-}
-
-function useThreadComposerAttachmentContext(options?: {
-  optional?: false | undefined;
-}): ThreadComposerAttachmentContextValue;
-function useThreadComposerAttachmentContext(options?: {
-  optional?: boolean | undefined;
-}): ThreadComposerAttachmentContextValue | null;
-function useThreadComposerAttachmentContext(options?: {
-  optional?: boolean | undefined;
-}): ThreadComposerAttachmentContextValue | null {
-  const context = useAttachmentContext(options);
-  if (!context) return null;
-  if (context.source !== "thread-composer")
-    throw new Error(
-      "This component must be used within a thread's ComposerPrimitive.Attachments component.",
-    );
-  return context as ThreadComposerAttachmentContextValue;
-}
-
-function useEditComposerAttachmentContext(options?: {
-  optional?: false | undefined;
-}): EditComposerAttachmentContextValue;
-function useEditComposerAttachmentContext(options?: {
-  optional?: boolean | undefined;
-}): EditComposerAttachmentContextValue | null;
-function useEditComposerAttachmentContext(options?: {
-  optional?: boolean | undefined;
-}): EditComposerAttachmentContextValue | null {
-  const context = useAttachmentContext(options);
-  if (!context) return null;
-  if (context.source !== "edit-composer")
-    throw new Error(
-      "This component must be used within a messages's ComposerPrimitive.Attachments component.",
-    );
-  return context as EditComposerAttachmentContextValue;
-}
-
-function useMessageAttachmentContext(options?: {
-  optional?: false | undefined;
-}): MessageAttachmentContextValue;
-function useMessageAttachmentContext(options?: {
-  optional?: boolean | undefined;
-}): MessageAttachmentContextValue | null;
-function useMessageAttachmentContext(options?: {
-  optional?: boolean | undefined;
-}): MessageAttachmentContextValue | null {
-  const context = useAttachmentContext(options);
-  if (!context) return null;
-  if (context.source !== "message")
-    throw new Error(
-      "This component must be used within a MessagePrimitive.Attachments component.",
-    );
-  return context as MessageAttachmentContextValue;
-}
+const useAttachmentContext = createContextHook(
+  AttachmentContext,
+  "a ComposerPrimitive.Attachments or MessagePrimitive.Attachments component",
+);
 
 export function useAttachmentRuntime(options?: {
   optional?: false | undefined;
@@ -136,58 +36,67 @@ export function useAttachmentRuntime(options?: {
 
 export function useThreadComposerAttachmentRuntime(options?: {
   optional?: false | undefined;
-}): AttachmentRuntime;
+}): AttachmentRuntime<"thread-composer">;
 export function useThreadComposerAttachmentRuntime(options?: {
   optional?: boolean | undefined;
-}): AttachmentRuntime | null;
+}): AttachmentRuntime<"thread-composer"> | null;
 export function useThreadComposerAttachmentRuntime(options?: {
   optional?: boolean | undefined;
-}): AttachmentRuntime | null {
-  const attachmentRuntime = useThreadComposerAttachmentContext(options);
+}): AttachmentRuntime<"thread-composer"> | null {
+  const attachmentRuntime = useAttachmentRuntime(options);
   if (!attachmentRuntime) return null;
-  return attachmentRuntime.useAttachmentRuntime();
+  if (attachmentRuntime.source !== "thread-composer")
+    throw new Error(
+      "This component must be used within a thread's ComposerPrimitive.Attachments component.",
+    );
+  return attachmentRuntime as AttachmentRuntime<"thread-composer">;
 }
 
 export function useEditComposerAttachmentRuntime(options?: {
   optional?: false | undefined;
-}): AttachmentRuntime;
+}): AttachmentRuntime<"edit-composer">;
 export function useEditComposerAttachmentRuntime(options?: {
   optional?: boolean | undefined;
-}): AttachmentRuntime | null;
+}): AttachmentRuntime<"edit-composer"> | null;
 export function useEditComposerAttachmentRuntime(options?: {
   optional?: boolean | undefined;
-}): AttachmentRuntime | null {
-  const attachmentRuntime = useEditComposerAttachmentContext(options);
+}): AttachmentRuntime<"edit-composer"> | null {
+  const attachmentRuntime = useAttachmentRuntime(options);
   if (!attachmentRuntime) return null;
-  return attachmentRuntime.useAttachmentRuntime();
+  if (attachmentRuntime.source !== "edit-composer")
+    throw new Error(
+      "This component must be used within a message's ComposerPrimitive.Attachments component.",
+    );
+
+  return attachmentRuntime as AttachmentRuntime<"edit-composer">;
 }
 
 export function useMessageAttachmentRuntime(options?: {
   optional?: false | undefined;
-}): AttachmentRuntime;
+}): AttachmentRuntime<"message">;
 export function useMessageAttachmentRuntime(options?: {
   optional?: boolean | undefined;
-}): AttachmentRuntime | null;
+}): AttachmentRuntime<"message"> | null;
 export function useMessageAttachmentRuntime(options?: {
   optional?: boolean | undefined;
-}): AttachmentRuntime | null {
-  const attachmentRuntime = useMessageAttachmentContext(options);
+}): AttachmentRuntime<"message"> | null {
+  const attachmentRuntime = useAttachmentRuntime(options);
   if (!attachmentRuntime) return null;
-  return attachmentRuntime.useAttachmentRuntime();
+  if (attachmentRuntime.source !== "message")
+    throw new Error(
+      "This component must be used within a MessagePrimitive.Attachments component.",
+    );
+  return attachmentRuntime as AttachmentRuntime<"message">;
 }
 
-export const { useAttachment } = createContextStoreHook(
-  useAttachmentContext,
-  "useAttachment",
-);
-
-export const { useAttachment: useThreadComposerAttachment } =
-  createContextStoreHook(useThreadComposerAttachmentContext, "useAttachment");
+export const useAttachment = createStateHookForRuntime(useAttachmentRuntime);
 
-export const { useAttachment: useEditComposerAttachment } =
-  createContextStoreHook(useEditComposerAttachmentContext, "useAttachment");
-
-export const { useAttachment: useMessageAttachment } = createContextStoreHook(
-  useMessageAttachmentContext,
-  "useAttachment",
+export const useThreadComposerAttachment = createStateHookForRuntime(
+  useThreadComposerAttachmentRuntime,
+);
+export const useEditComposerAttachment = createStateHookForRuntime(
+  useEditComposerAttachmentRuntime,
+);
+export const useMessageAttachment = createStateHookForRuntime(
+  useMessageAttachmentRuntime,
 );

package/src/context/react/ComposerContext.ts

@@ -1,34 +1,9 @@
 "use client";
 
-import { useMemo } from "react";
-import { useMessageContext, useMessageRuntime } from "./MessageContext";
-import { useThreadContext, useThreadRuntime } from "./ThreadContext";
-import { ReadonlyStore } from "../ReadonlyStore";
-import { createContextStoreHook } from "./utils/createContextStoreHook";
-import { ComposerRuntime, ComposerState } from "../../api/ComposerRuntime";
-import { UseBoundStore } from "zustand";
-
-export type ComposerContextValue = {
-  useComposer: UseBoundStore<ReadonlyStore<ComposerState>>;
-  type: "edit" | "new";
-};
-
-export const useComposerContext = (): ComposerContextValue => {
-  const { useComposer: useThreadComposer } = useThreadContext();
-  const { useEditComposer } = useMessageContext({ optional: true }) ?? {};
-  return useMemo(
-    () => ({
-      useComposer: useEditComposer ?? useThreadComposer,
-      type: useEditComposer ? ("edit" as const) : ("new" as const),
-    }),
-    [useEditComposer, useThreadComposer],
-  );
-};
-
-export const { useComposer } = createContextStoreHook(
-  useComposerContext,
-  "useComposer",
-);
+import { useMessageRuntime } from "./MessageContext";
+import { useThreadRuntime } from "./ThreadContext";
+import { ComposerRuntime } from "../../api/ComposerRuntime";
+import { createStateHookForRuntime } from "./utils/createStateHookForRuntime";
 
 export function useComposerRuntime(options?: {
   optional?: false | undefined;
@@ -45,3 +20,5 @@ export function useComposerRuntime(options?: {
     ? messageRuntime.composer
     : (threadRuntime?.composer ?? null);
 }
+
+export const useComposer = createStateHookForRuntime(useComposerRuntime);

package/src/context/react/ContentPartContext.ts

@@ -2,22 +2,20 @@
 
 import { createContext } from "react";
 import { ReadonlyStore } from "../ReadonlyStore";
-import { createContextStoreHook } from "./utils/createContextStoreHook";
 import { createContextHook } from "./utils/createContextHook";
 import { UseBoundStore } from "zustand";
 import { ContentPartRuntime } from "../../api/ContentPartRuntime";
-import { ContentPartState } from "../../api/ContentPartRuntime";
+import { createStateHookForRuntime } from "./utils/createStateHookForRuntime";
 
 export type ContentPartContextValue = {
   useContentPartRuntime: UseBoundStore<ReadonlyStore<ContentPartRuntime>>;
-  useContentPart: UseBoundStore<ReadonlyStore<ContentPartState>>;
 };
 
 export const ContentPartContext = createContext<ContentPartContextValue | null>(
   null,
 );
 
-export const useContentPartContext = createContextHook(
+const useContentPartContext = createContextHook(
   ContentPartContext,
   "a component passed to <MessagePrimitive.Content components={...}>",
 );
@@ -36,7 +34,4 @@ export function useContentPartRuntime(options?: {
   return context.useContentPartRuntime();
 }
 
-export const { useContentPart } = createContextStoreHook(
-  useContentPartContext,
-  "useContentPart",
-);
+export const useContentPart = createStateHookForRuntime(useContentPartRuntime);

package/src/context/react/MessageContext.ts

@@ -7,19 +7,17 @@ import { createContextHook } from "./utils/createContextHook";
 import { createContextStoreHook } from "./utils/createContextStoreHook";
 import { UseBoundStore } from "zustand";
 import { MessageRuntime } from "../../api/MessageRuntime";
-import { MessageState } from "../../api/MessageRuntime";
-import { EditComposerState } from "../../api/ComposerRuntime";
+import { createStateHookForRuntime } from "./utils/createStateHookForRuntime";
+import { EditComposerRuntime } from "../../api";
 
 export type MessageContextValue = {
   useMessageRuntime: UseBoundStore<ReadonlyStore<MessageRuntime>>;
-  useMessage: UseBoundStore<ReadonlyStore<MessageState>>;
   useMessageUtils: UseBoundStore<ReadonlyStore<MessageUtilsState>>;
-  useEditComposer: UseBoundStore<ReadonlyStore<EditComposerState>>;
 };
 
 export const MessageContext = createContext<MessageContextValue | null>(null);
 
-export const useMessageContext = createContextHook(
+const useMessageContext = createContextHook(
   MessageContext,
   "a component passed to <ThreadPrimitive.Messages components={...} />",
 );
@@ -38,17 +36,16 @@ export function useMessageRuntime(options?: {
   return context.useMessageRuntime();
 }
 
-export const { useMessage } = createContextStoreHook(
-  useMessageContext,
-  "useMessage",
+export const useMessage = createStateHookForRuntime(useMessageRuntime);
+
+const useEditComposerRuntime = (opt: {
+  optional: boolean | undefined;
+}): EditComposerRuntime | null => useMessageRuntime(opt)?.composer ?? null;
+export const useEditComposer = createStateHookForRuntime(
+  useEditComposerRuntime,
 );
 
 export const { useMessageUtils, useMessageUtilsStore } = createContextStoreHook(
   useMessageContext,
   "useMessageUtils",
 );
-
-export const { useEditComposer } = createContextStoreHook(
-  useMessageContext,
-  "useEditComposer",
-);

package/src/context/react/ThreadContext.ts

@@ -7,20 +7,18 @@ import { UseBoundStore } from "zustand";
 import { createContextHook } from "./utils/createContextHook";
 import { createContextStoreHook } from "./utils/createContextStoreHook";
 import { ThreadRuntime } from "../../api/ThreadRuntime";
-import { ThreadState } from "../../api/ThreadRuntime";
 import { ModelConfig } from "../../types";
-import { ThreadComposerState } from "../../api/ComposerRuntime";
+import { createStateHookForRuntime } from "./utils/createStateHookForRuntime";
+import { ThreadComposerRuntime } from "../../api";
 
 export type ThreadContextValue = {
-  useThread: UseBoundStore<ReadonlyStore<ThreadState>>;
   useThreadRuntime: UseBoundStore<ReadonlyStore<ThreadRuntime>>;
-  useComposer: UseBoundStore<ReadonlyStore<ThreadComposerState>>;
   useViewport: UseBoundStore<ReadonlyStore<ThreadViewportState>>;
 };
 
 export const ThreadContext = createContext<ThreadContextValue | null>(null);
 
-export const useThreadContext = createContextHook(
+const useThreadContext = createContextHook(
   ThreadContext,
   "AssistantRuntimeProvider",
 );
@@ -37,14 +35,13 @@ export function useThreadRuntime(options?: { optional?: boolean | undefined }) {
   return context.useThreadRuntime();
 }
 
-export const { useThread } = createContextStoreHook(
-  useThreadContext,
-  "useThread",
-);
+export const useThread = createStateHookForRuntime(useThreadRuntime);
 
-export const { useComposer: useThreadComposer } = createContextStoreHook(
-  useThreadContext,
-  "useComposer",
+const useThreadComposerRuntime = (opt: {
+  optional: boolean | undefined;
+}): ThreadComposerRuntime | null => useThreadRuntime(opt)?.composer ?? null;
+export const useThreadComposer = createStateHookForRuntime(
+  useThreadComposerRuntime,
 );
 
 export const {

package/src/context/react/ThreadListItemContext.ts

@@ -2,21 +2,19 @@
 
 import { createContext } from "react";
 import { ReadonlyStore } from "../ReadonlyStore";
-import { createContextStoreHook } from "./utils/createContextStoreHook";
 import { createContextHook } from "./utils/createContextHook";
 import { UseBoundStore } from "zustand";
 import { ThreadListItemRuntime } from "../../api/ThreadListItemRuntime";
-import { ThreadListItemState } from "../../api/ThreadListItemRuntime";
+import { createStateHookForRuntime } from "./utils/createStateHookForRuntime";
 
 export type ThreadListItemContextValue = {
   useThreadListItemRuntime: UseBoundStore<ReadonlyStore<ThreadListItemRuntime>>;
-  useThreadListItem: UseBoundStore<ReadonlyStore<ThreadListItemState>>;
 };
 
 export const ThreadListItemContext =
   createContext<ThreadListItemContextValue | null>(null);
 
-export const useThreadListItemContext = createContextHook(
+const useThreadListItemContext = createContextHook(
   ThreadListItemContext,
   "a component passed to <ThreadListPrimitive.Items components={...}>",
 );
@@ -35,7 +33,6 @@ export function useThreadListItemRuntime(options?: {
   return context.useThreadListItemRuntime();
 }
 
-export const { useThreadListItem } = createContextStoreHook(
-  useThreadListItemContext,
-  "useThreadListItem",
+export const useThreadListItem = createStateHookForRuntime(
+  useThreadListItemRuntime,
 );

package/src/context/react/index.ts

@@ -45,3 +45,5 @@ export {
   // useThreadComposerAttachment,
   // useThreadComposerAttachmentRuntime,
 } from "./AttachmentContext";
+
+export { useRuntimeState } from "./utils/useRuntimeState";

package/src/context/react/utils/createContextHook.ts

@@ -12,11 +12,9 @@ export function createContextHook<T>(
   context: Context<T | null>,
   providerName: string,
 ) {
-  function useContextHook(options?: { optional?: false | undefined }): T;
   function useContextHook(options?: {
     optional?: boolean | undefined;
-  }): T | null;
-  function useContextHook(options?: { optional?: boolean | undefined }) {
+  }): T | null {
     const contextValue = useContext(context);
     if (!options?.optional && !contextValue) {
       throw new Error(`This component must be used within ${providerName}.`);

package/src/context/react/utils/createStateHookForRuntime.ts

@@ -0,0 +1,80 @@
+import {
+  SubscribableRuntime,
+  useRuntimeStateInternal,
+} from "./useRuntimeState";
+
+export function createStateHookForRuntime<TState>(
+  useRuntime: (options: {
+    optional: boolean | undefined;
+  }) => SubscribableRuntime<TState> | null,
+) {
+  // empty
+  function useStoreHook(): TState;
+
+  // selector
+  function useStoreHook<TSelected>(
+    selector: (state: TState) => TSelected,
+  ): TSelected;
+
+  // selector?
+  function useStoreHook<TSelected>(
+    selector: ((state: TState) => TSelected) | undefined,
+  ): TSelected | TState;
+
+  // optional=false
+  function useStoreHook(options: { optional?: false | undefined }): TState;
+
+  // optional?
+  function useStoreHook(options: {
+    optional?: boolean | undefined;
+  }): TState | null;
+
+  // optional=false, selector
+  function useStoreHook<TSelected>(options: {
+    optional?: false | undefined;
+    selector: (state: TState) => TSelected;
+  }): TSelected;
+
+  // optional=false, selector?
+  function useStoreHook<TSelected>(options: {
+    optional?: false | undefined;
+    selector: ((state: TState) => TSelected) | undefined;
+  }): TSelected | TState;
+
+  // optional?, selector
+  function useStoreHook<TSelected>(options: {
+    optional?: boolean | undefined;
+    selector: (state: TState) => TSelected;
+  }): TSelected | null;
+
+  // optional?, selector?
+  function useStoreHook<TSelected>(options: {
+    optional?: boolean | undefined;
+    selector: ((state: TState) => TSelected) | undefined;
+  }): TSelected | TState | null;
+
+  function useStoreHook<TSelected>(
+    param?:
+      | ((state: TState) => TSelected)
+      | {
+          optional?: boolean | undefined;
+          selector?: ((state: TState) => TSelected) | undefined;
+        },
+  ): TSelected | TState | null {
+    let optional = false;
+    let selector: ((state: TState) => TSelected) | undefined;
+
+    if (typeof param === "function") {
+      selector = param;
+    } else if (param) {
+      optional = !!param.optional;
+      selector = param.selector;
+    }
+
+    const store = useRuntime({ optional });
+    if (!store) return null;
+    return useRuntimeStateInternal(store, selector);
+  }
+
+  return useStoreHook;
+}

package/src/context/react/utils/ensureBinding.ts

@@ -0,0 +1,45 @@
+type Bindable = {
+  __internal_bindMethods?: () => void;
+  __isBound?: boolean;
+};
+const debugVerifyPrototype = (
+  runtime: Record<string, unknown>,
+  prototype: any,
+) => {
+  const unboundMethods = Object.getOwnPropertyNames(prototype).filter(
+    (methodStr) => {
+      const descriptor = Object.getOwnPropertyDescriptor(prototype, methodStr);
+      const isMethod = descriptor && typeof descriptor.value === "function";
+      if (!isMethod) return false;
+
+      const methodName = methodStr as keyof typeof runtime | "constructor";
+      return (
+        isMethod &&
+        !methodName.startsWith("_") &&
+        methodName !== "constructor" &&
+        prototype[methodName] === runtime[methodName]
+      );
+    },
+  );
+
+  if (unboundMethods.length > 0) {
+    throw new Error(
+      "The following methods are not bound: " + JSON.stringify(unboundMethods),
+    );
+  }
+
+  const prototypePrototype = Object.getPrototypeOf(prototype);
+  if (prototypePrototype && prototypePrototype !== Object.prototype) {
+    debugVerifyPrototype(runtime, prototypePrototype);
+  }
+};
+export const ensureBinding = (r: unknown) => {
+  const runtime = r as Bindable;
+  if (runtime.__isBound) return;
+
+  runtime.__internal_bindMethods?.();
+  runtime.__isBound = true;
+
+  // @ts-ignore - strip this out in production build
+  DEV: debugVerifyPrototype(runtime, Object.getPrototypeOf(runtime));
+};

package/src/context/react/utils/useRuntimeState.ts

@@ -0,0 +1,43 @@
+import { useDebugValue, useSyncExternalStore } from "react";
+import { Unsubscribe } from "../../../types";
+import { ensureBinding } from "./ensureBinding";
+
+export type SubscribableRuntime<TState> = {
+  getState: () => TState;
+  subscribe: (callback: () => void) => Unsubscribe;
+};
+
+export function useRuntimeStateInternal<TState, TSelected>(
+  runtime: SubscribableRuntime<TState>,
+  selector: ((state: TState) => TSelected) | undefined = identity as any,
+): TSelected | TState {
+  const slice = useSyncExternalStore(
+    runtime.subscribe,
+    () => selector(runtime.getState()),
+    () => selector(runtime.getState()),
+  );
+  useDebugValue(slice);
+  return slice;
+}
+
+const identity = <T>(arg: T): T => arg;
+export function useRuntimeState<TState>(
+  runtime: SubscribableRuntime<TState>,
+): TState;
+export function useRuntimeState<TState, TSelected>(
+  runtime: SubscribableRuntime<TState>,
+  selector: (state: TState) => TSelected,
+): TSelected;
+export function useRuntimeState<TState, TSelected>(
+  runtime: SubscribableRuntime<TState>,
+  selector: ((state: TState) => TSelected) | undefined,
+): TSelected | TState;
+export function useRuntimeState<TState, TSelected>(
+  runtime: SubscribableRuntime<TState>,
+  selector?: ((state: TState) => TSelected) | undefined,
+): TSelected | TState {
+  // ensure that the runtime is bound
+  ensureBinding(runtime);
+
+  return useRuntimeStateInternal(runtime, selector);
+}

package/src/runtimes/adapters/attachment/AttachmentAdapter.ts

@@ -7,7 +7,9 @@ import {
 export type AttachmentAdapter = {
   accept: string;
 
-  add(state: { file: File }): Promise<PendingAttachment>;
+  add(state: {
+    file: File;
+  }): Promise<PendingAttachment> | AsyncGenerator<PendingAttachment, void>;
   remove(attachment: Attachment): Promise<void>;
   send(attachment: PendingAttachment): Promise<CompleteAttachment>;
 };

package/src/runtimes/adapters/attachment/CompositeAttachmentAdapter.ts

@@ -65,7 +65,7 @@ export class CompositeAttachmentAdapter implements AttachmentAdapter {
     }
   }
 
-  public async add(state: { file: File }) {
+  public add(state: { file: File }) {
     for (const adapter of this._adapters) {
       if (fileMatchesAccept(state.file, adapter.accept)) {
         return adapter.add(state);

package/src/runtimes/adapters/thread-history/ThreadHistoryAdapter.ts

@@ -3,6 +3,7 @@ import {
   ExportedMessageRepositoryItem,
 } from "../../utils/MessageRepository";
 
+// TODO external store - which version to save? how to restore?
 export type ThreadHistoryAdapter = {
   load(): Promise<ExportedMessageRepository>;
   append(item: ExportedMessageRepositoryItem): Promise<void>;