@assistant-ui/react 0.10.49 → 0.11.0

package/src/primitives/thread/ThreadSuggestion.tsx

@@ -6,8 +6,7 @@ import {
   createActionButton,
 } from "../../utils/createActionButton";
 import { useCallback } from "react";
-import { useThread } from "../../context";
-import { useThreadRuntime } from "../../context/react/ThreadContext";
+import { useAssistantState, useAssistantApi } from "../../context";
 
 const useThreadSuggestion = ({
   prompt,
@@ -17,16 +16,17 @@ const useThreadSuggestion = ({
   method?: "replace";
   autoSend?: boolean | undefined;
 }) => {
-  const threadRuntime = useThreadRuntime();
+  const api = useAssistantApi();
+  const disabled = useAssistantState(({ thread }) => thread.isDisabled);
 
-  const disabled = useThread((t) => t.isDisabled);
   const callback = useCallback(() => {
-    if (autoSend && !threadRuntime.getState().isRunning) {
-      threadRuntime.append(prompt);
+    const isRunning = api.thread().getState().isRunning;
+    if (autoSend && !isRunning) {
+      api.thread().append(prompt);
     } else {
-      threadRuntime.composer.setText(prompt);
+      api.composer().setText(prompt);
     }
-  }, [threadRuntime, autoSend, prompt]);
+  }, [api, autoSend, prompt]);
 
   if (disabled) return null;
   return callback;

package/src/primitives/thread/useThreadViewportAutoScroll.tsx

@@ -1,8 +1,8 @@
 "use client";
 
 import { useComposedRefs } from "@radix-ui/react-compose-refs";
-import { RefCallback, useCallback, useEffect, useRef } from "react";
-import { useThreadRuntime } from "../../context/react/ThreadContext";
+import { RefCallback, useCallback, useRef } from "react";
+import { useAssistantEvent } from "../../context";
 import { useOnResizeContent } from "../../utils/hooks/useOnResizeContent";
 import { useOnScrollToBottom } from "../../utils/hooks/useOnScrollToBottom";
 import { useManagedRef } from "../../utils/hooks/useManagedRef";
@@ -87,10 +87,7 @@ export const useThreadViewportAutoScroll = <TElement extends HTMLElement>({
   });
 
   // autoscroll on run start
-  const threadRuntime = useThreadRuntime();
-  useEffect(() => {
-    return threadRuntime.unstable_on("run-start", () => scrollToBottom("auto"));
-  }, [scrollToBottom, threadRuntime]);
+  useAssistantEvent("thread.run-start", () => scrollToBottom("auto"));
 
   const autoScrollRef = useComposedRefs<TElement>(resizeRef, scrollRef, divRef);
   return autoScrollRef as RefCallback<TElement>;

package/src/primitives/threadList/ThreadListItems.tsx

@@ -1,8 +1,10 @@
 "use client";
 
 import { ComponentType, FC, memo, useMemo } from "react";
-import { ThreadListItemRuntimeProvider } from "../../context/providers/ThreadListItemRuntimeProvider";
-import { useAssistantRuntime, useThreadList } from "../../context";
+import {
+  ThreadListItemByIndexProvider,
+  useAssistantState,
+} from "../../context";
 
 export namespace ThreadListPrimitiveItems {
   export type Props = {
@@ -40,21 +42,12 @@ export namespace ThreadListPrimitiveItemByIndex {
 export const ThreadListPrimitiveItemByIndex: FC<ThreadListPrimitiveItemByIndex.Props> =
   memo(
     ({ index, archived = false, components }) => {
-      const assistantRuntime = useAssistantRuntime();
-      const runtime = useMemo(
-        () =>
-          archived
-            ? assistantRuntime.threads.getArchivedItemByIndex(index)
-            : assistantRuntime.threads.getItemByIndex(index),
-        [assistantRuntime, index, archived],
-      );
-
       const ThreadListItemComponent = components.ThreadListItem;
 
       return (
-        <ThreadListItemRuntimeProvider runtime={runtime}>
+        <ThreadListItemByIndexProvider index={index} archived={archived}>
           <ThreadListItemComponent />
-        </ThreadListItemRuntimeProvider>
+        </ThreadListItemByIndexProvider>
       );
     },
     (prev, next) =>
@@ -69,8 +62,8 @@ export const ThreadListPrimitiveItems: FC<ThreadListPrimitiveItems.Props> = ({
   archived = false,
   components,
 }) => {
-  const contentLength = useThreadList((s) =>
-    archived ? s.archivedThreads.length : s.threads.length,
+  const contentLength = useAssistantState(({ threads }) =>
+    archived ? threads.archivedThreadIds.length : threads.threadIds.length,
   );
 
   const listElements = useMemo(() => {

package/src/primitives/threadList/ThreadListNew.tsx

@@ -4,29 +4,25 @@ import {
   ActionButtonElement,
   ActionButtonProps,
 } from "../../utils/createActionButton";
-import { useAssistantRuntime, useThreadList } from "../../context";
 import { forwardRef } from "react";
 import { Primitive } from "@radix-ui/react-primitive";
 import { composeEventHandlers } from "@radix-ui/primitive";
-
-const useThreadListNew = () => {
-  const runtime = useAssistantRuntime();
-  return () => {
-    runtime.switchToNewThread();
-  };
-};
+import { useAssistantState, useAssistantApi } from "../../context";
 
 export namespace ThreadListPrimitiveNew {
   export type Element = ActionButtonElement;
-  export type Props = ActionButtonProps<typeof useThreadListNew>;
+  export type Props = ActionButtonProps<() => void>;
 }
 
 export const ThreadListPrimitiveNew = forwardRef<
   ThreadListPrimitiveNew.Element,
   ThreadListPrimitiveNew.Props
 >(({ onClick, disabled, ...props }, forwardedRef) => {
-  const isMain = useThreadList((t) => t.newThread === t.mainThreadId);
-  const callback = useThreadListNew();
+  const isMain = useAssistantState(
+    ({ threads }) => threads.newThreadId === threads.mainThreadId,
+  );
+
+  const api = useAssistantApi();
 
   return (
     <Primitive.button
@@ -34,9 +30,9 @@ export const ThreadListPrimitiveNew = forwardRef<
       {...(isMain ? { "data-active": "true", "aria-current": "true" } : null)}
       {...props}
       ref={forwardedRef}
-      disabled={disabled || !callback}
+      disabled={disabled}
       onClick={composeEventHandlers(onClick, () => {
-        callback?.();
+        api.threads().switchToNewThread();
       })}
     />
   );

package/src/primitives/threadListItem/ThreadListItemArchive.ts

@@ -5,14 +5,14 @@ import {
   ActionButtonProps,
   createActionButton,
 } from "../../utils/createActionButton";
-import { useThreadListItemRuntime } from "../../context/react/ThreadListItemContext";
+import { useAssistantApi } from "../../context";
 import { useCallback } from "react";
 
 const useThreadListItemArchive = () => {
-  const runtime = useThreadListItemRuntime();
+  const api = useAssistantApi();
   return useCallback(() => {
-    runtime.archive();
-  }, [runtime]);
+    api.threadListItem().archive();
+  }, [api]);
 };
 
 export namespace ThreadListItemPrimitiveArchive {

package/src/primitives/threadListItem/ThreadListItemDelete.ts

@@ -5,13 +5,14 @@ import {
   ActionButtonProps,
   createActionButton,
 } from "../../utils/createActionButton";
-import { useThreadListItemRuntime } from "../../context/react/ThreadListItemContext";
+import { useAssistantApi } from "../../context";
+import { useCallback } from "react";
 
 const useThreadListItemDelete = () => {
-  const runtime = useThreadListItemRuntime();
-  return () => {
-    runtime.delete();
-  };
+  const api = useAssistantApi();
+  return useCallback(() => {
+    api.threadListItem().delete();
+  }, [api]);
 };
 
 export namespace ThreadListItemPrimitiveDelete {

package/src/primitives/threadListItem/ThreadListItemRoot.tsx

@@ -2,7 +2,7 @@
 
 import { Primitive } from "@radix-ui/react-primitive";
 import { type ComponentRef, forwardRef, ComponentPropsWithoutRef } from "react";
-import { useThreadListItem } from "../../context/react/ThreadListItemContext";
+import { useAssistantState } from "../../context";
 
 type PrimitiveDivProps = ComponentPropsWithoutRef<typeof Primitive.div>;
 
@@ -15,7 +15,9 @@ export const ThreadListItemPrimitiveRoot = forwardRef<
   ThreadListItemPrimitiveRoot.Element,
   ThreadListItemPrimitiveRoot.Props
 >((props, ref) => {
-  const isMain = useThreadListItem((t) => t.isMain);
+  const isMain = useAssistantState(
+    ({ threads, threadListItem }) => threads.mainThreadId === threadListItem.id,
+  );
 
   return (
     <Primitive.div

package/src/primitives/threadListItem/ThreadListItemTitle.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import type { FC, ReactNode } from "react";
-import { useThreadListItem } from "../../context/react/ThreadListItemContext";
+import { useAssistantState } from "../../context";
 
 export namespace ThreadListItemPrimitiveTitle {
   export type Props = {
@@ -12,7 +12,7 @@ export namespace ThreadListItemPrimitiveTitle {
 export const ThreadListItemPrimitiveTitle: FC<
   ThreadListItemPrimitiveTitle.Props
 > = ({ fallback }) => {
-  const title = useThreadListItem((t) => t.title);
+  const title = useAssistantState(({ threadListItem }) => threadListItem.title);
   return <>{title || fallback}</>;
 };
 

package/src/primitives/threadListItem/ThreadListItemTrigger.ts

@@ -5,13 +5,14 @@ import {
   ActionButtonProps,
   createActionButton,
 } from "../../utils/createActionButton";
-import { useThreadListItemRuntime } from "../../context/react/ThreadListItemContext";
+import { useAssistantApi } from "../../context";
+import { useCallback } from "react";
 
 const useThreadListItemTrigger = () => {
-  const runtime = useThreadListItemRuntime();
-  return () => {
-    runtime.switchTo();
-  };
+  const api = useAssistantApi();
+  return useCallback(() => {
+    api.threadListItem().switchTo();
+  }, [api]);
 };
 
 export namespace ThreadListItemPrimitiveTrigger {

package/src/primitives/threadListItem/ThreadListItemUnarchive.ts

@@ -5,13 +5,14 @@ import {
   ActionButtonProps,
   createActionButton,
 } from "../../utils/createActionButton";
-import { useThreadListItemRuntime } from "../../context/react/ThreadListItemContext";
+import { useAssistantApi } from "../../context";
+import { useCallback } from "react";
 
 const useThreadListItemUnarchive = () => {
-  const runtime = useThreadListItemRuntime();
-  return () => {
-    runtime.unarchive();
-  };
+  const api = useAssistantApi();
+  return useCallback(() => {
+    api.threadListItem().unarchive();
+  }, [api]);
 };
 
 export namespace ThreadListItemPrimitiveUnarchive {

package/src/runtimes/adapters/RuntimeAdapterProvider.tsx

@@ -2,11 +2,13 @@
 
 import { createContext, FC, ReactNode, useContext } from "react";
 import { ThreadHistoryAdapter } from "./thread-history/ThreadHistoryAdapter";
+import { AttachmentAdapter } from "./attachment/AttachmentAdapter";
 import { ModelContextProvider } from "../../model-context";
 
 export type RuntimeAdapters = {
   modelContext?: ModelContextProvider;
   history?: ThreadHistoryAdapter;
+  attachments?: AttachmentAdapter;
 };
 
 const RuntimeAdaptersContext = createContext<RuntimeAdapters | null>(null);

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

@@ -0,0 +1,101 @@
+import type { AssistantCloud } from "assistant-cloud";
+import {
+  Attachment,
+  PendingAttachment,
+  CompleteAttachment,
+} from "../../../types/AttachmentTypes";
+import { ThreadUserMessagePart } from "../../../types/MessagePartTypes";
+import { AttachmentAdapter } from "./AttachmentAdapter";
+
+const guessAttachmentType = (
+  contentType: string,
+): "image" | "document" | "file" => {
+  if (contentType.startsWith("image/")) return "image";
+  if (contentType.startsWith("text/")) return "document";
+  return "file";
+};
+
+export class CloudFileAttachmentAdapter implements AttachmentAdapter {
+  public accept = "*";
+
+  constructor(private cloud: AssistantCloud) {}
+
+  private uploadedUrls = new Map<string, string>();
+
+  public async *add({
+    file,
+  }: {
+    file: File;
+  }): AsyncGenerator<PendingAttachment, void> {
+    const id = crypto.randomUUID();
+    const type = guessAttachmentType(file.type);
+    let attachment: PendingAttachment = {
+      id,
+      type,
+      name: file.name,
+      contentType: file.type,
+      file,
+      status: { type: "running", reason: "uploading", progress: 0 },
+    };
+    yield attachment;
+
+    try {
+      const { signedUrl, publicUrl } =
+        await this.cloud.files.generatePresignedUploadUrl({
+          filename: file.name,
+        });
+      await fetch(signedUrl, {
+        method: "PUT",
+        body: file,
+        headers: {
+          "Content-Type": file.type,
+        },
+        mode: "cors",
+      });
+      this.uploadedUrls.set(id, publicUrl);
+      attachment = {
+        ...attachment,
+        status: { type: "requires-action", reason: "composer-send" },
+      };
+      yield attachment;
+    } catch {
+      attachment = {
+        ...attachment,
+        status: { type: "incomplete", reason: "error" },
+      };
+      yield attachment;
+    }
+  }
+
+  public async remove(attachment: Attachment): Promise<void> {
+    this.uploadedUrls.delete(attachment.id);
+  }
+
+  public async send(
+    attachment: PendingAttachment,
+  ): Promise<CompleteAttachment> {
+    const url = this.uploadedUrls.get(attachment.id);
+    if (!url) throw new Error("Attachment not uploaded");
+    this.uploadedUrls.delete(attachment.id);
+
+    let content: ThreadUserMessagePart[];
+    if (attachment.type === "image") {
+      content = [{ type: "image", image: url, filename: attachment.name }];
+    } else {
+      content = [
+        {
+          type: "file",
+          data: url,
+          mimeType: attachment.contentType,
+          filename: attachment.name,
+        },
+      ];
+    }
+
+    return {
+      ...attachment,
+      status: { type: "complete" },
+      content,
+    };
+  }
+}

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

@@ -2,3 +2,4 @@ export type { AttachmentAdapter } from "./AttachmentAdapter";
 export { SimpleImageAttachmentAdapter } from "./SimpleImageAttachmentAdapter";
 export { SimpleTextAttachmentAdapter } from "./SimpleTextAttachmentAdapter";
 export { CompositeAttachmentAdapter } from "./CompositeAttachmentAdapter";
+export { CloudFileAttachmentAdapter } from "./CloudFileAttachmentAdapter";

package/src/runtimes/composer/BaseComposerRuntimeCore.tsx

@@ -23,7 +23,7 @@ export abstract class BaseComposerRuntimeCore
 
   protected abstract getAttachmentAdapter(): AttachmentAdapter | undefined;
 
-  public getAttachmentAccept(): string {
+  public get attachmentAccept(): string {
     return this.getAttachmentAdapter()?.accept ?? "*";
   }
 
@@ -173,7 +173,7 @@ export abstract class BaseComposerRuntimeCore
         ];
       else {
         this._attachments = [...this._attachments, a];
-        this._notifyEventSubscribers("attachment_add");
+        this._notifyEventSubscribers("attachment-add");
       }
 
       this._notifySubscribers();
@@ -188,7 +188,7 @@ export abstract class BaseComposerRuntimeCore
       upsertAttachment(await promiseOrGenerator);
     }
 
-    this._notifyEventSubscribers("attachment_add");
+    this._notifyEventSubscribers("attachment-add");
     this._notifySubscribers();
   }
 

package/src/runtimes/core/BaseThreadRuntimeCore.tsx

@@ -92,7 +92,11 @@ export abstract class BaseThreadRuntimeCore implements ThreadRuntimeCore {
   }
 
   public getMessageById(messageId: string) {
-    return this.repository.getMessage(messageId);
+    try {
+      return this.repository.getMessage(messageId);
+    } catch {
+      return undefined;
+    }
   }
 
   public getBranches(messageId: string): string[] {

package/src/runtimes/core/ComposerRuntimeCore.tsx

@@ -1,7 +1,7 @@
 import type { Attachment, PendingAttachment, Unsubscribe } from "../../types";
 import { MessageRole, RunConfig } from "../../types/AssistantTypes";
 
-export type ComposerRuntimeEventType = "send" | "attachment_add";
+export type ComposerRuntimeEventType = "send" | "attachment-add";
 
 export type ComposerRuntimeCore = Readonly<{
   isEditing: boolean;
@@ -10,8 +10,8 @@ export type ComposerRuntimeCore = Readonly<{
   isEmpty: boolean;
 
   attachments: readonly Attachment[];
+  attachmentAccept: string;
 
-  getAttachmentAccept(): string;
   addAttachment: (file: File) => Promise<void>;
   removeAttachment: (attachmentId: string) => Promise<void>;
 

package/src/runtimes/core/ThreadListRuntimeCore.tsx

@@ -2,10 +2,10 @@ import { Unsubscribe } from "../../types";
 import { ThreadRuntimeCore } from "./ThreadRuntimeCore";
 import type { ThreadListItemStatus } from "../../api/RuntimeBindings";
 
-type ThreadListItemCoreState = {
-  readonly threadId: string;
-  readonly remoteId?: string | undefined;
-  readonly externalId?: string | undefined;
+export type ThreadListItemCoreState = {
+  readonly id: string;
+  readonly remoteId: string | undefined;
+  readonly externalId: string | undefined;
 
   readonly status: ThreadListItemStatus;
   readonly title?: string | undefined;
@@ -21,6 +21,8 @@ export type ThreadListRuntimeCore = {
   threadIds: readonly string[];
   archivedThreadIds: readonly string[];
 
+  readonly threadData: Readonly<Record<string, ThreadListItemCoreState>>;
+
   getMainThreadRuntimeCore(): ThreadRuntimeCore;
   getThreadRuntimeCore(threadId: string): ThreadRuntimeCore;
 

package/src/runtimes/external-store/ExternalStoreAdapter.tsx

@@ -12,7 +12,9 @@ import { ExportedMessageRepository } from "../utils/MessageRepository";
 
 export type ExternalStoreThreadData<TState extends "regular" | "archived"> = {
   status: TState;
-  threadId: string;
+  id: string;
+  remoteId?: string | undefined;
+  externalId?: string | undefined;
   title?: string | undefined;
 };
 
@@ -59,7 +61,8 @@ type ExternalStoreAdapterBase<T> = {
   suggestions?: readonly ThreadSuggestion[] | undefined;
   extras?: unknown;
 
-  setMessages?: ((messages: T[]) => void) | undefined;
+  setMessages?: ((messages: readonly T[]) => void) | undefined;
+  onImport?: ((messages: readonly ThreadMessage[]) => void) | undefined;
   onNew: (message: AppendMessage) => Promise<void>;
   onEdit?: ((message: AppendMessage) => Promise<void>) | undefined;
   onReload?: // TODO: remove parentId in 0.8.0

package/src/runtimes/external-store/ExternalStoreThreadListRuntimeCore.tsx

@@ -1,21 +1,26 @@
 import type { Unsubscribe } from "../../types";
 import { ExternalStoreThreadRuntimeCore } from "./ExternalStoreThreadRuntimeCore";
-import { ThreadListRuntimeCore } from "../core/ThreadListRuntimeCore";
 import {
-  ExternalStoreThreadData,
-  ExternalStoreThreadListAdapter,
-} from "./ExternalStoreAdapter";
+  ThreadListItemCoreState,
+  ThreadListRuntimeCore,
+} from "../core/ThreadListRuntimeCore";
+import { ExternalStoreThreadListAdapter } from "./ExternalStoreAdapter";
 
 export type ExternalStoreThreadFactory = () => ExternalStoreThreadRuntimeCore;
 
 const EMPTY_ARRAY = Object.freeze([]);
 const DEFAULT_THREAD_ID = "DEFAULT_THREAD_ID";
 const DEFAULT_THREADS = Object.freeze([DEFAULT_THREAD_ID]);
-const DEFAULT_THREAD: ExternalStoreThreadData<"regular"> = Object.freeze({
-  threadId: DEFAULT_THREAD_ID,
+const DEFAULT_THREAD = Object.freeze({
+  id: DEFAULT_THREAD_ID,
+  remoteId: undefined,
+  externalId: undefined,
   status: "regular",
 });
 const RESOLVED_PROMISE = Promise.resolve();
+const DEFAULT_THREAD_DATA = Object.freeze({
+  [DEFAULT_THREAD_ID]: DEFAULT_THREAD,
+});
 
 export class ExternalStoreThreadListRuntimeCore
   implements ThreadListRuntimeCore
@@ -23,6 +28,8 @@ export class ExternalStoreThreadListRuntimeCore
   private _mainThreadId: string = DEFAULT_THREAD_ID;
   private _threads: readonly string[] = DEFAULT_THREADS;
   private _archivedThreads: readonly string[] = EMPTY_ARRAY;
+  private _threadData: Readonly<Record<string, ThreadListItemCoreState>> =
+    DEFAULT_THREAD_DATA;
 
   public get isLoading() {
     return this.adapter.isLoading ?? false;
@@ -40,6 +47,10 @@ export class ExternalStoreThreadListRuntimeCore
     return this._archivedThreads;
   }
 
+  public get threadData() {
+    return this._threadData;
+  }
+
   public getLoadThreadsPromise() {
     return RESOLVED_PROMISE;
   }
@@ -55,6 +66,7 @@ export class ExternalStoreThreadListRuntimeCore
     private threadFactory: ExternalStoreThreadFactory,
   ) {
     this._mainThread = this.threadFactory();
+    this.__internal_setAdapter(adapter, true);
   }
 
   public getMainThreadRuntimeCore() {
@@ -67,16 +79,19 @@ export class ExternalStoreThreadListRuntimeCore
 
   public getItemById(threadId: string) {
     for (const thread of this.adapter.threads ?? []) {
-      if (thread.threadId === threadId) return thread;
+      if (thread.id === threadId) return thread as any;
     }
     for (const thread of this.adapter.archivedThreads ?? []) {
-      if (thread.threadId === threadId) return thread;
+      if (thread.id === threadId) return thread as any;
     }
     if (threadId === DEFAULT_THREAD_ID) return DEFAULT_THREAD;
     return undefined;
   }
 
-  public __internal_setAdapter(adapter: ExternalStoreThreadListAdapter) {
+  public __internal_setAdapter(
+    adapter: ExternalStoreThreadListAdapter,
+    initialLoad = false,
+  ) {
     const previousAdapter = this.adapter;
     this.adapter = adapter;
 
@@ -90,6 +105,7 @@ export class ExternalStoreThreadListRuntimeCore
       previousAdapter.archivedThreads ?? EMPTY_ARRAY;
 
     if (
+      !initialLoad &&
       previousThreadId === newThreadId &&
       previousThreads === newThreads &&
       previousArchivedThreads === newArchivedThreads
@@ -97,14 +113,39 @@ export class ExternalStoreThreadListRuntimeCore
       return;
     }
 
+    this._threadData = {
+      ...DEFAULT_THREAD_DATA,
+      ...Object.fromEntries(
+        adapter.threads?.map((t) => [
+          t.id,
+          {
+            ...t,
+            remoteId: t.remoteId,
+            externalId: t.externalId,
+            status: "regular",
+          },
+        ]) ?? [],
+      ),
+      ...Object.fromEntries(
+        adapter.archivedThreads?.map((t) => [
+          t.id,
+          {
+            ...t,
+            remoteId: t.remoteId,
+            externalId: t.externalId,
+            status: "archived",
+          },
+        ]) ?? [],
+      ),
+    };
+
     if (previousThreads !== newThreads) {
-      this._threads =
-        this.adapter.threads?.map((t) => t.threadId) ?? EMPTY_ARRAY;
+      this._threads = this.adapter.threads?.map((t) => t.id) ?? EMPTY_ARRAY;
     }
 
     if (previousArchivedThreads !== newArchivedThreads) {
       this._archivedThreads =
-        this.adapter.archivedThreads?.map((t) => t.threadId) ?? EMPTY_ARRAY;
+        this.adapter.archivedThreads?.map((t) => t.id) ?? EMPTY_ARRAY;
     }
 
     if (previousThreadId !== newThreadId) {

package/src/runtimes/external-store/ExternalStoreThreadRuntimeCore.tsx

@@ -297,6 +297,10 @@ export class ExternalStoreThreadRuntimeCore
     this._assistantOptimisticId = null;
 
     super.import(data);
+
+    if (this._store.onImport) {
+      this._store.onImport(this.repository.getMessages());
+    }
   }
 
   private updateMessages = (messages: readonly ThreadMessage[]) => {