@assistant-ui/react 0.5.98 → 0.5.99

package/src/context/providers/TextContentPartProvider.tsx

@@ -14,10 +14,12 @@ import {
   ContentPartState,
 } from "../../api/ContentPartRuntime";
 
-type TextContentPartProviderProps = {
-  text: string;
-  isRunning?: boolean | undefined;
-};
+export namespace TextContentPartProvider {
+  export type Props = PropsWithChildren<{
+    text: string;
+    isRunning?: boolean | undefined;
+  }>;
+}
 
 const COMPLETE_STATUS: ContentPartStatus = {
   type: "complete",
@@ -27,9 +29,11 @@ const RUNNING_STATUS: ContentPartStatus = {
   type: "running",
 };
 
-export const TextContentPartProvider: FC<
-  PropsWithChildren<TextContentPartProviderProps>
-> = ({ children, text, isRunning }) => {
+export const TextContentPartProvider: FC<TextContentPartProvider.Props> = ({
+  children,
+  text,
+  isRunning,
+}) => {
   const [context] = useState<ContentPartContextValue>(() => {
     const useContentPartRuntime = create(
       // TODO

package/src/context/providers/ThreadListItemRuntimeProvider.tsx

@@ -0,0 +1,54 @@
+"use client";
+
+import { type FC, type PropsWithChildren, useEffect, useState } from "react";
+import { create } from "zustand";
+import {
+  ThreadListItemContext,
+  type ThreadListItemContextValue,
+} from "../react/ThreadListItemContext";
+import { writableStore } from "../ReadonlyStore";
+import { ThreadListItemRuntime } from "../../api/ThreadListItemRuntime";
+
+export namespace ThreadListItemRuntimeProvider {
+  export type Props = PropsWithChildren<{
+    runtime: ThreadListItemRuntime;
+  }>;
+}
+
+const useThreadListItemRuntimeStore = (runtime: ThreadListItemRuntime) => {
+  const [store] = useState(() => create(() => runtime));
+
+  useEffect(() => {
+    writableStore(store).setState(runtime, true);
+  }, [runtime, store]);
+
+  return store;
+};
+
+export const useThreadListItemStore = (runtime: ThreadListItemRuntime) => {
+  const [store] = useState(() => create(() => runtime.getState()));
+  useEffect(() => {
+    const updateState = () =>
+      writableStore(store).setState(runtime.getState(), true);
+    updateState();
+    return runtime.subscribe(updateState);
+  }, [runtime, store]);
+
+  return store;
+};
+
+export const ThreadListItemRuntimeProvider: FC<
+  ThreadListItemRuntimeProvider.Props
+> = ({ runtime, children }) => {
+  const useThreadListItemRuntime = useThreadListItemRuntimeStore(runtime);
+  const useThreadListItem = useThreadListItemStore(runtime);
+  const [context] = useState<ThreadListItemContextValue>(() => {
+    return { useThreadListItemRuntime, useThreadListItem };
+  });
+
+  return (
+    <ThreadListItemContext.Provider value={context}>
+      {children}
+    </ThreadListItemContext.Provider>
+  );
+};

package/src/context/react/AssistantContext.ts

@@ -7,12 +7,12 @@ import { createContextHook } from "./utils/createContextHook";
 import { createContextStoreHook } from "./utils/createContextStoreHook";
 import { UseBoundStore } from "zustand";
 import { AssistantRuntime } from "../../api/AssistantRuntime";
-import { ThreadManagerState } from "../../api/ThreadManagerRuntime";
+import { ThreadListState } from "../../api/ThreadListRuntime";
 
 export type AssistantContextValue = {
   useToolUIs: UseBoundStore<ReadonlyStore<AssistantToolUIsState>>;
   useAssistantRuntime: UseBoundStore<ReadonlyStore<AssistantRuntime>>;
-  useThreadManager: UseBoundStore<ReadonlyStore<ThreadManagerState>>;
+  useThreadList: UseBoundStore<ReadonlyStore<ThreadListState>>;
 
   /**
    * @deprecated Use `useAssistantRuntime` instead. This will be removed in 0.6.0.
@@ -68,7 +68,7 @@ export const { useToolUIs, useToolUIsStore } = createContextStoreHook(
   "useToolUIs",
 );
 
-export const { useThreadManager } = createContextStoreHook(
+export const { useThreadList } = createContextStoreHook(
   useAssistantContext,
-  "useThreadManager",
+  "useThreadList",
 );

package/src/context/react/ThreadListItemContext.ts

@@ -0,0 +1,39 @@
+"use client";
+
+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";
+
+export type ThreadListItemContextValue = {
+  useThreadListItemRuntime: UseBoundStore<ReadonlyStore<ThreadListItemRuntime>>;
+  useThreadListItem: UseBoundStore<ReadonlyStore<ThreadListItemState>>;
+};
+
+export const ThreadListItemContext =
+  createContext<ThreadListItemContextValue | null>(null);
+
+export const useThreadListItemContext = createContextHook(
+  ThreadListItemContext,
+  "a component passed to <ThreadListPrimitive.Items components={...}>",
+);
+
+export function useThreadListItemRuntime(options?: {
+  optional?: false | undefined;
+}): ThreadListItemRuntime;
+export function useThreadListItemRuntime(options?: {
+  optional?: boolean | undefined;
+}): ThreadListItemRuntime | null;
+export function useThreadListItemRuntime(options?: {
+  optional?: boolean | undefined;
+}) {
+  const context = useThreadListItemContext(options);
+  if (!context) return null;
+  return context.useThreadListItemRuntime();
+}
+
+export const { useThreadListItem, useThreadListItemStore } =
+  createContextStoreHook(useThreadListItemContext, "useThreadListItem");

package/src/context/react/index.ts

@@ -1,6 +1,6 @@
 export {
   useAssistantRuntime,
-  useThreadManager,
+  useThreadList,
   useToolUIs,
   useToolUIsStore,
 
@@ -150,7 +150,7 @@ export {
   useAttachment,
   useAttachmentRuntime,
 
-  // TODO decide if we want to export/drop these? 
+  // TODO decide if we want to export/drop these?
   // useEditComposerAttachment,
   // useEditComposerAttachmentRuntime,
   // useMessageAttachment,

package/src/internal.ts

@@ -1,5 +1,5 @@
 export type { ThreadRuntimeCore } from "./runtimes/core/ThreadRuntimeCore";
-export type { ThreadManagerRuntimeCore } from "./runtimes/core/ThreadManagerRuntimeCore";
+export type { ThreadListRuntimeCore } from "./runtimes/core/ThreadListRuntimeCore";
 export { DefaultThreadComposerRuntimeCore } from "./runtimes/composer/DefaultThreadComposerRuntimeCore";
 export { ProxyConfigProvider } from "./utils/ProxyConfigProvider";
 export { MessageRepository } from "./runtimes/utils/MessageRepository";

package/src/primitives/index.ts

@@ -6,6 +6,8 @@ export * as ComposerPrimitive from "./composer";
 export * as ContentPartPrimitive from "./contentPart";
 export * as MessagePrimitive from "./message";
 export * as ThreadPrimitive from "./thread";
+export * as ThreadListPrimitive from "./threadList";
+export * as ThreadListItemPrimitive from "./threadListItem";
 
 export type * from "./actionBar/types";
 export type * from "./assistantModal/types";

package/src/primitives/threadList/ThreadListItems.tsx

@@ -0,0 +1,73 @@
+"use client";
+
+import { ComponentType, FC, memo, useMemo } from "react";
+import { ThreadListItemRuntimeProvider } from "../../context/providers/ThreadListItemRuntimeProvider";
+import { useAssistantRuntime, useThreadList } from "../../context";
+
+export namespace MessagePrimitiveContent {
+  export type Props = {
+    archived?: boolean | undefined;
+    components: {
+      ThreadListItem: ComponentType;
+    };
+  };
+}
+
+type ThreadListItemProps = {
+  partIndex: number;
+  archived: boolean;
+  components: MessagePrimitiveContent.Props["components"];
+};
+
+const ThreadListItemImpl: FC<ThreadListItemProps> = ({
+  partIndex,
+  archived,
+  components,
+}) => {
+  const assistantRuntime = useAssistantRuntime();
+  const runtime = useMemo(
+    () =>
+      archived
+        ? assistantRuntime.threadList.getThreadListArchivedItemByIndex(
+            partIndex,
+          )
+        : assistantRuntime.threadList.getThreadListItemByIndex(partIndex),
+    [assistantRuntime, partIndex],
+  );
+
+  const ThreadListItemComponent = components.ThreadListItem;
+
+  return (
+    <ThreadListItemRuntimeProvider runtime={runtime}>
+      <ThreadListItemComponent />
+    </ThreadListItemRuntimeProvider>
+  );
+};
+
+const ThreadListItem = memo(
+  ThreadListItemImpl,
+  (prev, next) =>
+    prev.partIndex === next.partIndex &&
+    prev.archived === next.archived &&
+    prev.components.ThreadListItem === next.components.ThreadListItem,
+);
+
+export const ThreadListPrimitiveItems: FC<MessagePrimitiveContent.Props> = ({
+  archived = false,
+  components,
+}) => {
+  const contentLength = useThreadList((s) =>
+    archived ? s.archivedThreads.length : s.threads.length,
+  );
+
+  return Array.from({ length: contentLength }, (_, index) => (
+    <ThreadListItem
+      key={index}
+      partIndex={index}
+      archived={archived}
+      components={components}
+    />
+  ));
+};
+
+ThreadListPrimitiveItems.displayName = "ThreadListPrimitive.Items";

package/src/primitives/threadList/ThreadListNew.ts

@@ -0,0 +1,25 @@
+"use client";
+
+import {
+  ActionButtonElement,
+  ActionButtonProps,
+  createActionButton,
+} from "../../utils/createActionButton";
+import { useAssistantRuntime } from "../../context";
+
+const useThreadListNew = () => {
+  const runtime = useAssistantRuntime();
+  return () => {
+    runtime.switchToNewThread();
+  };
+};
+
+export namespace ThreadListPrimitiveNew {
+  export type Element = ActionButtonElement;
+  export type Props = ActionButtonProps<typeof useThreadListNew>;
+}
+
+export const ThreadListPrimitiveNew = createActionButton(
+  "ThreadListPrimitive.New",
+  useThreadListNew,
+);

package/src/primitives/threadList/index.ts

@@ -0,0 +1,2 @@
+export { ThreadListPrimitiveNew as New } from "./ThreadListNew";
+export { ThreadListPrimitiveItems as Items } from "./ThreadListItems";

package/src/primitives/threadListItem/ThreadListItemArchive.ts

@@ -0,0 +1,25 @@
+"use client";
+
+import {
+  ActionButtonElement,
+  ActionButtonProps,
+  createActionButton,
+} from "../../utils/createActionButton";
+import { useThreadListItemRuntime } from "../../context/react/ThreadListItemContext";
+
+const useThreadListItemArchive = () => {
+  const runtime = useThreadListItemRuntime();
+  return () => {
+    runtime.archive();
+  };
+};
+
+export namespace ThreadListItemPrimitiveArchive {
+  export type Element = ActionButtonElement;
+  export type Props = ActionButtonProps<typeof useThreadListItemArchive>;
+}
+
+export const ThreadListItemPrimitiveArchive = createActionButton(
+  "ThreadListItemPrimitive.Archive",
+  useThreadListItemArchive,
+);

package/src/primitives/threadListItem/ThreadListItemDelete.ts

@@ -0,0 +1,25 @@
+"use client";
+
+import {
+  ActionButtonElement,
+  ActionButtonProps,
+  createActionButton,
+} from "../../utils/createActionButton";
+import { useThreadListItemRuntime } from "../../context/react/ThreadListItemContext";
+
+const useThreadListItemDelete = () => {
+  const runtime = useThreadListItemRuntime();
+  return () => {
+    runtime.delete();
+  };
+};
+
+export namespace ThreadListItemPrimitiveDelete {
+  export type Element = ActionButtonElement;
+  export type Props = ActionButtonProps<typeof useThreadListItemDelete>;
+}
+
+export const ThreadListItemPrimitiveDelete = createActionButton(
+  "ThreadListItemPrimitive.Delete",
+  useThreadListItemDelete,
+);

package/src/primitives/threadListItem/ThreadListItemUnarchive.ts

@@ -0,0 +1,25 @@
+"use client";
+
+import {
+  ActionButtonElement,
+  ActionButtonProps,
+  createActionButton,
+} from "../../utils/createActionButton";
+import { useThreadListItemRuntime } from "../../context/react/ThreadListItemContext";
+
+const useThreadListItemUnarchive = () => {
+  const runtime = useThreadListItemRuntime();
+  return () => {
+    runtime.unarchive();
+  };
+};
+
+export namespace ThreadListItemPrimitiveUnarchive {
+  export type Element = ActionButtonElement;
+  export type Props = ActionButtonProps<typeof useThreadListItemUnarchive>;
+}
+
+export const ThreadListItemPrimitiveUnarchive = createActionButton(
+  "ThreadListItemPrimitive.Unarchive",
+  useThreadListItemUnarchive,
+);

package/src/primitives/threadListItem/index.ts

@@ -0,0 +1,3 @@
+export { ThreadListItemPrimitiveArchive as Archive } from "./ThreadListItemArchive";
+export { ThreadListItemPrimitiveUnarchive as Unarchive } from "./ThreadListItemUnarchive";
+export { ThreadListItemPrimitiveDelete as Delete } from "./ThreadListItemDelete";

package/src/runtimes/composer/BaseComposerRuntimeCore.tsx

@@ -6,6 +6,7 @@ import {
 import { AppendMessage, Unsubscribe } from "../../types";
 import { AttachmentAdapter } from "../attachment";
 import { ComposerRuntimeCore } from "../core/ComposerRuntimeCore";
+import { MessageRole } from "../../types/AssistantTypes";
 
 const isAttachmentComplete = (a: Attachment): a is CompleteAttachment =>
   a.status.type === "complete";
@@ -20,14 +21,15 @@ export abstract class BaseComposerRuntimeCore implements ComposerRuntimeCore {
   }
 
   private _attachments: readonly Attachment[] = [];
-  protected set attachments(value: readonly Attachment[]) {
-    this._attachments = value;
-    this.notifySubscribers();
-  }
   public get attachments() {
     return this._attachments;
   }
 
+  protected setAttachments(value: readonly Attachment[]) {
+    this._attachments = value;
+    this.notifySubscribers();
+  }
+
   public abstract get canCancel(): boolean;
 
   public get isEmpty() {
@@ -40,6 +42,17 @@ export abstract class BaseComposerRuntimeCore implements ComposerRuntimeCore {
     return this._text;
   }
 
+  private _role: MessageRole = "user";
+
+  get role() {
+    return this._role;
+  }
+
+  setRole(role: MessageRole) {
+    this._role = role;
+    this.notifySubscribers();
+  }
+
   setText(value: string) {
     this._text = value;
     this.notifySubscribers();
@@ -47,6 +60,7 @@ export abstract class BaseComposerRuntimeCore implements ComposerRuntimeCore {
 
   reset() {
     this._text = "";
+    this._role = "user";
     this._attachments = [];
     this.notifySubscribers();
   }
@@ -69,7 +83,7 @@ export abstract class BaseComposerRuntimeCore implements ComposerRuntimeCore {
         : [];
 
     const message: Omit<AppendMessage, "parentId"> = {
-      role: "user",
+      role: this.role,
       content: this.text ? [{ type: "text", text: this.text }] : [],
       attachments,
     };

package/src/runtimes/composer/DefaultEditComposerRuntimeCore.tsx

@@ -28,11 +28,12 @@ export class DefaultEditComposerRuntimeCore extends BaseComposerRuntimeCore {
     this._previousText = getThreadMessageText(message);
     this.setText(this._previousText);
 
+    this.setRole(message.role);
+    this.setAttachments(message.attachments ?? []);
+
     this._nonTextParts = message.content.filter(
       (part) => part.type !== "text" && part.type !== "ui",
     );
-
-    this.attachments = message.attachments ?? [];
   }
 
   public async handleSend(message: Omit<AppendMessage, "parentId">) {

package/src/runtimes/core/AssistantRuntimeCore.tsx

@@ -1,9 +1,9 @@
 import type { ModelConfigProvider } from "../../types/ModelConfigTypes";
 import type { Unsubscribe } from "../../types/Unsubscribe";
-import { ThreadManagerRuntimeCore } from "./ThreadManagerRuntimeCore";
+import { ThreadListRuntimeCore } from "./ThreadListRuntimeCore";
 
 export type AssistantRuntimeCore = {
-  readonly threadManager: ThreadManagerRuntimeCore;
+  readonly threadList: ThreadListRuntimeCore;
 
   registerModelConfigProvider: (provider: ModelConfigProvider) => Unsubscribe;
 };

package/src/runtimes/core/BaseAssistantRuntimeCore.tsx

@@ -2,11 +2,11 @@ import { type ModelConfigProvider } from "../../types/ModelConfigTypes";
 import type { Unsubscribe } from "../../types/Unsubscribe";
 import type { AssistantRuntimeCore } from "./AssistantRuntimeCore";
 import { ProxyConfigProvider } from "../../utils/ProxyConfigProvider";
-import { ThreadManagerRuntimeCore } from "./ThreadManagerRuntimeCore";
+import { ThreadListRuntimeCore } from "./ThreadListRuntimeCore";
 
 export abstract class BaseAssistantRuntimeCore implements AssistantRuntimeCore {
   protected readonly _proxyConfigProvider = new ProxyConfigProvider();
-  public abstract get threadManager(): ThreadManagerRuntimeCore;
+  public abstract get threadList(): ThreadListRuntimeCore;
 
   constructor() {}
 

package/src/runtimes/core/ComposerRuntimeCore.tsx

@@ -1,4 +1,5 @@
 import type { Attachment, PendingAttachment, Unsubscribe } from "../../types";
+import { MessageRole } from "../../types/AssistantTypes";
 
 export type ComposerRuntimeCore = Readonly<{
   attachments: readonly Attachment[];
@@ -15,6 +16,9 @@ export type ComposerRuntimeCore = Readonly<{
   text: string;
   setText: (value: string) => void;
 
+  role: MessageRole;
+  setRole: (role: MessageRole) => void;
+
   /**
    * @deprecated This method will be removed in 0.6.0. Submit feedback if you need this functionality.
    */

package/src/runtimes/core/{ThreadManagerRuntimeCore.tsx → ThreadListRuntimeCore.tsx}

@@ -1,16 +1,18 @@
 import { Unsubscribe } from "../../types";
 import { ThreadRuntimeCore } from "./ThreadRuntimeCore";
 
-export type ThreadManagerMetadata = {
+export type ThreadListMetadata = Readonly<{
   threadId: string;
   title?: string;
-};
+}>;
 
-export type ThreadManagerRuntimeCore = {
+export type ThreadListRuntimeCore = {
   mainThread: ThreadRuntimeCore;
 
-  threads: readonly ThreadManagerMetadata[];
-  archivedThreads: readonly ThreadManagerMetadata[];
+  threads: readonly ThreadListMetadata[];
+  archivedThreads: readonly ThreadListMetadata[];
+
+  getThreadMetadataById(threadId: string): ThreadListMetadata | undefined;
 
   switchToThread(threadId: string): void;
   switchToNewThread(): void;

package/src/runtimes/core/subscribeToMainThread.ts

@@ -12,7 +12,7 @@ export const subscribeToMainThread = (
   let cleanup: Unsubscribe | undefined;
   const inner = () => {
     cleanup?.();
-    cleanup = runtime.threadManager.mainThread.subscribe(callback);
+    cleanup = runtime.threadList.mainThread.subscribe(callback);
 
     if (!first) {
       callback();
@@ -20,7 +20,7 @@ export const subscribeToMainThread = (
     first = false;
   };
 
-  const unsubscribe = runtime.threadManager.mainThread.subscribe(inner);
+  const unsubscribe = runtime.threadList.mainThread.subscribe(inner);
   inner();
 
   return () => {

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

@@ -6,13 +6,13 @@ import {
 } from "../core/ThreadRuntimeCore";
 import { FeedbackAdapter } from "../feedback/FeedbackAdapter";
 import { SpeechSynthesisAdapter } from "../speech/SpeechAdapterTypes";
-import { ThreadManagerMetadata } from "../core/ThreadManagerRuntimeCore";
+import { ThreadListMetadata } from "../core/ThreadListRuntimeCore";
 import { ThreadMessageLike } from "./ThreadMessageLike";
 
-export type ExternalStoreThreadManagerAdapter = {
+export type ExternalStoreThreadListAdapter = {
   threadId?: string | undefined;
-  threads?: readonly ThreadManagerMetadata[] | undefined;
-  archivedThreads?: readonly ThreadManagerMetadata[] | undefined;
+  threads?: readonly ThreadListMetadata[] | undefined;
+  archivedThreads?: readonly ThreadListMetadata[] | undefined;
   onSwitchToNewThread?: (() => Promise<void> | void) | undefined;
   onSwitchToThread?: ((threadId: string) => Promise<void> | void) | undefined;
   onRename?: (
@@ -35,16 +35,16 @@ type ExternalStoreMessageConverterAdapter<T> = {
 
 type ExternalStoreAdapterBase<T> = {
   /**
-   * @deprecated Use `adapters.threadManager.threadId` instead. This will be removed in 0.6.0.
+   * @deprecated Use `adapterst.threadList.threadId` instead. This will be removed in 0.6.0.
    */
   threadId?: string | undefined;
 
   /**
-   * @deprecated Use `adapters.threadManager.onSwitchToThread` instead. This will be removed in 0.6.0.
+   * @deprecated Use `adapters..threadList.onSwitchToThread` instead. This will be removed in 0.6.0.
    */
   onSwitchToThread?: ((threadId: string) => Promise<void> | void) | undefined;
   /**
-   * @deprecated Use `adapters.threadManager.onSwitchToNewThread` instead. This will be removed in 0.6.0.
+   * @deprecated Use `adapters.threadList.onSwitchToNewThread` instead. This will be removed in 0.6.0.
    */
   onSwitchToNewThread?: (() => Promise<void> | void) | undefined;
 
@@ -68,7 +68,7 @@ type ExternalStoreAdapterBase<T> = {
         attachments?: AttachmentAdapter | undefined;
         speech?: SpeechSynthesisAdapter | undefined;
         feedback?: FeedbackAdapter | undefined;
-        threadManager?: ExternalStoreThreadManagerAdapter | undefined;
+        threadList?: ExternalStoreThreadListAdapter | undefined;
       }
     | undefined;
   unstable_capabilities?:

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

@@ -1,27 +1,27 @@
 import { BaseAssistantRuntimeCore } from "../../internal";
-import { ExternalStoreThreadManagerRuntimeCore } from "./ExternalStoreThreadManagementAdapter";
+import { ExternalStoreThreadListRuntimeCore } from "./ExternalStoreThreadListRuntimeCore";
 import { ExternalStoreAdapter } from "./ExternalStoreAdapter";
 import { ExternalStoreThreadRuntimeCore } from "./ExternalStoreThreadRuntimeCore";
 
-const getThreadManagerAdapter = (store: ExternalStoreAdapter<any>) => {
+const getThreadListAdapter = (store: ExternalStoreAdapter<any>) => {
   return {
     threadId: store.threadId,
     onSwitchToNewThread: store.onSwitchToNewThread,
     onSwitchToThread: store.onSwitchToThread,
-    ...store.adapters?.threadManager,
+    ...store.adapters?.threadList,
   };
 };
 
 export class ExternalStoreRuntimeCore extends BaseAssistantRuntimeCore {
-  public readonly threadManager;
+  public readonly threadList;
 
   private _store: ExternalStoreAdapter<any>;
 
   constructor(store: ExternalStoreAdapter<any>) {
     super();
     this._store = store;
-    this.threadManager = new ExternalStoreThreadManagerRuntimeCore(
-      getThreadManagerAdapter(store),
+    this.threadList = new ExternalStoreThreadListRuntimeCore(
+      getThreadListAdapter(store),
       (threadId) =>
         new ExternalStoreThreadRuntimeCore(
           this._proxyConfigProvider,
@@ -33,7 +33,7 @@ export class ExternalStoreRuntimeCore extends BaseAssistantRuntimeCore {
 
   public setStore(store: ExternalStoreAdapter<any>) {
     this._store = store;
-    this.threadManager.setAdapter(getThreadManagerAdapter(store));
-    this.threadManager.mainThread.setStore(store);
+    this.threadList.setAdapter(getThreadListAdapter(store));
+    this.threadList.mainThread.setStore(store);
   }
 }