Working MCP tools

Author: brandonskiser

crates/agent/src/agent/agent_config/definitions.rs

@@ -13,7 +13,8 @@ use crate::agent::consts::BUILTIN_VIBER_AGENT_NAME;
 use crate::agent::tools::BuiltInToolName;
 
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
-#[serde(tag = "specVersion")]
+// #[serde(tag = "specVersion")]
+#[serde(untagged)]
 pub enum Config {
     #[serde(rename = "2025_08_22")]
     V2025_08_22(AgentConfigV2025_08_22),
@@ -50,9 +51,9 @@ impl Config {
         }
     }
 
-    pub fn tool_settings(&self) -> &ToolSettings {
+    pub fn tool_settings(&self) -> Option<&ToolSettings> {
         match self {
-            Config::V2025_08_22(a) => &a.tool_settings,
+            Config::V2025_08_22(a) => a.tool_settings.as_ref(),
         }
     }
 
@@ -74,9 +75,9 @@ impl Config {
         }
     }
 
-    pub fn mcp_servers(&self) -> Option<&McpServers> {
+    pub fn mcp_servers(&self) -> &HashMap<String, McpServerConfig> {
         match self {
-            Config::V2025_08_22(a) => a.mcp_servers.as_ref(),
+            Config::V2025_08_22(a) => &a.mcp_servers,
         }
     }
 
@@ -120,9 +121,10 @@ pub struct AgentConfigV2025_08_22 {
     pub tool_aliases: HashMap<String, String>,
     /// Settings for specific tools
     #[serde(default)]
-    pub tool_settings: ToolSettings,
+    pub tool_settings: Option<ToolSettings>,
     /// A JSON schema specification describing the arguments for when this agent is invoked as a
     /// tool.
+    #[serde(default)]
     pub tool_schema: Option<InputSchema>,
 
     /// Hooks to add additional context
@@ -132,12 +134,13 @@ pub struct AgentConfigV2025_08_22 {
     ///
     /// TODO: unimplemented
     #[serde(skip)]
+    #[allow(dead_code)]
     pub model_preferences: Option<ModelPreferences>,
 
     // mcp
     /// Configuration for Model Context Protocol (MCP) servers
     #[serde(default)]
-    pub mcp_servers: Option<McpServers>,
+    pub mcp_servers: HashMap<String, McpServerConfig>,
     /// Whether or not to include the legacy ~/.aws/amazonq/mcp.json in the agent
     ///
     /// You can reference tools brought in by these servers as just as you would with the servers
@@ -198,6 +201,7 @@ pub struct FileWriteSettings {
 
 /// This mirrors claude's config set up.
 #[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema)]
+#[serde(rename_all = "camelCase")]
 pub struct McpServers {
     pub mcp_servers: HashMap<String, McpServerConfig>,
 }

crates/agent/src/agent/agent_config/manager.rs

@@ -0,0 +1,119 @@
+//! Unused code
+
+#[derive(Debug, Clone)]
+pub struct ConfigHandle {
+    /// Sender for sending requests to the tool manager task
+    sender: RequestSender<AgentConfigRequest, AgentConfigResponse, AgentConfigError>,
+}
+
+impl ConfigHandle {
+    pub async fn get_config(&self, agent_name: &str) -> Result<AgentConfig, AgentConfigError> {
+        match self
+            .sender
+            .send_recv(AgentConfigRequest::GetConfig {
+                agent_name: agent_name.to_string(),
+            })
+            .await
+            .unwrap_or(Err(AgentConfigError::Channel))?
+        {
+            AgentConfigResponse::Config(agent_config) => Ok(agent_config),
+            other => {
+                error!(?other, "received unexpected response");
+                Err(AgentConfigError::Custom("received unexpected response".to_string()))
+            },
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct AgentConfigManager {
+    configs: Vec<AgentConfig>,
+
+    request_tx: RequestSender<AgentConfigRequest, AgentConfigResponse, AgentConfigError>,
+    request_rx: RequestReceiver<AgentConfigRequest, AgentConfigResponse, AgentConfigError>,
+}
+
+impl AgentConfigManager {
+    pub fn new() -> Self {
+        let (request_tx, request_rx) = new_request_channel();
+        Self {
+            configs: Vec::new(),
+            request_tx,
+            request_rx,
+        }
+    }
+
+    pub async fn spawn(mut self) -> Result<(ConfigHandle, Vec<AgentConfigError>)> {
+        let request_tx_clone = self.request_tx.clone();
+
+        // TODO - return errors back.
+        let (configs, errors) = load_agents().await?;
+        self.configs = configs;
+
+        tokio::spawn(async move {
+            self.run().await;
+        });
+
+        Ok((
+            ConfigHandle {
+                sender: request_tx_clone,
+            },
+            errors,
+        ))
+    }
+
+    async fn run(mut self) {
+        loop {
+            tokio::select! {
+                req = self.request_rx.recv() => {
+                    let Some(req) = req else {
+                        warn!("Agent config request channel has closed, exiting");
+                        break;
+                    };
+                    let res = self.handle_agent_config_request(req.payload).await;
+                    respond!(req, res);
+                }
+            }
+        }
+    }
+
+    async fn handle_agent_config_request(
+        &mut self,
+        req: AgentConfigRequest,
+    ) -> Result<AgentConfigResponse, AgentConfigError> {
+        match req {
+            AgentConfigRequest::GetConfig { agent_name } => {
+                let agent_config = self
+                    .configs
+                    .iter()
+                    .find_map(|a| {
+                        if a.config.name() == agent_name {
+                            Some(a.clone())
+                        } else {
+                            None
+                        }
+                    })
+                    .ok_or(AgentConfigError::AgentNotFound { name: agent_name })?;
+                Ok(AgentConfigResponse::Config(agent_config))
+            },
+            AgentConfigRequest::GetAllConfigs => {
+                todo!()
+            },
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum AgentConfigRequest {
+    GetConfig { agent_name: String },
+    GetAllConfigs,
+}
+
+#[derive(Debug, Clone)]
+pub enum AgentConfigResponse {
+    Config(AgentConfig),
+    AllConfigs {
+        configs: Vec<AgentConfig>,
+        invalid_configs: Vec<()>,
+    },
+}