feat: mcp router skeleton (#2606)

crates/goose/src/agents/agent.rs

@@ -25,6 +25,10 @@ use crate::agents::platform_tools::{
     PLATFORM_READ_RESOURCE_TOOL_NAME, PLATFORM_SEARCH_AVAILABLE_EXTENSIONS_TOOL_NAME,
 };
 use crate::agents::prompt_manager::PromptManager;
+use crate::agents::router_tool_selector::{
+    create_tool_selector, RouterToolSelectionStrategy, RouterToolSelector,
+};
+use crate::agents::router_tools::ROUTER_VECTOR_SEARCH_TOOL_NAME;
 use crate::agents::types::SessionConfig;
 use crate::agents::types::{FrontendTool, ToolResultReceiver};
 use mcp_core::{
@@ -32,6 +36,7 @@ use mcp_core::{
 };
 
 use super::platform_tools;
+use super::router_tools;
 use super::tool_execution::{ToolFuture, CHAT_MODE_TOOL_SKIPPED_RESPONSE, DECLINED_RESPONSE};
 
 /// The main goose Agent
@@ -46,6 +51,7 @@ pub struct Agent {
     pub(super) tool_result_tx: mpsc::Sender<(String, ToolResult<Vec<Content>>)>,
     pub(super) tool_result_rx: ToolResultReceiver,
     pub(super) tool_monitor: Mutex<Option<ToolMonitor>>,
+    pub(super) router_tool_selector: Mutex<Option<Box<dyn RouterToolSelector>>>,
 }
 
 impl Agent {
@@ -54,6 +60,16 @@ impl Agent {
         let (confirm_tx, confirm_rx) = mpsc::channel(32);
         let (tool_tx, tool_rx) = mpsc::channel(32);
 
+        let router_tool_selection_strategy = std::env::var("GOOSE_ROUTER_TOOL_SELECTION_STRATEGY")
+            .ok()
+            .and_then(|s| {
+                if s.eq_ignore_ascii_case("vector") {
+                    Some(RouterToolSelectionStrategy::Vector)
+                } else {
+                    None
+                }
+            });
+
         Self {
             provider: Mutex::new(None),
             extension_manager: Mutex::new(ExtensionManager::new()),
@@ -65,6 +81,9 @@ impl Agent {
             tool_result_tx: tool_tx,
             tool_result_rx: Arc::new(Mutex::new(tool_rx)),
             tool_monitor: Mutex::new(None),
+            router_tool_selector: Mutex::new(Some(create_tool_selector(
+                router_tool_selection_strategy,
+            ))),
         }
     }
 
@@ -184,6 +203,15 @@ impl Agent {
             Err(ToolError::ExecutionError(
                 "Frontend tool execution required".to_string(),
             ))
+        } else if tool_call.name == ROUTER_VECTOR_SEARCH_TOOL_NAME {
+            let router_tool_selector = self.router_tool_selector.lock().await;
+            if let Some(selector) = router_tool_selector.as_ref() {
+                selector.select_tools(tool_call.arguments.clone()).await
+            } else {
+                Err(ToolError::ExecutionError(
+                    "Encountered vector search error.".to_string(),
+                ))
+            }
         } else {
             extension_manager
                 .dispatch_tool_call(tool_call.clone())
@@ -318,6 +346,29 @@ impl Agent {
         prefixed_tools
     }
 
+    pub async fn list_tools_for_router(
+        &self,
+        strategy: Option<RouterToolSelectionStrategy>,
+    ) -> Vec<Tool> {
+        let extension_manager = self.extension_manager.lock().await;
+
+        let mut prefixed_tools = vec![];
+        match strategy {
+            Some(RouterToolSelectionStrategy::Vector) => {
+                prefixed_tools.push(router_tools::vector_search_tool());
+            }
+            None => {}
+        }
+        prefixed_tools.push(platform_tools::search_available_extensions_tool());
+        prefixed_tools.push(platform_tools::manage_extensions_tool());
+
+        if extension_manager.supports_resources() {
+            prefixed_tools.push(platform_tools::read_resource_tool());
+            prefixed_tools.push(platform_tools::list_resources_tool());
+        }
+        prefixed_tools
+    }
+
     pub async fn remove_extension(&self, name: &str) {
         let mut extension_manager = self.extension_manager.lock().await;
         extension_manager
@@ -474,7 +525,7 @@ impl Agent {
                                 &permission_check_result.needs_approval,
                                 tool_futures_arc.clone(),
                                 &mut permission_manager,
-                                message_tool_response.clone(),
+                                message_tool_response.clone()
                             );
 
                             // We have a stream of tool_approval_requests to handle
@@ -629,6 +680,7 @@ impl Agent {
             self.frontend_instructions.lock().await.clone(),
             extension_manager.suggest_disable_extensions_prompt().await,
             Some(model_name),
+            None,
         );
 
         let recipe_prompt = prompt_manager.get_recipe_prompt().await;