@assistant-ui/core 0.3.2 → 0.3.4

package/src/runtime/api/thread-list-runtime.ts

@@ -31,7 +31,10 @@ export type ThreadListState = {
   readonly isLoadingMore: boolean;
   readonly hasMore: boolean;
   readonly threadItems: Readonly<
-    Record<string, Omit<ThreadListItemState, "isMain" | "threadId">>
+    Record<
+      string,
+      Omit<ThreadListItemState, "isMain" | "threadId" | "isRunning">
+    >
   >;
 };
 
@@ -56,6 +59,18 @@ export type ThreadListRuntime = {
 
   getLoadThreadsPromise(): Promise<void>;
   reload(): Promise<void>;
+  /**
+   * Refetches the open thread's remote state, for state that changed out of
+   * band and so never reached the stream. When the runtime declares the
+   * in-place capability (`unstable_refetchThread`), composer drafts survive,
+   * existing messages stay rendered during the refetch, and the promise
+   * settles with the refetch, rejecting if it fails; that runtime also owns
+   * what happens to a run in progress, since this does not stop one. Runtimes
+   * without the capability have their hook remounted instead, which discards
+   * unsent composer input and ends any run, and the promise resolves once the
+   * new runtime attaches. A thread that has not been sent yet is left alone.
+   */
+  reloadMainThread(): Promise<void>;
   loadMore(): Promise<void>;
 };
 
@@ -91,6 +106,7 @@ const getThreadListItemState = (
     lastMessageAt: threadData.lastMessageAt,
     custom: threadData.custom,
     isMain: threadData.id === threadList.mainThreadId,
+    isRunning: threadList.unstable_isThreadRunning?.(threadData.id) ?? false,
   };
 };
 
