Revert "Rewrite extension management tools"

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

@@ -3,6 +3,9 @@ use cliclack::spinner;
 use console::style;
 use goose::agents::extension::ToolInfo;
 use goose::agents::extension_manager::get_parameter_names;
+use goose::agents::platform_tools::{
+    PLATFORM_LIST_RESOURCES_TOOL_NAME, PLATFORM_READ_RESOURCE_TOOL_NAME,
+};
 use goose::agents::Agent;
 use goose::agents::{extension::Envs, ExtensionConfig};
 use goose::config::declarative_providers::{create_custom_provider, remove_custom_provider};
@@ -1446,6 +1449,10 @@ pub async fn configure_tool_permissions_dialog() -> Result<(), Box<dyn Error>> {
         .list_tools(Some(selected_extension_name.clone()))
         .await
         .into_iter()
+        .filter(|tool| {
+            tool.name != PLATFORM_LIST_RESOURCES_TOOL_NAME
+                && tool.name != PLATFORM_READ_RESOURCE_TOOL_NAME
+        })
         .map(|tool| {
             ToolInfo::new(
                 &tool.name,

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

@@ -324,8 +324,6 @@ pub async fn build_session(session_config: SessionBuilderConfig) -> CliSession {
         .extension_manager
         .set_context(PlatformExtensionContext {
             session_id: session_id.clone(),
-            extension_manager: Some(Arc::downgrade(&agent.extension_manager)),
-            tool_route_manager: Some(Arc::downgrade(&agent.tool_route_manager)),
         })
         .await;
 

crates/goose/src/agents/agent.rs

@@ -10,9 +10,12 @@ use uuid::Uuid;
 
 use crate::agents::extension::{ExtensionConfig, ExtensionError, 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::platform_tools::{
+    PLATFORM_LIST_RESOURCES_TOOL_NAME, PLATFORM_MANAGE_EXTENSIONS_TOOL_NAME,
+    PLATFORM_MANAGE_SCHEDULE_TOOL_NAME, PLATFORM_READ_RESOURCE_TOOL_NAME,
+    PLATFORM_SEARCH_AVAILABLE_EXTENSIONS_TOOL_NAME,
+};
 use crate::agents::prompt_manager::PromptManager;
 use crate::agents::recipe_tools::dynamic_task_tools::{
     create_dynamic_task, create_dynamic_task_tool, DYNAMIC_TASK_TOOL_NAME_PREFIX,
@@ -29,7 +32,7 @@ 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, ToolResultReceiver};
-use crate::config::{get_enabled_extensions, Config};
+use crate::config::{get_enabled_extensions, get_extension_by_name, Config};
 use crate::context_mgmt::DEFAULT_COMPACTION_THRESHOLD;
 use crate::conversation::{debug_conversation_fix, fix_conversation, Conversation};
 use crate::mcp_utils::ToolResult;
@@ -85,7 +88,7 @@ pub struct ToolCategorizeResult {
 /// The main goose Agent
 pub struct Agent {
     pub(super) provider: Mutex<Option<Arc<dyn Provider>>>,
-    pub extension_manager: Arc<ExtensionManager>,
+    pub extension_manager: ExtensionManager,
     pub(super) sub_recipe_manager: Mutex<SubRecipeManager>,
     pub(super) tasks_manager: TasksManager,
     pub(super) final_output_tool: Arc<Mutex<Option<FinalOutputTool>>>,
@@ -97,7 +100,7 @@ pub struct Agent {
     pub(super) tool_result_tx: mpsc::Sender<(String, ToolResult<Vec<Content>>)>,
     pub(super) tool_result_rx: ToolResultReceiver,
 
-    pub tool_route_manager: Arc<ToolRouteManager>,
+    pub(super) tool_route_manager: ToolRouteManager,
     pub(super) scheduler_service: Mutex<Option<Arc<dyn SchedulerTrait>>>,
     pub(super) retry_manager: RetryManager,
     pub(super) tool_inspection_manager: ToolInspectionManager,
@@ -160,7 +163,7 @@ impl Agent {
 
         Self {
             provider: Mutex::new(None),
-            extension_manager: Arc::new(ExtensionManager::new()),
+            extension_manager: ExtensionManager::new(),
             sub_recipe_manager: Mutex::new(SubRecipeManager::new()),
             tasks_manager: TasksManager::new(),
             final_output_tool: Arc::new(Mutex::new(None)),
@@ -171,7 +174,7 @@ 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()),
+            tool_route_manager: ToolRouteManager::new(),
             scheduler_service: Mutex::new(None),
             retry_manager: RetryManager::new(),
             tool_inspection_manager: Self::create_default_tool_inspection_manager(),
@@ -401,6 +404,28 @@ impl Agent {
             return (request_id, Ok(ToolCallResult::from(result)));
         }
 
+        if tool_call.name == PLATFORM_MANAGE_EXTENSIONS_TOOL_NAME {
+            let extension_name = tool_call
+                .arguments
+                .as_ref()
+                .and_then(|args| args.get("extension_name"))
+                .and_then(|v| v.as_str())
+                .unwrap_or("")
+                .to_string();
+            let action = tool_call
+                .arguments
+                .as_ref()
+                .and_then(|args| args.get("action"))
+                .and_then(|v| v.as_str())
+                .unwrap_or("")
+                .to_string();
+            let (request_id, result) = self
+                .manage_extensions(action, extension_name, request_id)
+                .await;
+
+            return (request_id, Ok(ToolCallResult::from(result)));
+        }
+
         if tool_call.name == FINAL_OUTPUT_TOOL_NAME {
             return if let Some(final_output_tool) = self.final_output_tool.lock().await.as_mut() {
                 let result = final_output_tool.execute_tool_call(tool_call.clone()).await;
@@ -463,12 +488,12 @@ impl Agent {
             let parent_session_id = session.id.to_string();
             let parent_working_dir = session.working_dir.clone();
 
-            // Get extensions from the agent's runtime state rather than global config
-            // This ensures subagents inherit extensions that were dynamically enabled by the parent
-            let extensions = self.get_extension_configs().await;
-
-            let task_config =
-                TaskConfig::new(provider, parent_session_id, parent_working_dir, extensions);
+            let task_config = TaskConfig::new(
+                provider,
+                parent_session_id,
+                parent_working_dir,
+                get_enabled_extensions(),
+            );
 
             let arguments = match tool_call.arguments.clone() {
                 Some(args) => Value::Object(args),
@@ -535,6 +560,31 @@ impl Agent {
                 .map(Value::Object)
                 .unwrap_or(Value::Object(serde_json::Map::new()));
             create_dynamic_task(arguments, &self.tasks_manager, loaded_extensions).await
+        } else if tool_call.name == PLATFORM_READ_RESOURCE_TOOL_NAME {
+            // Check if the tool is read_resource and handle it separately
+            let arguments = tool_call
+                .arguments
+                .clone()
+                .map(Value::Object)
+                .unwrap_or(Value::Object(serde_json::Map::new()));
+            ToolCallResult::from(
+                self.extension_manager
+                    .read_resource(arguments, cancellation_token.unwrap_or_default())
+                    .await,
+            )
+        } else if tool_call.name == PLATFORM_LIST_RESOURCES_TOOL_NAME {
+            let arguments = tool_call
+                .arguments
+                .clone()
+                .map(Value::Object)
+                .unwrap_or(Value::Object(serde_json::Map::new()));
+            ToolCallResult::from(
+                self.extension_manager
+                    .list_resources(arguments, cancellation_token.unwrap_or_default())
+                    .await,
+            )
+        } else if tool_call.name == PLATFORM_SEARCH_AVAILABLE_EXTENSIONS_TOOL_NAME {
+            ToolCallResult::from(self.extension_manager.search_available_extensions().await)
         } else if self.is_frontend_tool(&tool_call.name).await {
             // For frontend tools, return an error indicating we need frontend execution
             ToolCallResult::from(Err(ErrorData::new(
@@ -603,6 +653,109 @@ impl Agent {
         Ok(())
     }
 
+    #[allow(clippy::too_many_lines)]
+    pub(super) async fn manage_extensions(
+        &self,
+        action: String,
+        extension_name: String,
+        request_id: String,
+    ) -> (String, Result<Vec<Content>, ErrorData>) {
+        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_action = if action == "disable" { "remove" } else { "add" };
+                let selector = Arc::new(selector);
+                if let Err(e) = ToolRouterIndexManager::update_extension_tools(
+                    &selector,
+                    &self.extension_manager,
+                    &extension_name,
+                    selector_action,
+                )
+                .await
+                {
+                    return (
+                        request_id,
+                        Err(ErrorData::new(
+                            ErrorCode::INTERNAL_ERROR,
+                            format!("Failed to update LLM index: {}", e),
+                            None,
+                        )),
+                    );
+                }
+            }
+        }
+        if action == "disable" {
+            let result = self
+                .extension_manager
+                .remove_extension(&extension_name)
+                .await
+                .map(|_| {
+                    vec![Content::text(format!(
+                        "The extension '{}' has been disabled successfully",
+                        extension_name
+                    ))]
+                })
+                .map_err(|e| ErrorData::new(ErrorCode::INTERNAL_ERROR, e.to_string(), None));
+            return (request_id, result);
+        }
+
+        let config = match get_extension_by_name(&extension_name) {
+            Some(config) => config,
+            None => {
+                return (
+                    request_id,
+                    Err(ErrorData::new(
+                        ErrorCode::RESOURCE_NOT_FOUND,
+                        format!(
+                        "Extension '{}' not found. Please check the extension name and try again.",
+                        extension_name
+                    ),
+                        None,
+                    )),
+                )
+            }
+        };
+        let result = self
+            .extension_manager
+            .add_extension(config)
+            .await
+            .map(|_| {
+                vec![Content::text(format!(
+                    "The extension '{}' has been installed successfully",
+                    extension_name
+                ))]
+            })
+            .map_err(|e| ErrorData::new(ErrorCode::INTERNAL_ERROR, e.to_string(), None));
+
+        // Update LLM index if operation was successful and LLM routing is functional
+        if result.is_ok() && 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 llm_action = if action == "disable" { "remove" } else { "add" };
+                let selector = Arc::new(selector);
+                if let Err(e) = ToolRouterIndexManager::update_extension_tools(
+                    &selector,
+                    &self.extension_manager,
+                    &extension_name,
+                    llm_action,
+                )
+                .await
+                {
+                    return (
+                        request_id,
+                        Err(ErrorData::new(
+                            ErrorCode::INTERNAL_ERROR,
+                            format!("Failed to update LLM index: {}", e),
+                            None,
+                        )),
+                    );
+                }
+            }
+        }
+
+        (request_id, result)
+    }
+
     pub async fn add_extension(&self, extension: ExtensionConfig) -> ExtensionResult<()> {
         match &extension {
             ExtensionConfig::Frontend {
@@ -671,10 +824,21 @@ impl Agent {
 
         if extension_name.is_none() || extension_name.as_deref() == Some("platform") {
             // Add platform tools
-            // TODO: migrate the manage schedule tool as well
-            prefixed_tools.extend([platform_tools::manage_schedule_tool()]);
+            prefixed_tools.extend([
+                platform_tools::search_available_extensions_tool(),
+                platform_tools::manage_extensions_tool(),
+                platform_tools::manage_schedule_tool(),
+            ]);
             // Dynamic task tool
             prefixed_tools.push(create_dynamic_task_tool());
+
+            // Add resource tools if supported
+            if self.extension_manager.supports_resources().await {
+                prefixed_tools.extend([
+                    platform_tools::read_resource_tool(),
+                    platform_tools::list_resources_tool(),
+                ]);
+            }
         }
 
         if extension_name.is_none() {
@@ -1051,7 +1215,7 @@ impl Agent {
                                     let mut enable_extension_request_ids = vec![];
                                     for request in &remaining_requests {
                                         if let Ok(tool_call) = &request.tool_call {
-                                            if tool_call.name == MANAGE_EXTENSIONS_TOOL_NAME_COMPLETE {
+                                            if tool_call.name == PLATFORM_MANAGE_EXTENSIONS_TOOL_NAME {
                                                 enable_extension_request_ids.push(request.id.clone());
                                             }
                                         }

crates/goose/src/agents/extension.rs

@@ -1,4 +1,3 @@
-use crate::agents::extension_manager_extension;
 use crate::agents::todo_extension;
 use std::collections::HashMap;
 
@@ -35,8 +34,8 @@ impl ProcessExit {
     }
 }
 
-pub static PLATFORM_EXTENSIONS: Lazy<HashMap<&'static str, PlatformExtensionDef>> = Lazy::new(
-    || {
+pub static PLATFORM_EXTENSIONS: Lazy<HashMap<&'static str, PlatformExtensionDef>> =
+    Lazy::new(|| {
         let mut map = HashMap::new();
 
         map.insert(
@@ -50,28 +49,12 @@ pub static PLATFORM_EXTENSIONS: Lazy<HashMap<&'static str, PlatformExtensionDef>
             },
         );
 
-        map.insert(
-            "extensionmanager",
-            PlatformExtensionDef {
-                name: extension_manager_extension::EXTENSION_NAME,
-                description:
-                    "Enable extension management tools for discovering, enabling, and disabling extensions",
-                default_enabled: true,
-                client_factory: |ctx| Box::new(extension_manager_extension::ExtensionManagerClient::new(ctx).unwrap()),
-            },
-        );
-
         map
-    },
-);
+    });
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 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

@@ -238,11 +238,7 @@ impl ExtensionManager {
     pub fn new() -> Self {
         Self {
             extensions: Mutex::new(HashMap::new()),
-            context: Mutex::new(PlatformExtensionContext {
-                session_id: None,
-                extension_manager: None,
-                tool_route_manager: None,
-            }),
+            context: Mutex::new(PlatformExtensionContext { session_id: None }),
         }
     }