agent: Make ToolWorkingSet an Entity (#28757)

Motivation is to emit events when enabled tools change, want to use this
in #28755

Release Notes:

- N/A

crates/assistant_tool/src/tool_working_set.rs

@@ -1,8 +1,7 @@
 use std::sync::Arc;
 
 use collections::{HashMap, HashSet, IndexMap};
-use gpui::App;
-use parking_lot::Mutex;
+use gpui::{App, Context, EventEmitter};
 
 use crate::{Tool, ToolRegistry, ToolSource};
 
@@ -12,11 +11,6 @@ pub struct ToolId(usize);
 /// A working set of tools for use in one instance of the Assistant Panel.
 #[derive(Default)]
 pub struct ToolWorkingSet {
-    state: Mutex<WorkingSetState>,
-}
-
-#[derive(Default)]
-struct WorkingSetState {
     context_server_tools_by_id: HashMap<ToolId, Arc<dyn Tool>>,
     context_server_tools_by_name: HashMap<String, Arc<dyn Tool>>,
     enabled_sources: HashSet<ToolSource>,
@@ -24,99 +18,27 @@ struct WorkingSetState {
     next_tool_id: ToolId,
 }
 
+pub enum ToolWorkingSetEvent {
+    EnabledToolsChanged,
+}
+
+impl EventEmitter<ToolWorkingSetEvent> for ToolWorkingSet {}
+
 impl ToolWorkingSet {
     pub fn tool(&self, name: &str, cx: &App) -> Option<Arc<dyn Tool>> {
-        self.state
-            .lock()
-            .context_server_tools_by_name
+        self.context_server_tools_by_name
             .get(name)
             .cloned()
             .or_else(|| ToolRegistry::global(cx).tool(name))
     }
 
     pub fn tools(&self, cx: &App) -> Vec<Arc<dyn Tool>> {
-        self.state.lock().tools(cx)
-    }
-
-    pub fn tools_by_source(&self, cx: &App) -> IndexMap<ToolSource, Vec<Arc<dyn Tool>>> {
-        self.state.lock().tools_by_source(cx)
-    }
-
-    pub fn enabled_tools(&self, cx: &App) -> Vec<Arc<dyn Tool>> {
-        self.state.lock().enabled_tools(cx)
-    }
-
-    pub fn disable_all_tools(&self) {
-        let mut state = self.state.lock();
-        state.disable_all_tools();
-    }
-
-    pub fn enable_source(&self, source: ToolSource, cx: &App) {
-        let mut state = self.state.lock();
-        state.enable_source(source, cx);
-    }
-
-    pub fn disable_source(&self, source: &ToolSource) {
-        let mut state = self.state.lock();
-        state.disable_source(source);
-    }
-
-    pub fn insert(&self, tool: Arc<dyn Tool>) -> ToolId {
-        let mut state = self.state.lock();
-        let tool_id = state.next_tool_id;
-        state.next_tool_id.0 += 1;
-        state
-            .context_server_tools_by_id
-            .insert(tool_id, tool.clone());
-        state.tools_changed();
-        tool_id
-    }
-
-    pub fn is_enabled(&self, source: &ToolSource, name: &Arc<str>) -> bool {
-        self.state.lock().is_enabled(source, name)
-    }
-
-    pub fn is_disabled(&self, source: &ToolSource, name: &Arc<str>) -> bool {
-        self.state.lock().is_disabled(source, name)
-    }
-
-    pub fn enable(&self, source: ToolSource, tools_to_enable: &[Arc<str>]) {
-        let mut state = self.state.lock();
-        state.enable(source, tools_to_enable);
-    }
-
-    pub fn disable(&self, source: ToolSource, tools_to_disable: &[Arc<str>]) {
-        let mut state = self.state.lock();
-        state.disable(source, tools_to_disable);
-    }
-
-    pub fn remove(&self, tool_ids_to_remove: &[ToolId]) {
-        let mut state = self.state.lock();
-        state
-            .context_server_tools_by_id
-            .retain(|id, _| !tool_ids_to_remove.contains(id));
-        state.tools_changed();
-    }
-}
-
-impl WorkingSetState {
-    fn tools_changed(&mut self) {
-        self.context_server_tools_by_name.clear();
-        self.context_server_tools_by_name.extend(
-            self.context_server_tools_by_id
-                .values()
-                .map(|tool| (tool.name(), tool.clone())),
-        );
-    }
-
-    fn tools(&self, cx: &App) -> Vec<Arc<dyn Tool>> {
         let mut tools = ToolRegistry::global(cx).tools();
         tools.extend(self.context_server_tools_by_id.values().cloned());
-
         tools
     }
 
-    fn tools_by_source(&self, cx: &App) -> IndexMap<ToolSource, Vec<Arc<dyn Tool>>> {
+    pub fn tools_by_source(&self, cx: &App) -> IndexMap<ToolSource, Vec<Arc<dyn Tool>>> {
         let mut tools_by_source = IndexMap::default();
 
         for tool in self.tools(cx) {
@@ -135,7 +57,7 @@ impl WorkingSetState {
         tools_by_source
     }
 
-    fn enabled_tools(&self, cx: &App) -> Vec<Arc<dyn Tool>> {
+    pub fn enabled_tools(&self, cx: &App) -> Vec<Arc<dyn Tool>> {
         let all_tools = self.tools(cx);
 
         all_tools
@@ -144,31 +66,12 @@ impl WorkingSetState {
             .collect()
     }
 
-    fn is_enabled(&self, source: &ToolSource, name: &Arc<str>) -> bool {
-        self.enabled_tools_by_source
-            .get(source)
-            .map_or(false, |enabled_tools| enabled_tools.contains(name))
+    pub fn disable_all_tools(&mut self, cx: &mut Context<Self>) {
+        self.enabled_tools_by_source.clear();
+        cx.emit(ToolWorkingSetEvent::EnabledToolsChanged);
     }
 
-    fn is_disabled(&self, source: &ToolSource, name: &Arc<str>) -> bool {
-        !self.is_enabled(source, name)
-    }
-
-    fn enable(&mut self, source: ToolSource, tools_to_enable: &[Arc<str>]) {
-        self.enabled_tools_by_source
-            .entry(source)
-            .or_default()
-            .extend(tools_to_enable.into_iter().cloned());
-    }
-
-    fn disable(&mut self, source: ToolSource, tools_to_disable: &[Arc<str>]) {
-        self.enabled_tools_by_source
-            .entry(source)
-            .or_default()
-            .retain(|name| !tools_to_disable.contains(name));
-    }
-
-    fn enable_source(&mut self, source: ToolSource, cx: &App) {
+    pub fn enable_source(&mut self, source: ToolSource, cx: &mut Context<Self>) {
         self.enabled_sources.insert(source.clone());
 
         let tools_by_source = self.tools_by_source(cx);
@@ -181,14 +84,72 @@ impl WorkingSetState {
                     .collect::<HashSet<_>>(),
             );
         }
+        cx.emit(ToolWorkingSetEvent::EnabledToolsChanged);
     }
 
-    fn disable_source(&mut self, source: &ToolSource) {
+    pub fn disable_source(&mut self, source: &ToolSource, cx: &mut Context<Self>) {
         self.enabled_sources.remove(source);
         self.enabled_tools_by_source.remove(source);
+        cx.emit(ToolWorkingSetEvent::EnabledToolsChanged);
     }
 
-    fn disable_all_tools(&mut self) {
-        self.enabled_tools_by_source.clear();
+    pub fn insert(&mut self, tool: Arc<dyn Tool>) -> ToolId {
+        let tool_id = self.next_tool_id;
+        self.next_tool_id.0 += 1;
+        self.context_server_tools_by_id
+            .insert(tool_id, tool.clone());
+        self.tools_changed();
+        tool_id
+    }
+
+    pub fn is_enabled(&self, source: &ToolSource, name: &Arc<str>) -> bool {
+        self.enabled_tools_by_source
+            .get(source)
+            .map_or(false, |enabled_tools| enabled_tools.contains(name))
+    }
+
+    pub fn is_disabled(&self, source: &ToolSource, name: &Arc<str>) -> bool {
+        !self.is_enabled(source, name)
+    }
+
+    pub fn enable(
+        &mut self,
+        source: ToolSource,
+        tools_to_enable: &[Arc<str>],
+        cx: &mut Context<Self>,
+    ) {
+        self.enabled_tools_by_source
+            .entry(source)
+            .or_default()
+            .extend(tools_to_enable.into_iter().cloned());
+        cx.emit(ToolWorkingSetEvent::EnabledToolsChanged);
+    }
+
+    pub fn disable(
+        &mut self,
+        source: ToolSource,
+        tools_to_disable: &[Arc<str>],
+        cx: &mut Context<Self>,
+    ) {
+        self.enabled_tools_by_source
+            .entry(source)
+            .or_default()
+            .retain(|name| !tools_to_disable.contains(name));
+        cx.emit(ToolWorkingSetEvent::EnabledToolsChanged);
+    }
+
+    pub fn remove(&mut self, tool_ids_to_remove: &[ToolId]) {
+        self.context_server_tools_by_id
+            .retain(|id, _| !tool_ids_to_remove.contains(id));
+        self.tools_changed();
+    }
+
+    fn tools_changed(&mut self) {
+        self.context_server_tools_by_name.clear();
+        self.context_server_tools_by_name.extend(
+            self.context_server_tools_by_id
+                .values()
+                .map(|tool| (tool.name(), tool.clone())),
+        );
     }
 }