Factor tool definitions out of assistant (#21189)

This PR factors the tool definitions out of the `assistant` crate so
that they can be shared between `assistant` and `assistant2`.

`ToolWorkingSet` now lives in `assistant_tool`. The tool definitions
themselves live in `assistant_tools`, with the exception of the
`ContextServerTool`, which has been moved to the `context_server` crate.

As part of this refactoring I needed to extract the
`ContextServerSettings` to a separate `context_server_settings` crate so
that the `extension_host`—which is referenced by the `remote_server`—can
name the `ContextServerSettings` type without pulling in some undesired
dependencies.

Release Notes:

- N/A

crates/assistant_tool/src/assistant_tool.rs

@@ -1,4 +1,5 @@
 mod tool_registry;
+mod tool_working_set;
 
 use std::sync::Arc;
 
@@ -6,7 +7,8 @@ use anyhow::Result;
 use gpui::{AppContext, Task, WeakView, WindowContext};
 use workspace::Workspace;
 
-pub use tool_registry::*;
+pub use crate::tool_registry::*;
+pub use crate::tool_working_set::*;
 
 pub fn init(cx: &mut AppContext) {
     ToolRegistry::default_global(cx);

crates/assistant_tool/src/tool_working_set.rs

@@ -0,0 +1,77 @@
+use std::sync::Arc;
+
+use collections::HashMap;
+use gpui::AppContext;
+use parking_lot::Mutex;
+
+use crate::{Tool, ToolRegistry};
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
+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>>,
+    next_tool_id: ToolId,
+}
+
+impl ToolWorkingSet {
+    pub fn tool(&self, name: &str, cx: &AppContext) -> Option<Arc<dyn Tool>> {
+        self.state
+            .lock()
+            .context_server_tools_by_name
+            .get(name)
+            .cloned()
+            .or_else(|| ToolRegistry::global(cx).tool(name))
+    }
+
+    pub fn tools(&self, cx: &AppContext) -> Vec<Arc<dyn Tool>> {
+        let mut tools = ToolRegistry::global(cx).tools();
+        tools.extend(
+            self.state
+                .lock()
+                .context_server_tools_by_id
+                .values()
+                .cloned(),
+        );
+
+        tools
+    }
+
+    pub fn insert(&self, command: Arc<dyn Tool>) -> ToolId {
+        let mut state = self.state.lock();
+        let command_id = state.next_tool_id;
+        state.next_tool_id.0 += 1;
+        state
+            .context_server_tools_by_id
+            .insert(command_id, command.clone());
+        state.tools_changed();
+        command_id
+    }
+
+    pub fn remove(&self, command_ids_to_remove: &[ToolId]) {
+        let mut state = self.state.lock();
+        state
+            .context_server_tools_by_id
+            .retain(|id, _| !command_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(|command| (command.name(), command.clone())),
+        );
+    }
+}