@assistant-ui/react 0.7.9 → 0.7.10

package/src/api/ThreadListRuntime.ts

@@ -21,6 +21,7 @@ export type ThreadListRuntime = {
 
   subscribe(callback: () => void): Unsubscribe;
 
+  readonly mainThreadListItem: ThreadListItemRuntime;
   getThreadListItemById(threadId: string): ThreadListItemRuntime;
   getThreadListItemByIndex(idx: number): ThreadListItemRuntime;
   getThreadListArchivedItemByIndex(idx: number): ThreadListItemRuntime;
@@ -30,10 +31,10 @@ const getThreadListState = (
   threadList: ThreadListRuntimeCore,
 ): ThreadListState => {
   return {
-    mainThreadId: threadList.mainThread.metadata.threadId,
-    newThread: threadList.newThread,
-    threads: threadList.threads,
-    archivedThreads: threadList.archivedThreads,
+    mainThreadId: threadList.mainThreadId,
+    newThread: threadList.newThreadId,
+    threads: threadList.threadIds,
+    archivedThreads: threadList.archivedThreadIds,
   };
 };
 
@@ -43,13 +44,14 @@ const getThreadListItemState = (
 ): ThreadListItemState | SKIP_UPDATE => {
   if (threadId === undefined) return SKIP_UPDATE;
 
-  const threadData = threadList.getThreadMetadataById(threadId);
+  const threadData = threadList.getItemById(threadId);
   if (!threadData) return SKIP_UPDATE;
   return {
-    threadId: threadData.threadId,
+    id: threadData.threadId,
+    threadId: threadData.threadId, // TODO remove in 0.8.0
     title: threadData.title,
     state: threadData.state,
-    isMain: threadList.mainThread.metadata.threadId === threadId,
+    isMain: threadData.threadId === threadList.mainThreadId,
   };
 };
 
@@ -65,6 +67,20 @@ export class ThreadListRuntimeImpl implements ThreadListRuntime {
     });
 
     this._getState = stateBinding.getState.bind(stateBinding);