@@ -155,6 +171,7 @@ export class ThreadListRuntimeImpl implements ThreadListRuntime {
     this.switchToNewThread = this.switchToNewThread.bind(this);
     this.getLoadThreadsPromise = this.getLoadThreadsPromise.bind(this);
     this.reload = this.reload.bind(this);
+    this.reloadMainThread = this.reloadMainThread.bind(this);
     this.loadMore = this.loadMore.bind(this);
     this.getState = this.getState.bind(this);
     this.subscribe = this.subscribe.bind(this);
@@ -183,6 +200,10 @@ export class ThreadListRuntimeImpl implements ThreadListRuntime {
     return this._core.reload?.() ?? RESOLVED_PROMISE;
   }
 
+  public reloadMainThread(): Promise<void> {
+    return this._core.reloadMainThread?.() ?? RESOLVED_PROMISE;
+  }
+
   public loadMore(): Promise<void> {
     return this._core.loadMore?.() ?? RESOLVED_PROMISE;
   }

package/src/runtime/api/thread-runtime.ts

@@ -193,22 +193,31 @@ export type ThreadState = {
   readonly voice: VoiceSessionState | undefined;
 };
 
+/**
+ * The canonical `isRunning` derivation. A runtime that tracks run state itself
+ * reports it directly; the rest fall back to the trailing assistant message.
+ */
+export const getThreadRuntimeCoreIsRunning = (
+  runtime: ThreadRuntimeCore,
+): boolean => {
+  if (runtime.isRunning !== undefined) return runtime.isRunning;
+  const lastMessage = runtime.messages.at(-1);
+  return (
+    lastMessage?.role === "assistant" && lastMessage.status.type === "running"
+  );
+};
+
 export const getThreadState = (
   runtime: ThreadRuntimeCore,
   threadListItemState: ThreadListItemState,
 ): ThreadState => {
-  const lastMessage = runtime.messages.at(-1);
   return Object.freeze({
     threadId: threadListItemState.id,
     metadata: threadListItemState,
     capabilities: runtime.capabilities,
     isDisabled: runtime.isDisabled,
     isLoading: runtime.isLoading,
-    isRunning:
-      runtime.isRunning ??
-      (lastMessage?.role !== "assistant"
-        ? false
-        : lastMessage.status.type === "running"),
+    isRunning: getThreadRuntimeCoreIsRunning(runtime),
     messages: runtime.messages,
     state: runtime.state,
     suggestions: runtime.suggestions,

package/src/runtime/base/base-composer-runtime-core.ts

@@ -34,6 +34,11 @@ import { notifyEventListeners } from "../../utils/notify-event-listeners";
 const isAttachmentComplete = (a: Attachment): a is CompleteAttachment =>
   a.status.type === "complete";
 
+type AttachmentAddOperation = {
+  cancelled: boolean;
+  attachmentIds: Set<string>;
+};
+
 export abstract class BaseComposerRuntimeCore
   extends BaseSubscribable
   implements ComposerRuntimeCore
@@ -138,6 +143,22 @@ export abstract class BaseComposerRuntimeCore
   protected _isSending = false;
   private _removedDuringSend = new Set<string>();
   private _sendGeneration = 0;
+  private _attachmentAddOperations = new Set<AttachmentAddOperation>();
+
+  private _cancelAttachmentAdd(attachmentId: string) {
+    for (const operation of [...this._attachmentAddOperations]) {
+      if (!operation.attachmentIds.has(attachmentId)) continue;
+      operation.cancelled = true;
+      this._attachmentAddOperations.delete(operation);
+    }
+  }
+
+  private _cancelAllAttachmentAdds() {
+    for (const operation of this._attachmentAddOperations) {
+      operation.cancelled = true;
+    }
+    this._attachmentAddOperations.clear();
+  }
 
   private _emptyTextAndAttachments() {
     this._attachments = [];
@@ -154,6 +175,8 @@ export abstract class BaseComposerRuntimeCore
   }
 
   public async reset() {
+    this._cancelAllAttachmentAdds();
+
     // A send whose adapter never settles must not brick the composer; reset is
     // the escape hatch that releases the in-flight lock. Bumping the generation
     // invalidates that send entirely so a late-settling upload can neither
@@ -182,6 +205,7 @@ export abstract class BaseComposerRuntimeCore
   }
 
   public async clearAttachments() {
+    this._cancelAllAttachmentAdds();
     const task = this._onClearAttachments();
     this.setAttachments([]);
 
@@ -324,23 +348,6 @@ export abstract class BaseComposerRuntimeCore
       return;
     }
 
-    const upsertAttachment = (a: PendingAttachment) => {
-      const idx = this._attachments.findIndex(
-        (attachment) => attachment.id === a.id,
-      );
-      if (idx !== -1)
-        this._attachments = [
-          ...this._attachments.slice(0, idx),
-          a,
-          ...this._attachments.slice(idx + 1),
-        ];
-      else {
-        this._attachments = [...this._attachments, a];
-      }
-
-      this._notifySubscribers();
-    };
-
     const adapter = this.getAttachmentAdapter();
     if (!adapter) {
       const message = "Attachments are not supported";
@@ -361,19 +368,46 @@ export abstract class BaseComposerRuntimeCore
       throw err;
     }
 
+    const operation: AttachmentAddOperation = {
+      cancelled: false,
+      attachmentIds: new Set(),
+    };
+    const operations = this._attachmentAddOperations;
+    operations.add(operation);
+    const upsertAttachment = (a: PendingAttachment) => {
+      if (operation.cancelled) return false;
+
+      operation.attachmentIds.add(a.id);
+      const idx = this._attachments.findIndex(
+        (attachment) => attachment.id === a.id,
+      );
+      if (idx !== -1)
+        this._attachments = [
+          ...this._attachments.slice(0, idx),
+          a,
+          ...this._attachments.slice(idx + 1),
+        ];
+      else {
+        this._attachments = [...this._attachments, a];
+      }
+
+      this._notifySubscribers();
+      return true;
+    };
     let lastAttachment: PendingAttachment | undefined;
     try {
       const promiseOrGenerator = adapter.add({ file: fileOrAttachment });
       if (Symbol.asyncIterator in promiseOrGenerator) {
         for await (const r of promiseOrGenerator) {
           lastAttachment = r;
-          upsertAttachment(r);
+          if (!upsertAttachment(r)) break;
         }
       } else {
         lastAttachment = await promiseOrGenerator;
         upsertAttachment(lastAttachment);
       }
     } catch (e) {
+      if (operation.cancelled) return;
       if (lastAttachment) {
         upsertAttachment({
           ...lastAttachment,
@@ -391,8 +425,11 @@ export abstract class BaseComposerRuntimeCore
         e instanceof Error ? e : undefined,
       );
       throw e;
+    } finally {
+      operations.delete(operation);
     }
 
+    if (operation.cancelled) return;
     if (
       lastAttachment?.status.type === "incomplete" &&
       lastAttachment.status.reason === "error"
@@ -434,6 +471,8 @@ export abstract class BaseComposerRuntimeCore
     if (index === -1) throw new Error("Attachment not found");
     const attachment = this._attachments[index]!;
 
+    this._cancelAttachmentAdd(attachmentId);
+
     // A send in flight may already be uploading this attachment; the upload
     // can't be cancelled, so mark it to be dropped from the outgoing message
     // before any await gives the upload a chance to settle first.
@@ -442,7 +481,21 @@ export abstract class BaseComposerRuntimeCore
     if (!isAttachmentComplete(attachment)) {
       const adapter = this.getAttachmentAdapter();
       if (!adapter) throw new Error("Attachments are not supported");
-      await adapter.remove(attachment);
+      try {
+        await adapter.remove(attachment);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this._attachments = this._attachments.map((candidate) =>
+          candidate.id === attachmentId && !isAttachmentComplete(candidate)
+            ? {
+                ...candidate,
+                status: { type: "incomplete", reason: "error", message },
+              }
+            : candidate,
+        );
+        this._notifySubscribers();
+        throw error;
+      }
     }
     this._attachments = this._attachments.filter((a) => a.id !== attachmentId);
     this._notifySubscribers();

package/src/runtime/interfaces/thread-list-runtime-core.ts

@@ -31,6 +31,16 @@ export type ThreadListRuntimeCore = {
   getMainThreadRuntimeCore(): ThreadRuntimeCore;
   getThreadRuntimeCore(threadId: string): ThreadRuntimeCore;
 
+  /**
+   * Whether the thread currently has a run in progress, including a run on a
+   * thread that is not the main one. Implemented by thread lists that keep
+   * runtimes alive for non-main threads, and they notify their subscribers
+   * whenever the answer changes. A thread list that mounts only the main thread
+   * leaves this undefined: its other threads have no runtime and so cannot be
+   * running, and the main thread's run state is read from its runtime directly.
+   */
+  unstable_isThreadRunning?(threadId: string): boolean;
+
   getItemById(threadId: string): ThreadListItemCoreState | undefined;
 
   switchToThread(
@@ -41,6 +51,7 @@ export type ThreadListRuntimeCore = {
 
   getLoadThreadsPromise(): Promise<void>;
   reload?(): Promise<void>;
+  reloadMainThread?(): Promise<void>;
   loadMore?(): Promise<void>;
 
   detach(threadId: string): Promise<void>;

package/src/runtime/interfaces/thread-runtime-core.ts

@@ -23,6 +23,8 @@ export type RuntimeCapabilities = {
   readonly switchBranchDuringRun: boolean;
   readonly edit: boolean;
   readonly reload: boolean;
+  /** Whether the runtime can refetch this thread's remote state in place. */
+  readonly refetchThread: boolean;
   readonly delete: boolean;
   readonly cancel: boolean;
   readonly unstable_copy: boolean;
@@ -216,6 +218,19 @@ export type ThreadRuntimeCore = Readonly<{
 
   reset(initialMessages?: readonly ThreadMessageLike[]): void;
 
+  /**
+   * Re-fetches this thread's state from its backing store, in place: no
+   * runtime-hook remount, so runtime identity and composer drafts survive.
+   * Presence signals the capability to `threads.reloadMainThread()`, which
+   * calls this and propagates its rejection. It does not touch a run in
+   * progress first, because stopping one is `cancelRun`, whose contract is
+   * that the user abandoned a send: it returns the trailing user message to
+   * the composer. An implementation is therefore responsible for whatever
+   * coordination a concurrent run needs. Runtimes without remote state leave
+   * it undefined.
+   */
+  unstable_refetchThread?: (() => Promise<void>) | undefined;
+
   /**
    * @deprecated This API is still under active development and might change without notice.
    * For state-derivable transitions, prefer `subscribe` + `getState`. This channel is the

package/src/runtimes/external-store/external-store-adapter.ts

@@ -143,6 +143,15 @@ type ExternalStoreAdapterBase<T> = {
     | undefined;
   onResume?: ((config: ResumeRunConfig) => Promise<void>) | undefined;
   onCancel?: (() => Promise<void>) | undefined;
+  /**
+   * Re-fetches the thread's state from the backing store, in place; a
+   * rejection reaches the `threads.reloadMainThread()` caller. Unrelated to
+   * `onReload`, which re-generates an assistant message.
+   *
+   * The caller does not stop a run in progress first, so an adapter that can
+   * stream owns whatever coordination one needs.
+   */
+  onRefetchThread?: (() => Promise<void>) | undefined;
   onAddToolResult?:
     | ((options: AddToolResultOptions) => Promise<void> | void)
     | undefined;

package/src/runtimes/external-store/external-store-thread-list-runtime-core.ts

@@ -169,6 +169,15 @@ export class ExternalStoreThreadListRuntimeCore implements ThreadListRuntimeCore
     this._notifySubscribers();
   }
 
+  public async reloadMainThread(): Promise<void> {
+    // There is no runtime hook to remount here, so the capability is the only
+    // path and an adapter without it has nothing to refetch with.
+    if (!this._mainThread.unstable_refetchThread) return;
+    // No unsent-thread guard: every entry here is regular or archived, so the
+    // "new" status the remote thread list has to exclude cannot occur.
+    await this._mainThread.unstable_refetchThread();
+  }
+
   public async switchToThread(
     threadId: string,
     _options?: { unarchive?: boolean },

package/src/runtimes/external-store/external-store-thread-runtime-core.ts

@@ -65,6 +65,7 @@ export class ExternalStoreThreadRuntimeCore
     edit: false,
     delete: false,
     reload: false,
+    refetchThread: false,
     cancel: false,
     unstable_copy: false,
     speech: false,
@@ -102,6 +103,12 @@ export class ExternalStoreThreadRuntimeCore
     return this._store.adapters;
   }
 
+  // A getter, not a method, so its presence tracks the adapter.
+  public get unstable_refetchThread(): (() => Promise<void>) | undefined {
+    if (!this._store.onRefetchThread) return undefined;
+    return () => this._store.onRefetchThread!();
+  }
+
   public suggestions: readonly ThreadSuggestion[] = [];
   public extras: unknown = undefined;
 
@@ -156,6 +163,7 @@ export class ExternalStoreThreadRuntimeCore
         this._store.onDelete !== undefined ||
         this._store.setMessages !== undefined,
       reload: this._store.onReload !== undefined,
+      refetchThread: this._store.onRefetchThread !== undefined,
       cancel: this._store.onCancel !== undefined,
       speech: this._store.adapters?.speech !== undefined,
       dictation: this._store.adapters?.dictation !== undefined,

package/src/runtimes/local/local-thread-runtime-core.ts

@@ -53,6 +53,7 @@ export class LocalThreadRuntimeCore
     edit: true,
     delete: false,
     reload: true,
+    refetchThread: false,
     cancel: true,
     unstable_copy: true,
     speech: false,

package/src/runtimes/readonly/ReadonlyThreadRuntimeCore.ts

@@ -208,6 +208,7 @@ export class ReadonlyThreadRuntimeCore
     edit: false,
     delete: false,
     reload: false,
+    refetchThread: false,
     cancel: false,
     unstable_copy: false,
     speech: false,

package/src/runtimes/remote-thread-list/empty-thread-core.ts

@@ -189,6 +189,7 @@ export const EMPTY_THREAD_CORE: ThreadRuntimeCore = {
     edit: false,
     delete: false,
     reload: false,
+    refetchThread: false,
     cancel: false,
     unstable_copy: false,
     speech: false,

package/src/store/clients/chain-of-thought-client.ts

@@ -5,12 +5,8 @@ import type {
   ChainOfThoughtState,
   ChainOfThoughtPart,
 } from "../scopes/chain-of-thought";
-import type { MessagePartStatus } from "../../types/message";
 import type { PartMethods } from "../scopes/part";
-
-const COMPLETE_STATUS: MessagePartStatus = Object.freeze({
-  type: "complete",
-});
+import { getGroupStatus } from "../../utils/getGroupStatus";
 
 const useChainOfThoughtClient = ({
   parts,
@@ -22,8 +18,7 @@ const useChainOfThoughtClient = ({
   const [collapsed, setCollapsed] = useState(true);
 
   const status = useMemo(() => {
-    const lastPart = parts[parts.length - 1];
-    return lastPart?.status ?? COMPLETE_STATUS;
+    return getGroupStatus(parts);
   }, [parts]);
 
   const state = useMemo<ChainOfThoughtState>(

package/src/store/clients/thread-message-client.test.ts

@@ -0,0 +1,84 @@
+import { createTapRoot, useResource } from "@assistant-ui/tap";
+import { describe, expect, it } from "vitest";
+import type { ThreadAssistantMessage } from "../../types/message";
+import { ThreadMessageClient } from "./thread-message-client";
+
+describe("ThreadMessageClient", () => {
+  const getPartStatus = (
+    part: ThreadAssistantMessage["content"][number],
+    status: ThreadAssistantMessage["status"],
+  ) => {
+    const message: ThreadAssistantMessage = {
+      id: "message-1",
+      role: "assistant",
+      createdAt: new Date(0),
+      content: [part],
+      status,
+      metadata: {
+        unstable_state: null,
+        unstable_annotations: [],
+        unstable_data: [],
+        steps: [],
+        custom: {},
+      },
+    };
+    const root = createTapRoot(function ThreadMessageRoot() {
+      return useResource(ThreadMessageClient({ message, index: 0 }));
+    });
+
+    try {
+      return root.getValue().getState().parts[0]?.status;
+    } finally {
+      root.unmount();
+    }
+  };
+
+  it("preserves a running part status on a running detached message", () => {
+    const part = {
+      type: "text",
+      text: "done",
+      status: { type: "running" },
+    } as unknown as ThreadAssistantMessage["content"][number];
+
+    expect(getPartStatus(part, { type: "running" })).toEqual({
+      type: "running",
+    });
+  });
+
+  it("normalizes an unknown incomplete reason on a running detached message", () => {
+    const part = {
+      type: "text",
+      text: "done",
+      status: { type: "incomplete", reason: "unknown" },
+    } as unknown as ThreadAssistantMessage["content"][number];
+
+    expect(getPartStatus(part, { type: "running" })).toEqual({
+      type: "incomplete",
+      reason: "other",
+    });
+  });
+
+  it("normalizes an upstream complete reason on a running detached message", () => {
+    const part = {
+      type: "text",
+      text: "done",
+      status: { type: "complete", reason: "unknown" },
+    } as unknown as ThreadAssistantMessage["content"][number];
+
+    expect(getPartStatus(part, { type: "running" })).toEqual({
+      type: "complete",
+    });
+  });
+
+  it("marks parts complete on a non-running detached message", () => {
+    const part = {
+      type: "text",
+      text: "done",
+      status: { type: "running" },
+    } as unknown as ThreadAssistantMessage["content"][number];
+
+    expect(getPartStatus(part, { type: "complete", reason: "stop" })).toEqual({
+      type: "complete",
+    });
+  });
+});

package/src/store/clients/thread-message-client.ts

@@ -11,19 +11,27 @@ import { useClientLookup } from "@assistant-ui/store";
 import type { MessageState } from "../scopes/message";
 import type { PartState } from "../scopes/part";
 import { NoOpComposerClient } from "./no-op-composer-client";
+import {
+  COMPLETE_STATUS,
+  normalizePartStatus,
+} from "../../utils/normalizePartStatus";
 import { getThreadMessageText } from "../../utils/text";
 
 const useThreadMessagePartClient = ({
   part,
+  isMessageRunning,
 }: {
   part: ThreadAssistantMessagePart | ThreadUserMessagePart;
+  isMessageRunning: boolean;
 }): ClientOutput<"part"> => {
   const state = useMemo<PartState>(() => {
     return {
       ...part,
-      status: { type: "complete" },
+      status: isMessageRunning
+        ? (normalizePartStatus(part) ?? COMPLETE_STATUS)
+        : COMPLETE_STATUS,
     };
-  }, [part]);
+  }, [part, isMessageRunning]);
 
   return {
     getState: () => state,
@@ -74,6 +82,8 @@ const useThreadMessageClient = ({
 }: ThreadMessageClientProps): ClientOutput<"message"> => {
   const [isCopiedState, setIsCopied] = useState(false);
   const [isHoveringState, setIsHovering] = useState(false);
+  const isMessageRunning =
+    message.role === "assistant" && message.status.type === "running";
 
   const parts = useClientLookup(
     message.content.map((part, idx) =>
@@ -81,8 +91,8 @@ const useThreadMessageClient = ({
         "toolCallId" in part && part.toolCallId != null
           ? `toolCallId-${part.toolCallId}`
           : `index-${idx}`,
-        ThreadMessagePartClient({ part }),
-        [part],
+        ThreadMessagePartClient({ part, isMessageRunning }),
+        [part, isMessageRunning],
       ),
     ),
   );

package/src/store/runtime-clients/thread-list-item-runtime-client.ts

@@ -1,5 +1,5 @@
 import type { Unsubscribe } from "../../types/unsubscribe";
-import { useEffect } from "react";
+import { useEffect, useMemo } from "react";
 import { resource } from "@assistant-ui/tap";
 import { type ClientOutput, useAssistantEmit } from "@assistant-ui/store";
 import type {
@@ -10,10 +10,21 @@ import { useSubscribable } from "./useSubscribable";
 
 const useThreadListItemClient = ({
   runtime,
+  mainThreadIsRunning = false,
 }: {
   runtime: ThreadListItemRuntime;
+  // A thread list that cannot report per-thread run state still leaves the open
+  // thread observable, and the thread client tracks that reactively. Omitted
+  // where the runtime state is already authoritative for every thread.
+  mainThreadIsRunning?: boolean | undefined;
 }): ClientOutput<"threadListItem"> => {
-  const state = useSubscribable(runtime);
+  const runtimeState = useSubscribable(runtime);
+  const state = useMemo(() => {
+    const isRunning =
+      runtimeState.isRunning || (runtimeState.isMain && mainThreadIsRunning);
+    if (isRunning === runtimeState.isRunning) return runtimeState;
+    return { ...runtimeState, isRunning };
+  }, [runtimeState, mainThreadIsRunning]);
   const emit = useAssistantEmit();
 
   // Bind thread list item events to event manager

package/src/store/runtime-clients/thread-list-runtime-client.ts

@@ -15,9 +15,11 @@ import type { ThreadsState } from "../scopes/threads";
 const useThreadListItemClientById = ({
   runtime,
   id,
+  mainThreadIsRunning,
 }: {
   runtime: ThreadListRuntime;
   id: string;
+  mainThreadIsRunning: boolean;
 }) => {
   const threadListItemRuntime = useMemo(
     () => runtime.getItemById(id),
@@ -26,6 +28,7 @@ const useThreadListItemClientById = ({
   return useResource(
     ThreadListItemClient({
       runtime: threadListItemRuntime,
+      mainThreadIsRunning,
     }),
   );
 };
@@ -48,7 +51,15 @@ const useThreadListClient = ({
   );
   const threadItems = useClientLookup(
     Object.keys(runtimeState.threadItems).map((id) =>
-      withKey(id, ThreadListItemClientById({ runtime, id }), [runtime, id]),
+      withKey(
+        id,
+        ThreadListItemClientById({
+          runtime,
+          id,
+          mainThreadIsRunning: main.state.isRunning,
+        }),
+        [runtime, id, main.state.isRunning],
+      ),
     ),
   );
 
@@ -93,6 +104,7 @@ const useThreadListClient = ({
     },
     getLoadThreadsPromise: () => runtime.getLoadThreadsPromise(),
     reload: () => runtime.reload(),
+    reloadMainThread: () => runtime.reloadMainThread(),
     loadMore: () => runtime.loadMore(),
     __internal_getAssistantRuntime: () => __internal_assistantRuntime,
   };

package/src/store/scopes/thread-list-item.ts

@@ -9,6 +9,13 @@ export type ThreadListItemState = {
   readonly lastMessageAt?: Date | undefined;
   readonly status: ThreadListItemStatus;
   readonly custom?: Record<string, unknown> | undefined;
+  /**
+   * Whether this thread has a run in progress, including a run that continues
+   * after the user switches to another thread. A thread list that mounts only
+   * the open thread has no runtime to run the others, so they read as not
+   * running rather than as unknown.
+   */
+  readonly isRunning: boolean;
 };
 
 export type ThreadListItemMethods = {

package/src/store/scopes/threads.ts

@@ -30,6 +30,7 @@ export type ThreadsMethods = {
   thread(selector: "main"): ThreadMethods;
   getLoadThreadsPromise(): Promise<void>;
   reload(): Promise<void>;
+  reloadMainThread(): Promise<void>;
   loadMore(): Promise<void>;
   __internal_getAssistantRuntime?(): AssistantRuntime;
 };