remove Tool Selection Strategy preview

crates/goose-cli/src/commands/configure.rs

@@ -1154,11 +1154,6 @@ pub fn remove_extension_dialog() -> anyhow::Result<()> {
 pub async fn configure_settings_dialog() -> anyhow::Result<()> {
     let setting_type = cliclack::select("What setting would you like to configure?")
         .item("goose_mode", "goose mode", "Configure goose mode")
-        .item(
-            "goose_router_strategy",
-            "Router Tool Selection Strategy",
-            "Experimental: configure a strategy for auto selecting tools to use",
-        )
         .item(
             "tool_permission",
             "Tool Permission",
@@ -1197,9 +1192,6 @@ pub async fn configure_settings_dialog() -> anyhow::Result<()> {
         "goose_mode" => {
             configure_goose_mode_dialog()?;
         }
-        "goose_router_strategy" => {
-            configure_goose_router_strategy_dialog()?;
-        }
         "tool_permission" => {
             configure_tool_permissions_dialog().await.and(Ok(()))?;
             // No need to print config file path since it's already handled.
@@ -1271,33 +1263,6 @@ pub fn configure_goose_mode_dialog() -> anyhow::Result<()> {
     Ok(())
 }
 
-pub fn configure_goose_router_strategy_dialog() -> anyhow::Result<()> {
-    let config = Config::global();
-
-    let enable_router = cliclack::select("Would you like to enable smart tool routing?")
-        .item(
-            true,
-            "Enable Router",
-            "Use LLM-based intelligence to select tools",
-        )
-        .item(
-            false,
-            "Disable Router",
-            "Use the default tool selection strategy",
-        )
-        .interact()?;
-
-    config.set_param("GOOSE_ENABLE_ROUTER", enable_router)?;
-    let msg = if enable_router {
-        "Router enabled - using LLM-based intelligence for tool selection"
-    } else {
-        "Router disabled - using default tool selection"
-    };
-    cliclack::outro(msg)?;
-
-    Ok(())
-}
-
 pub fn configure_tool_output_dialog() -> anyhow::Result<()> {
     let config = Config::global();
 

crates/goose-cli/src/session/builder.rs

@@ -386,7 +386,6 @@ pub async fn build_session(session_config: SessionBuilderConfig) -> CliSession {
         .set_context(PlatformExtensionContext {
             session_id: Some(session_id.clone()),
             extension_manager: Some(Arc::downgrade(&agent.extension_manager)),
-            tool_route_manager: Some(Arc::downgrade(&agent.tool_route_manager)),
         })
         .await;
 
@@ -425,7 +424,6 @@ pub async fn build_session(session_config: SessionBuilderConfig) -> CliSession {
     // Extensions need to be added after the session is created because we change directory when resuming a session
     // If we get extensions_override, only run those extensions and none other
     let extensions_to_run: Vec<_> = if let Some(extensions) = session_config.extensions_override {
-        agent.disable_router_for_recipe().await;
         extensions.into_iter().collect()
     } else if session_config.resume {
         match SessionManager::get_session(&session_id, false).await {

crates/goose-server/src/openapi.rs

@@ -361,7 +361,6 @@ derive_utoipa!(Icon as IconSchema);
         super::routes::agent::agent_add_extension,
         super::routes::agent::agent_remove_extension,
         super::routes::agent::update_agent_provider,
-        super::routes::agent::update_router_tool_selector,
         super::routes::action_required::confirm_tool_action,
         super::routes::reply::reply,
         super::routes::session::list_sessions,
@@ -525,7 +524,6 @@ derive_utoipa!(Icon as IconSchema);
         super::routes::agent::ReadResourceResponse,
         super::routes::agent::CallToolRequest,
         super::routes::agent::CallToolResponse,
-        super::routes::agent::UpdateRouterToolSelectorRequest,
         super::routes::agent::StartAgentRequest,
         super::routes::agent::ResumeAgentRequest,
         super::routes::agent::UpdateFromSessionRequest,

crates/goose-server/src/routes/agent.rs

@@ -53,11 +53,6 @@ pub struct GetToolsQuery {
     session_id: String,
 }
 
-#[derive(Deserialize, utoipa::ToSchema)]
-pub struct UpdateRouterToolSelectorRequest {
-    session_id: String,
-}
-
 #[derive(Deserialize, utoipa::ToSchema)]
 pub struct StartAgentRequest {
     working_dir: String,
@@ -288,7 +283,7 @@ async fn resume_agent(
                     })?;
 
             agent
-                .load_provider(provider)
+                .update_provider(provider, &payload.session_id)
                 .await
                 .map_err(|e| ErrorResponse {
                     message: format!("Could not configure agent: {}", e),
@@ -501,35 +496,6 @@ async fn update_agent_provider(
     Ok(())
 }
 
-#[utoipa::path(
-    post,
-    path = "/agent/update_router_tool_selector",
-    request_body = UpdateRouterToolSelectorRequest,
-    responses(
-        (status = 200, description = "Tool selection strategy updated successfully", body = String),
-        (status = 401, description = "Unauthorized - invalid secret key"),
-        (status = 424, description = "Agent not initialized"),
-        (status = 500, description = "Internal server error")
-    )
-)]
-async fn update_router_tool_selector(
-    State(state): State<Arc<AppState>>,
-    Json(payload): Json<UpdateRouterToolSelectorRequest>,
-) -> Result<Json<String>, StatusCode> {
-    let agent = state.get_agent_for_route(payload.session_id).await?;
-    agent
-        .update_router_tool_selector(None, Some(true))
-        .await
-        .map_err(|e| {
-            error!("Failed to update tool selection strategy: {}", e);
-            StatusCode::INTERNAL_SERVER_ERROR
-        })?;
-
-    Ok(Json(
-        "Tool selection strategy updated successfully".to_string(),
-    ))
-}
-
 #[utoipa::path(
     post,
     path = "/agent/add_extension",
@@ -695,10 +661,6 @@ pub fn routes(state: Arc<AppState>) -> Router {
         .route("/agent/read_resource", post(read_resource))
         .route("/agent/call_tool", post(call_tool))
         .route("/agent/update_provider", post(update_agent_provider))
-        .route(
-            "/agent/update_router_tool_selector",
-            post(update_router_tool_selector),
-        )
         .route("/agent/update_from_session", post(update_from_session))
         .route("/agent/add_extension", post(agent_add_extension))
         .route("/agent/remove_extension", post(agent_remove_extension))

crates/goose/src/agents/agent.rs

@@ -12,20 +12,17 @@ use super::final_output_tool::FinalOutputTool;
 use super::platform_tools;
 use super::tool_execution::{ToolCallResult, CHAT_MODE_TOOL_SKIPPED_RESPONSE, DECLINED_RESPONSE};
 use crate::action_required_manager::ActionRequiredManager;
-use crate::agents::extension::{ExtensionConfig, ExtensionError, ExtensionResult, ToolInfo};
+use crate::agents::extension::{ExtensionConfig, ExtensionResult, ToolInfo};
 use crate::agents::extension_manager::{get_parameter_names, ExtensionManager};
 use crate::agents::extension_manager_extension::MANAGE_EXTENSIONS_TOOL_NAME_COMPLETE;
 use crate::agents::final_output_tool::{FINAL_OUTPUT_CONTINUATION_MESSAGE, FINAL_OUTPUT_TOOL_NAME};
 use crate::agents::platform_tools::PLATFORM_MANAGE_SCHEDULE_TOOL_NAME;
 use crate::agents::prompt_manager::PromptManager;
 use crate::agents::retry::{RetryManager, RetryResult};
-use crate::agents::router_tools::ROUTER_LLM_SEARCH_TOOL_NAME;
 use crate::agents::subagent_task_config::TaskConfig;
 use crate::agents::subagent_tool::{
     create_subagent_tool, handle_subagent_tool, SUBAGENT_TOOL_NAME,
 };
-use crate::agents::tool_route_manager::ToolRouteManager;
-use crate::agents::tool_router_index_manager::ToolRouterIndexManager;
 use crate::agents::types::SessionConfig;
 use crate::agents::types::{FrontendTool, SharedProvider, ToolResultReceiver};
 use crate::config::{get_enabled_extensions, Config, GooseMode};
@@ -95,7 +92,6 @@ pub struct Agent {
     pub(super) tool_result_tx: mpsc::Sender<(String, ToolResult<CallToolResult>)>,
     pub(super) tool_result_rx: ToolResultReceiver,
 
-    pub tool_route_manager: Arc<ToolRouteManager>,
     pub(super) scheduler_service: Mutex<Option<Arc<dyn SchedulerTrait>>>,
     pub(super) retry_manager: RetryManager,
     pub(super) tool_inspection_manager: ToolInspectionManager,
@@ -169,7 +165,6 @@ impl Agent {
             confirmation_rx: Mutex::new(confirm_rx),
             tool_result_tx: tool_tx,
             tool_result_rx: Arc::new(Mutex::new(tool_rx)),
-            tool_route_manager: Arc::new(ToolRouteManager::new()),
             scheduler_service: Mutex::new(None),
             retry_manager: RetryManager::new(),
             tool_inspection_manager: Self::create_default_tool_inspection_manager(),
@@ -369,10 +364,6 @@ impl Agent {
         *scheduler_service = Some(scheduler);
     }
 
-    pub async fn disable_router_for_recipe(&self) {
-        self.tool_route_manager.disable_router_for_recipe().await;
-    }
-
     /// Get a reference count clone to the provider
     pub async fn provider(&self) -> Result<Arc<dyn Provider>, anyhow::Error> {
         match &*self.provider.lock().await {
@@ -518,15 +509,6 @@ impl Agent {
                 "Frontend tool execution required".to_string(),
                 None,
             )))
-        } else if tool_call.name == ROUTER_LLM_SEARCH_TOOL_NAME {
-            match self
-                .tool_route_manager
-                .dispatch_route_search_tool(tool_call.arguments.unwrap_or_default())
-                .await
-            {
-                Ok(tool_result) => tool_result,
-                Err(e) => return (request_id, Err(e)),
-            }
         } else {
             // Clone the result to ensure no references to extension_manager are returned
             let result = self
@@ -617,28 +599,6 @@ impl Agent {
             }
         }
 
-        // If LLM tool selection is functional, index the tools
-        if self.tool_route_manager.is_router_functional().await {
-            let selector = self.tool_route_manager.get_router_tool_selector().await;
-            if let Some(selector) = selector {
-                let selector = Arc::new(selector);
-                if let Err(e) = ToolRouterIndexManager::update_extension_tools(
-                    &selector,
-                    &self.extension_manager,
-                    &extension.name(),
-                    "add",
-                )
-                .await
-                {
-                    return Err(ExtensionError::SetupError(format!(
-                        "Failed to index tools for extension {}: {}",
-                        extension.name(),
-                        e
-                    )));
-                }
-            }
-        }
-
         Ok(())
     }
 
@@ -702,29 +662,8 @@ impl Agent {
         prefixed_tools
     }
 
-    pub async fn list_tools_for_router(&self) -> Vec<Tool> {
-        self.tool_route_manager
-            .list_tools_for_router(&self.extension_manager)
-            .await
-    }
-
     pub async fn remove_extension(&self, name: &str) -> Result<()> {
         self.extension_manager.remove_extension(name).await?;
-
-        // If LLM tool selection is functional, remove tools from the index
-        if self.tool_route_manager.is_router_functional().await {
-            let selector = self.tool_route_manager.get_router_tool_selector().await;
-            if let Some(selector) = selector {
-                ToolRouterIndexManager::update_extension_tools(
-                    &selector,
-                    &self.extension_manager,
-                    name,
-                    "remove",
-                )
-                .await?;
-            }
-        }
-
         Ok(())
     }
 
@@ -1052,10 +991,6 @@ impl Agent {
                                     remaining_requests,
                                     filtered_response,
                                 } = self.categorize_tools(&response, &tools).await;
-                                let requests_to_record: Vec<ToolRequest> = frontend_requests.iter().chain(remaining_requests.iter()).cloned().collect();
-                                self.tool_route_manager
-                                    .record_tool_requests(&requests_to_record)
-                                    .await;
 
                                 yield AgentEvent::Message(filtered_response.clone());
                                 tokio::task::yield_now().await;
@@ -1377,9 +1312,6 @@ impl Agent {
         let mut current_provider = self.provider.lock().await;
         *current_provider = Some(provider.clone());
 
-        self.update_router_tool_selector(Some(provider.clone()), None)
-            .await?;
-
         SessionManager::update_session(session_id)
             .provider_name(provider.get_name())
             .model_config(provider.get_model_config())
@@ -1388,30 +1320,6 @@ impl Agent {
             .context("Failed to persist provider config to session")
     }
 
-    pub async fn load_provider(&self, provider: Arc<dyn Provider>) -> Result<()> {
-        let mut current_provider = self.provider.lock().await;
-        *current_provider = Some(provider.clone());
-
-        self.update_router_tool_selector(Some(provider.clone()), None)
-            .await
-    }
-
-    pub async fn update_router_tool_selector(
-        &self,
-        provider: Option<Arc<dyn Provider>>,
-        reindex_all: Option<bool>,
-    ) -> Result<()> {
-        let provider = match provider {
-            Some(p) => p,
-            None => self.provider().await?,
-        };
-
-        // Delegate to ToolRouteManager
-        self.tool_route_manager
-            .update_router_tool_selector(provider, reindex_all, &self.extension_manager)
-            .await
-    }
-
     /// Override the system prompt with a custom template
     pub async fn override_system_prompt(&self, template: String) {
         let mut prompt_manager = self.prompt_manager.lock().await;

crates/goose/src/agents/code_execution_extension.rs

@@ -923,7 +923,6 @@ mod tests {
         let context = PlatformExtensionContext {
             session_id: None,
             extension_manager: None,
-            tool_route_manager: None,
         };
         let client = CodeExecutionClient::new(context).unwrap();
 
@@ -948,7 +947,6 @@ mod tests {
         let context = PlatformExtensionContext {
             session_id: None,
             extension_manager: None,
-            tool_route_manager: None,
         };
         let client = CodeExecutionClient::new(context).unwrap();
 

crates/goose/src/agents/extension.rs

@@ -109,8 +109,6 @@ pub struct PlatformExtensionContext {
     pub session_id: Option<String>,
     pub extension_manager:
         Option<std::sync::Weak<crate::agents::extension_manager::ExtensionManager>>,
-    pub tool_route_manager:
-        Option<std::sync::Weak<crate::agents::tool_route_manager::ToolRouteManager>>,
 }
 
 #[derive(Debug, Clone)]

crates/goose/src/agents/extension_manager.rs

@@ -264,7 +264,6 @@ impl ExtensionManager {
             context: Mutex::new(PlatformExtensionContext {
                 session_id: None,
                 extension_manager: None,
-                tool_route_manager: None,
             }),
             provider,
         }