+
+    this._mainThreadListItemRuntime = new ThreadListItemRuntimeImpl(
+      new ShallowMemoizeSubject({
+        path: {
+          ref: `threadItems[main]`,
+          threadSelector: { type: "main" },
+        },
+        getState: () => {
+          return getThreadListItemState(this._core, this._core.mainThreadId);
+        },
+        subscribe: (callback) => this._core.subscribe(callback),
+      }),
+      this._core,
+    );
   }
 
   public getState(): ThreadListState {
@@ -75,6 +91,12 @@ export class ThreadListRuntimeImpl implements ThreadListRuntime {
     return this._core.subscribe(callback);
   }
 
+  private _mainThreadListItemRuntime;
+
+  public get mainThreadListItem() {
+    return this._mainThreadListItemRuntime;
+  }
+
   public getThreadListItemByIndex(idx: number) {
     return new ThreadListItemRuntimeImpl(
       new ShallowMemoizeSubject({
@@ -83,7 +105,7 @@ export class ThreadListRuntimeImpl implements ThreadListRuntime {
           threadSelector: { type: "index", index: idx },
         },
         getState: () => {
-          return getThreadListItemState(this._core, this._core.threads[idx]);
+          return getThreadListItemState(this._core, this._core.threadIds[idx]);
         },
         subscribe: (callback) => this._core.subscribe(callback),
       }),
@@ -101,7 +123,7 @@ export class ThreadListRuntimeImpl implements ThreadListRuntime {
         getState: () => {
           return getThreadListItemState(
             this._core,
-            this._core.archivedThreads[idx],
+            this._core.archivedThreadIds[idx],
           );
         },
         subscribe: (callback) => this._core.subscribe(callback),

package/src/api/ThreadRuntime.ts

@@ -4,7 +4,6 @@ import {
   ThreadRuntimeCore,
   SpeechState,
   ThreadRuntimeEventType,
-  ThreadMetadata,
 } from "../runtimes/core/ThreadRuntimeCore";
 import { ExportedMessageRepository } from "../runtimes/utils/MessageRepository";
 import {
@@ -30,7 +29,12 @@ import {
 } from "./ComposerRuntime";
 import { LazyMemoizeSubject } from "./subscribable/LazyMemoizeSubject";
 import { SKIP_UPDATE } from "./subscribable/SKIP_UPDATE";
-import { MessageRuntimePath, ThreadRuntimePath } from "./RuntimePathTypes";
+import {
+  MessageRuntimePath,
+  ThreadListItemRuntimePath,
+  ThreadRuntimePath,
+} from "./RuntimePathTypes";
+import { ThreadListItemState } from "./ThreadListItemRuntime";
 
 export type CreateAppendMessage =
   | string
@@ -74,17 +78,24 @@ export type ThreadRuntimeCoreBinding = SubscribableWithState<
   outerSubscribe(callback: () => void): Unsubscribe;
 };
 
+export type ThreadListItemRuntimeBinding = SubscribableWithState<
+  ThreadListItemState,
+  ThreadListItemRuntimePath
+>;
+
 export type ThreadState = {
   /**
    * The thread ID.
-   * @deprecated This field is deprecated and will be removed in 0.8.0. Use `metadata.threadId` instead.
+   * @deprecated This field is deprecated and will be removed in 0.8.0. Use `useThreadListItem().id` instead.
    */
   readonly threadId: string;
 
   /**
    * The thread metadata.
+   *
+   * @deprecated Use `useThreadListItem()` instead. This field is deprecated and will be removed in 0.8.0.
    */
-  readonly metadata: ThreadMetadata;
+  readonly metadata: ThreadListItemState;
 
   /**
    * Whether the thread is disabled. Disabled threads cannot receive new messages.
@@ -122,11 +133,14 @@ export type ThreadState = {
   readonly speech: SpeechState | undefined;
 };
 
-export const getThreadState = (runtime: ThreadRuntimeCore): ThreadState => {
+export const getThreadState = (
+  runtime: ThreadRuntimeCore,
+  threadListItemState: ThreadListItemState,
+): ThreadState => {
   const lastMessage = runtime.messages.at(-1);
   return Object.freeze({
-    threadId: runtime.metadata.threadId,
-    metadata: runtime.metadata,
+    threadId: threadListItemState.id,
+    metadata: threadListItemState,
     capabilities: runtime.capabilities,
     isDisabled: runtime.isDisabled,
     isRunning:
@@ -208,11 +222,25 @@ export class ThreadRuntimeImpl implements ThreadRuntime {
     getStateState(): ThreadState;
   };
 
-  constructor(threadBinding: ThreadRuntimeCoreBinding) {
+  constructor(
+    threadBinding: ThreadRuntimeCoreBinding,
+    threadListItemBinding: ThreadListItemRuntimeBinding,
+  ) {
     const stateBinding = new LazyMemoizeSubject({
       path: threadBinding.path,
-      getState: () => getThreadState(threadBinding.getState()),
-      subscribe: (callback) => threadBinding.subscribe(callback),
+      getState: () =>
+        getThreadState(
+          threadBinding.getState(),
+          threadListItemBinding.getState(),
+        ),
+      subscribe: (callback) => {
+        const sub1 = threadBinding.subscribe(callback);
+        const sub2 = threadListItemBinding.subscribe(callback);
+        return () => {
+          sub1();
+          sub2();
+        };
+      },
     });
 
     this._threadBinding = {

package/src/context/providers/AssistantRuntimeProvider.tsx

@@ -61,7 +61,10 @@ export const AssistantRuntimeProviderImpl: FC<
 
   return (
     <AssistantContext.Provider value={context}>
-      <ThreadRuntimeProvider runtime={runtime.thread}>
+      <ThreadRuntimeProvider
+        runtime={runtime.thread}
+        listItemRuntime={runtime.threadList.mainThreadListItem}
+      >
         {children}
       </ThreadRuntimeProvider>
     </AssistantContext.Provider>

package/src/context/providers/ThreadRuntimeProvider.tsx

@@ -7,8 +7,11 @@ import { writableStore } from "../ReadonlyStore";
 import { ThreadRuntime } from "../../api/ThreadRuntime";
 import { create } from "zustand";
 import { ThreadComposerRuntime } from "../../api/ComposerRuntime";
+import { ThreadListItemRuntime } from "../../api/ThreadListItemRuntime";
+import { ThreadListItemRuntimeProvider } from "./ThreadListItemRuntimeProvider";
 
 type ThreadProviderProps = {
+  listItemRuntime: ThreadListItemRuntime;
   runtime: ThreadRuntime;
 };
 
@@ -49,7 +52,7 @@ const useThreadComposerStore = (runtime: ThreadComposerRuntime) => {
 
 export const ThreadRuntimeProvider: FC<
   PropsWithChildren<ThreadProviderProps>
-> = ({ children, runtime }) => {
+> = ({ children, listItemRuntime: threadListItemRuntime, runtime }) => {
   const useThreadRuntime = useThreadRuntimeStore(runtime);
   const useThread = useThreadStore(runtime);
   const useThreadComposer = useThreadComposerStore(runtime.composer);
@@ -66,6 +69,10 @@ export const ThreadRuntimeProvider: FC<
   }, [useThread, useThreadRuntime, useThreadComposer]);
 
   return (
-    <ThreadContext.Provider value={context}>{children}</ThreadContext.Provider>
+    <ThreadListItemRuntimeProvider runtime={threadListItemRuntime}>
+      <ThreadContext.Provider value={context}>
+        {children}
+      </ThreadContext.Provider>
+    </ThreadListItemRuntimeProvider>
   );
 };

package/src/internal.ts

@@ -10,7 +10,7 @@ export { AssistantRuntimeImpl } from "./api/AssistantRuntime";
 export {
   ThreadRuntimeImpl,
   type ThreadRuntimeCoreBinding,
+  type ThreadListItemRuntimeBinding,
 } from "./api/ThreadRuntime";
-export { LocalThreadMetadataRuntimeCore } from "./runtimes/local/LocalThreadMetadataRuntimeCore";
 
 export * from "./utils/smooth";

package/src/primitives/composer/ComposerInput.tsx

@@ -20,6 +20,7 @@ import {
 import { useThread, useThreadRuntime } from "../../context/react/ThreadContext";
 import { useEscapeKeydown } from "@radix-ui/react-use-escape-keydown";
 import { useOnScrollToBottom } from "../../utils/hooks/useOnScrollToBottom";
+import { useThreadListItemRuntime } from "../../context/react/ThreadListItemContext";
 
 export namespace ComposerPrimitiveInput {
   export type Element = HTMLTextAreaElement;
@@ -53,6 +54,7 @@ export const ComposerPrimitiveInput = forwardRef<
     },
     forwardedRef,
   ) => {
+    const threadListItemRuntime = useThreadListItemRuntime();
     const threadRuntime = useThreadRuntime();
     const composerRuntime = useComposerRuntime();
 
@@ -124,7 +126,7 @@ export const ComposerPrimitiveInput = forwardRef<
       if (composerRuntime.type !== "thread" || !unstable_focusOnThreadSwitched)
         return undefined;
 
-      return threadRuntime.unstable_on("switched-to", focus);
+      return threadListItemRuntime.unstable_on("switched-to", focus);
     }, [unstable_focusOnThreadSwitched]);
 
     return (

package/src/runtimes/core/BaseThreadRuntimeCore.tsx

@@ -17,7 +17,6 @@ import {
   RuntimeCapabilities,
   SubmittedFeedback,
   ThreadRuntimeEventType,
-  ThreadMetadataRuntimeCore,
 } from "../core/ThreadRuntimeCore";
 import { DefaultEditComposerRuntimeCore } from "../composer/DefaultEditComposerRuntimeCore";
 import { SpeechSynthesisAdapter } from "../speech/SpeechAdapterTypes";
@@ -46,20 +45,13 @@ export abstract class BaseThreadRuntimeCore implements ThreadRuntimeCore {
   public abstract addToolResult(options: AddToolResultOptions): void;
   public abstract cancelRun(): void;
 
-  public get metadata() {
-    return this._metadata;
-  }
-
   public get messages() {
     return this.repository.getMessages();
   }
 
   public readonly composer = new DefaultThreadComposerRuntimeCore(this);
 
-  constructor(
-    private readonly _configProvider: ModelConfigProvider,
-    private readonly _metadata: ThreadMetadataRuntimeCore,
-  ) {}
+  constructor(private readonly _configProvider: ModelConfigProvider) {}
 
   public getModelConfig() {
     return this._configProvider.getModelConfig();

package/src/runtimes/core/ThreadListRuntimeCore.tsx

@@ -1,21 +1,30 @@
 import { Unsubscribe } from "../../types";
-import { ThreadMetadata, ThreadRuntimeCore } from "./ThreadRuntimeCore";
+import { ThreadRuntimeCore } from "./ThreadRuntimeCore";
+
+type ThreadListItemCoreState = {
+  readonly threadId: string;
+  readonly state: "archived" | "regular" | "new" | "deleted";
+  readonly title?: string | undefined;
+
+  readonly runtime?: ThreadRuntimeCore | undefined;
+};
 
 export type ThreadListRuntimeCore = {
-  mainThread: ThreadRuntimeCore;
+  mainThreadId: string;
+  newThreadId: string | undefined;
 
-  newThread: string | undefined;
-  threads: readonly string[];
-  archivedThreads: readonly string[];
+  threadIds: readonly string[];
+  archivedThreadIds: readonly string[];
 
-  getThreadMetadataById(threadId: string): ThreadMetadata | undefined;
+  getMainThreadRuntimeCore(): ThreadRuntimeCore;
+  getItemById(threadId: string): ThreadListItemCoreState | undefined;
 
   switchToThread(threadId: string): Promise<void>;
   switchToNewThread(): Promise<void>;
 
   // getLoadThreadsPromise(): Promise<void>;
   // getLoadArchivedThreadsPromise(): Promise<void>;
-  // create(): Promise<ThreadMetadata>;
+
   rename(threadId: string, newTitle: string): Promise<void>;
   archive(threadId: string): Promise<void>;
   unarchive(threadId: string): Promise<void>;

package/src/runtimes/core/ThreadRuntimeCore.tsx

@@ -43,30 +43,12 @@ export type SubmittedFeedback = {
   readonly type: "negative" | "positive";
 };
 
-export type ThreadMetadata = Readonly<{
-  readonly threadId: string;
-  readonly state: "archived" | "regular" | "new" | "deleted";
-  readonly title?: string | undefined;
-}>;
-
 export type ThreadRuntimeEventType =
-  | "switched-to"
-  | "switched-away"
   | "run-start"
+  | "initialize"
   | "model-config-update";
 
-export type ThreadMetadataRuntimeCore = ThreadMetadata & {
-  create(title?: string): Promise<void>;
-  rename(newTitle: string): Promise<void>;
-  archive(): Promise<void>;
-  unarchive(): Promise<void>;
-  delete(): Promise<void>;
-  subscribe(callback: () => void): Unsubscribe;
-};
-
 export type ThreadRuntimeCore = Readonly<{
-  metadata: ThreadMetadataRuntimeCore;
-
   getMessageById: (messageId: string) =>
     | {
         parentId: string | null;

package/src/runtimes/core/index.ts

@@ -2,5 +2,4 @@ export type {
   AddToolResultOptions,
   SubmitFeedbackOptions,
   ThreadSuggestion,
-  ThreadMetadataRuntimeCore,
 } from "./ThreadRuntimeCore";

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

@@ -2,18 +2,32 @@ import { AppendMessage, ThreadMessage } from "../../types";
 import { AttachmentAdapter } from "../attachment";
 import {
   AddToolResultOptions,
-  ThreadMetadata,
   ThreadSuggestion,
 } from "../core/ThreadRuntimeCore";
 import { FeedbackAdapter } from "../feedback/FeedbackAdapter";
 import { SpeechSynthesisAdapter } from "../speech/SpeechAdapterTypes";
 import { ThreadMessageLike } from "./ThreadMessageLike";
 
+export type ExternalStoreThreadData<TState extends "regular" | "archived"> = {
+  state: TState;
+  threadId: string;
+  title?: string | undefined;
+};
+
 export type ExternalStoreThreadListAdapter = {
+  /**
+   * @deprecated This API is still under active development and might change without notice.
+   */
   threadId?: string | undefined;
-  threads?: readonly ThreadMetadata[] | undefined;
-  archivedThreads?: readonly ThreadMetadata[] | undefined;
+  threads?: readonly ExternalStoreThreadData<"regular">[] | undefined;
+  archivedThreads?: readonly ExternalStoreThreadData<"archived">[] | undefined;
+  /**
+   * @deprecated This API is still under active development and might change without notice.
+   */
   onSwitchToNewThread?: (() => Promise<void> | void) | undefined;
+  /**
+   * @deprecated This API is still under active development and might change without notice.
+   */
   onSwitchToThread?: ((threadId: string) => Promise<void> | void) | undefined;
   onRename?: (
     threadId: string,
@@ -54,6 +68,9 @@ type ExternalStoreAdapterBase<T> = {
         attachments?: AttachmentAdapter | undefined;
         speech?: SpeechSynthesisAdapter | undefined;
         feedback?: FeedbackAdapter | undefined;
+        /**
+         * @deprecated This API is still under active development and might change without notice.
+         */
         threadList?: ExternalStoreThreadListAdapter | undefined;
       }
     | undefined;

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

@@ -12,25 +12,18 @@ const getThreadListAdapter = (store: ExternalStoreAdapter<any>) => {
 export class ExternalStoreRuntimeCore extends BaseAssistantRuntimeCore {
   public readonly threadList;
 
-  private _store: ExternalStoreAdapter<any>;
-
   constructor(store: ExternalStoreAdapter<any>) {
     super();
-    this._store = store;
     this.threadList = new ExternalStoreThreadListRuntimeCore(
       getThreadListAdapter(store),
-      (threadId) =>
-        new ExternalStoreThreadRuntimeCore(
-          this._proxyConfigProvider,
-          threadId,
-          this._store,
-        ),
+      () =>
+        new ExternalStoreThreadRuntimeCore(this._proxyConfigProvider, store),
     );
   }
 
   public setStore(store: ExternalStoreAdapter<any>) {
-    this._store = store;
-    this.threadList.setAdapter(getThreadListAdapter(store));
-    this.threadList.mainThread.setStore(store);
+    // Update the thread list adapter and propagate store changes to the main thread
+    this.threadList.__internal_setAdapter(getThreadListAdapter(store));
+    this.threadList.getMainThreadRuntimeCore().__internal_setStore(store);
   }
 }

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

@@ -3,9 +3,7 @@ import { ExternalStoreThreadRuntimeCore } from "./ExternalStoreThreadRuntimeCore
 import { ThreadListRuntimeCore } from "../core/ThreadListRuntimeCore";
 import { ExternalStoreThreadListAdapter } from "./ExternalStoreAdapter";
 
-export type ExternalStoreThreadFactory = (
-  threadId: string,
-) => ExternalStoreThreadRuntimeCore;
+export type ExternalStoreThreadFactory = () => ExternalStoreThreadRuntimeCore;
 
 const EMPTY_ARRAY = Object.freeze([]);
 const DEFAULT_THREAD_ID = "DEFAULT_THREAD_ID";
@@ -13,35 +11,40 @@ const DEFAULT_THREAD_ID = "DEFAULT_THREAD_ID";
 export class ExternalStoreThreadListRuntimeCore
   implements ThreadListRuntimeCore
 {
-  private _threads: readonly string[] = [];
-  private _archivedThreads: readonly string[] = [];
+  private _mainThreadId: string = DEFAULT_THREAD_ID;
+  private _threads: readonly string[] = EMPTY_ARRAY;
+  private _archivedThreads: readonly string[] = EMPTY_ARRAY;
 
-  public get newThread() {
+  public get newThreadId() {
     return undefined;
   }
 
-  public get threads() {
+  public get threadIds() {
     return this._threads;
   }
 
-  public get archivedThreads() {
+  public get archivedThreadIds() {
     return this._archivedThreads;
   }
 
   private _mainThread: ExternalStoreThreadRuntimeCore;
 
-  public get mainThread() {
-    return this._mainThread;
+  public get mainThreadId() {
+    return this._mainThreadId;
   }
 
   constructor(
     private adapter: ExternalStoreThreadListAdapter = {},
     private threadFactory: ExternalStoreThreadFactory,
   ) {
-    this._mainThread = this.threadFactory(DEFAULT_THREAD_ID);
+    this._mainThread = this.threadFactory();
+  }
+
+  public getMainThreadRuntimeCore() {
+    return this._mainThread;
   }
 
-  public getThreadMetadataById(threadId: string) {
+  public getItemById(threadId: string) {
     for (const thread of this.adapter.threads ?? []) {
       if (thread.threadId === threadId) return thread;
     }
@@ -51,7 +54,7 @@ export class ExternalStoreThreadListRuntimeCore
     return undefined;
   }
 
-  public setAdapter(adapter: ExternalStoreThreadListAdapter) {
+  public __internal_setAdapter(adapter: ExternalStoreThreadListAdapter) {
     const previousAdapter = this.adapter;
     this.adapter = adapter;
 
@@ -72,42 +75,26 @@ export class ExternalStoreThreadListRuntimeCore
       return;
     }
 
-    if (previousAdapter.threads !== newThreads) {
+    if (previousThreads !== newThreads) {
       this._threads =
         this.adapter.threads?.map((t) => t.threadId) ?? EMPTY_ARRAY;
     }
 
-    if (previousAdapter.archivedThreads !== newArchivedThreads) {
+    if (previousArchivedThreads !== newArchivedThreads) {
       this._archivedThreads =
         this.adapter.archivedThreads?.map((t) => t.threadId) ?? EMPTY_ARRAY;
     }
 
-    if (previousAdapter.threadId !== newThreadId) {
-      this._mainThread._notifyEventSubscribers("switched-away");
-      this._mainThread = this.threadFactory(newThreadId);
-      this._mainThread._notifyEventSubscribers("switched-to");
-    }
-
-    const previousMainState = this._mainThread.metadata.state;
-    const mainState = this.archivedThreads.includes(
-      this._mainThread.metadata.threadId,
-    )
-      ? "archived"
-      : "regular";
-
-    if (previousMainState !== mainState) {
-      if (mainState === "archived") {
-        this._mainThread.metadata.archive();
-      } else {
-        this._mainThread.metadata.unarchive();
-      }
+    if (previousThreadId !== newThreadId) {
+      this._mainThreadId = newThreadId;
+      this._mainThread = this.threadFactory();
     }
 
     this._notifySubscribers();
   }
 
   public async switchToThread(threadId: string): Promise<void> {
-    if (this._mainThread?.metadata.threadId === threadId) return;
+    if (this._mainThreadId === threadId) return;
     const onSwitchToThread = this.adapter.onSwitchToThread;
     if (!onSwitchToThread)
       throw new Error(

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

@@ -18,7 +18,6 @@ import {
   ThreadRuntimeCore,
 } from "../core/ThreadRuntimeCore";
 import { BaseThreadRuntimeCore } from "../core/BaseThreadRuntimeCore";
-import { LocalThreadMetadataRuntimeCore } from "../local/LocalThreadMetadataRuntimeCore";
 
 const EMPTY_ARRAY = Object.freeze([]);
 
@@ -77,16 +76,13 @@ export class ExternalStoreThreadRuntimeCore
 
   constructor(
     configProvider: ModelConfigProvider,
-    threadId: string,
     store: ExternalStoreAdapter<any>,
   ) {
-    const metadata = new LocalThreadMetadataRuntimeCore(threadId);
-    metadata.create();
-    super(configProvider, metadata);
-    this.setStore(store);
+    super(configProvider);
+    this.__internal_setStore(store);
   }
 
-  public setStore(store: ExternalStoreAdapter<any>) {
+  public __internal_setStore(store: ExternalStoreAdapter<any>) {
     if (this._store === store) return;
 
     const isRunning = store.isRunning ?? false;

package/src/runtimes/local/LocalRuntimeCore.tsx

@@ -31,10 +31,9 @@ export class LocalRuntimeCore extends BaseAssistantRuntimeCore {
 
     this._options = options;
 
-    this.threadList = new LocalThreadListRuntimeCore((threadId, data) => {
+    this.threadList = new LocalThreadListRuntimeCore((data) => {
       const thread = new LocalThreadRuntimeCore(
         this._proxyConfigProvider,
-        threadId,
         this._options,
       );
       thread.import(data);
@@ -42,18 +41,12 @@ export class LocalRuntimeCore extends BaseAssistantRuntimeCore {
     });
 
     if (initialMessages) {
-      this.threadList.mainThread.import(
-        getExportFromInitialMessages(initialMessages),
-      );
+      this.threadList
+        .getMainThreadRuntimeCore()
+        .import(getExportFromInitialMessages(initialMessages));
     }
   }
 
-  public setOptions(options: LocalRuntimeOptionsBase) {
-    this._options = options;
-
-    this.threadList.mainThread.setOptions(options);
-  }
-
   public reset({
     initialMessages,
   }: {
@@ -62,8 +55,8 @@ export class LocalRuntimeCore extends BaseAssistantRuntimeCore {
     this.threadList.switchToNewThread();
     if (!initialMessages) return;
 
-    this.threadList.mainThread.import(
-      getExportFromInitialMessages(initialMessages),
-    );
+    this.threadList
+      .getMainThreadRuntimeCore()
+      .import(getExportFromInitialMessages(initialMessages));
   }
 }