assistant2: Don't block `ThreadStore` initialization on reloading the threads (#23728)

Marshall Bowers created 11 months ago

This PR changes the `ThreadStore` constructor to not block on reloading
the threads before we finish initializing it.

This allows us to make the constructor synchronous instead of
asynchronous.

Release Notes:

- N/A

Change summary

crates/assistant2/src/assistant_panel.rs | 10 +--
crates/assistant2/src/thread_store.rs    | 70 +++++++++++--------------
2 files changed, 36 insertions(+), 44 deletions(-)

Detailed changes

crates/assistant2/src/assistant_panel.rs

@@ -119,12 +119,10 @@ impl AssistantPanel {
         cx.spawn(|mut cx| async move {
             let tools = Arc::new(ToolWorkingSet::default());
             log::info!("[assistant2-debug] initializing ThreadStore");
-            let thread_store = workspace
-                .update(&mut cx, |workspace, cx| {
-                    let project = workspace.project().clone();
-                    ThreadStore::new(project, tools.clone(), cx)
-                })?
-                .await?;
+            let thread_store = workspace.update(&mut cx, |workspace, cx| {
+                let project = workspace.project().clone();
+                ThreadStore::new(project, tools.clone(), cx)
+            })??;
             log::info!("[assistant2-debug] finished initializing ThreadStore");
 
             let slash_commands = Arc::new(SlashCommandWorkingSet::default());

crates/assistant2/src/thread_store.rs

@@ -34,45 +34,39 @@ impl ThreadStore {
         project: Entity<Project>,
         tools: Arc<ToolWorkingSet>,
         cx: &mut App,
-    ) -> Task<Result<Entity<Self>>> {
-        cx.spawn(|mut cx| async move {
-            let this = cx.new(|cx: &mut Context<Self>| {
-                let context_server_factory_registry =
-                    ContextServerFactoryRegistry::default_global(cx);
-                let context_server_manager = cx.new(|cx| {
-                    ContextServerManager::new(context_server_factory_registry, project.clone(), cx)
-                });
+    ) -> Result<Entity<Self>> {
+        let this = cx.new(|cx| {
+            let context_server_factory_registry = ContextServerFactoryRegistry::default_global(cx);
+            let context_server_manager = cx.new(|cx| {
+                ContextServerManager::new(context_server_factory_registry, project.clone(), cx)
+            });
+
+            let executor = cx.background_executor().clone();
+            let database_future = executor
+                .spawn({
+                    let executor = executor.clone();
+                    let database_path = paths::support_dir().join("threads/threads-db.0.mdb");
+                    async move { ThreadsDatabase::new(database_path, executor) }
+                })
+                .then(|result| future::ready(result.map(Arc::new).map_err(Arc::new)))
+                .boxed()
+                .shared();
+
+            let this = Self {
+                project,
+                tools,
+                context_server_manager,
+                context_server_tool_ids: HashMap::default(),
+                threads: Vec::new(),
+                database_future,
+            };
+            this.register_context_server_handlers(cx);
+            this.reload(cx).detach_and_log_err(cx);
 
-                let executor = cx.background_executor().clone();
-                let database_future = executor
-                    .spawn({
-                        let executor = executor.clone();
-                        let database_path = paths::support_dir().join("threads/threads-db.0.mdb");
-                        async move { ThreadsDatabase::new(database_path, executor) }
-                    })
-                    .then(|result| future::ready(result.map(Arc::new).map_err(Arc::new)))
-                    .boxed()
-                    .shared();
-
-                let this = Self {
-                    project,
-                    tools,
-                    context_server_manager,
-                    context_server_tool_ids: HashMap::default(),
-                    threads: Vec::new(),
-                    database_future,
-                };
-                this.register_context_server_handlers(cx);
-
-                this
-            })?;
-
-            log::info!("[assistant2-debug] reloading threads");
-            this.update(&mut cx, |this, cx| this.reload(cx))?.await?;
-            log::info!("[assistant2-debug] finished reloading threads");
-
-            Ok(this)
-        })
+            this
+        });
+
+        Ok(this)
     }
 
     /// Returns the number of threads.