More WIP cleanup

Author: brandonskiser

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

@@ -88,7 +88,6 @@ impl Config {
     }
 }
 
-// TODO: use default implementation as an orchestrator agent
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]
 #[schemars(description = "An Agent is a declarative way of configuring a given instance of q chat.")]
@@ -176,7 +175,7 @@ impl Default for AgentConfigV2025_08_22 {
             use_legacy_mcp_json: false,
 
             resources: Default::default(),
-            allowed_tools: Default::default(),
+            allowed_tools: HashSet::from([BuiltInToolName::FileRead.to_string()]),
         }
     }
 }
@@ -382,6 +381,6 @@ mod tests {
             "description": "The orchestrator agent",
         });
 
-        let agent: Config = serde_json::from_value(agent).unwrap();
+        let _: Config = serde_json::from_value(agent).unwrap();
     }
 }

crates/agent/src/agent/agent_config/mod.rs

@@ -49,6 +49,7 @@ use crate::agent::util::error::{
 #[derive(Debug, Clone)]
 pub struct AgentConfig {
     /// Where the config was sourced from
+    #[allow(dead_code)]
     source: ConfigSource,
     /// The actual config content
     config: Config,
@@ -260,16 +261,20 @@ async fn load_agents_from_dir(
 #[derive(Debug, Clone)]
 pub struct LoadedMcpServerConfig {
     /// The name (aka id) to associate with the config
-    pub name: String,
+    pub server_name: String,
     /// The mcp server config
     pub config: McpServerConfig,
     /// Where the config originated from
     pub source: McpServerConfigSource,
 }
 
 impl LoadedMcpServerConfig {
-    fn new(name: String, config: McpServerConfig, source: McpServerConfigSource) -> Self {
-        Self { name, config, source }
+    fn new(server_name: String, config: McpServerConfig, source: McpServerConfigSource) -> Self {
+        Self {
+            server_name,
+            config,
+            source,
+        }
     }
 }
 
@@ -303,8 +308,12 @@ impl LoadedMcpServerConfigs {
         if config.use_legacy_mcp_json() {
             let mut push_configs = |mcp_servers: McpServers, source: McpServerConfigSource| {
                 for (name, config) in mcp_servers.mcp_servers {
-                    let config = LoadedMcpServerConfig { name, config, source };
-                    if configs.iter().any(|c| c.name == config.name) {
+                    let config = LoadedMcpServerConfig {
+                        server_name: name,
+                        config,
+                        source,
+                    };
+                    if configs.iter().any(|c| c.server_name == config.server_name) {
                         overwritten_configs.push(config);
                     } else {
                         configs.push(config);
@@ -336,6 +345,10 @@ impl LoadedMcpServerConfigs {
             overridden_configs: overwritten_configs,
         }
     }
+
+    pub fn server_names(&self) -> Vec<String> {
+        self.configs.iter().map(|c| c.server_name.clone()).collect()
+    }
 }
 
 /// Where an [McpServerConfig] originated from

crates/agent/src/agent/agent_config/parse.rs

@@ -1,3 +1,5 @@
+//! Utilities for semantic parsing of agent config values
+
 use std::borrow::Cow;
 use std::str::FromStr;
 
@@ -6,14 +8,7 @@ use crate::agent::protocol::AgentError;
 use crate::agent::tools::BuiltInToolName;
 use crate::agent::util::path::canonicalize_path;
 
-#[derive(Debug, Clone)]
-pub struct Resource {
-    /// Exact value from the config this resource was taken from
-    pub config_value: String,
-    /// Resource content
-    pub content: String,
-}
-
+/// Represents a value from the `resources` array in the agent config.
 pub enum ResourceKind<'a> {
     File { original: &'a str, file_path: &'a str },
     FileGlob { original: &'a str, pattern: glob::Pattern },
@@ -22,7 +17,7 @@ pub enum ResourceKind<'a> {
 impl<'a> ResourceKind<'a> {
     pub fn parse(value: &'a str) -> Result<Self, String> {
         if !value.starts_with("file://") {
-            return Err("Only file schemes are supported now".to_string());
+            return Err("Only file schemes are currently supported".to_string());
         }
 
         let file_path = value.trim_start_matches("file://");

crates/agent/src/agent/agent_loop/mod.rs

@@ -322,7 +322,7 @@ impl AgentLoop {
                     self.loop_event_tx.send(ev).await.ok();
                 }
 
-                Ok(AgentLoopResponse::Metadata(metadata))
+                Ok(AgentLoopResponse::Metadata(Box::new(metadata)))
             },
         }
     }
@@ -679,7 +679,7 @@ impl AgentLoopHandle {
             .await
             .unwrap_or(Err(AgentLoopResponseError::AgentLoopExited))?
         {
-            AgentLoopResponse::Metadata(md) => Ok(md),
+            AgentLoopResponse::Metadata(md) => Ok(*md),
             other => Err(AgentLoopResponseError::Custom(format!(
                 "unknown response getting execution state: {:?}",
                 other,

crates/agent/src/agent/agent_loop/model.rs

@@ -87,23 +87,23 @@ impl Model for Models {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct TestModel {}
 
 impl TestModel {
     pub fn new() -> Self {
-        Self {}
+        Self::default()
     }
 }
 
 impl Model for TestModel {
     fn stream(
         &self,
-        messages: Vec<Message>,
-        tool_specs: Option<Vec<ToolSpec>>,
-        system_prompt: Option<String>,
-        cancel_token: CancellationToken,
+        _messages: Vec<Message>,
+        _tool_specs: Option<Vec<ToolSpec>>,
+        _system_prompt: Option<String>,
+        _cancel_token: CancellationToken,
     ) -> Pin<Box<dyn Stream<Item = Result<StreamEvent, StreamError>> + Send + 'static>> {
-        todo!()
+        panic!("unimplemented")
     }
 }

crates/agent/src/agent/agent_loop/protocol.rs

@@ -59,7 +59,7 @@ pub enum AgentLoopResponse {
     ExecutionState(LoopState),
     StreamMetadata(Vec<StreamMetadata>),
     PendingToolUses(Option<Vec<ToolUseBlock>>),
-    Metadata(UserTurnMetadata),
+    Metadata(Box<UserTurnMetadata>),
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, thiserror::Error)]

crates/agent/src/agent/mcp/actor.rs

@@ -41,14 +41,14 @@ use crate::agent::util::request_channel::{
 /// Represents a message from an MCP server to the client.
 #[derive(Debug)]
 pub enum McpMessage {
-    ToolsResult(Result<Vec<RmcpTool>, ServiceError>),
-    PromptsResult(Result<Vec<RmcpPrompt>, ServiceError>),
-    ExecuteToolResult { request_id: u32, result: ExecuteToolResult },
+    Tools(Result<Vec<RmcpTool>, ServiceError>),
+    Prompts(Result<Vec<RmcpPrompt>, ServiceError>),
+    ExecuteTool { request_id: u32, result: ExecuteToolResult },
 }
 
 #[derive(Debug)]
 pub struct McpServerActorHandle {
-    server_name: String,
+    _server_name: String,
     sender: RequestSender<McpServerActorRequest, McpServerActorResponse, McpServerActorError>,
     event_rx: mpsc::Receiver<McpServerActorEvent>,
 }
@@ -172,8 +172,8 @@ pub enum McpServerActorEvent {
 pub struct McpServerActor {
     /// Name of the MCP server
     server_name: String,
-    /// Config the server was launched with
-    config: McpServerConfig,
+    /// Config the server was launched with. Kept for debug purposes.
+    _config: McpServerConfig,
     /// Tools
     tools: Vec<ToolSpec>,
     /// Prompts
@@ -203,7 +203,7 @@ impl McpServerActor {
         tokio::spawn(async move { Self::launch(server_name_clone, config, req_rx, event_tx).await });
 
         McpServerActorHandle {
-            server_name,
+            _server_name: server_name,
             sender: req_tx,
             event_rx,
         }
@@ -223,7 +223,7 @@ impl McpServerActor {
             Ok((service_handle, launch_md)) => {
                 let s = Self {
                     server_name,
-                    config,
+                    _config: config,
                     tools: launch_md.tools.unwrap_or_default(),
                     prompts: launch_md.prompts.unwrap_or_default(),
                     service_handle,
@@ -292,9 +292,7 @@ impl McpServerActor {
                         })
                         .await
                         .map_err(McpServerActorError::from);
-                    let _ = message_tx
-                        .send(McpMessage::ExecuteToolResult { request_id, result })
-                        .await;
+                    let _ = message_tx.send(McpMessage::ExecuteTool { request_id, result }).await;
                 });
                 self.executing_tools.insert(self.curr_tool_execution_id, tx);
                 Ok(McpServerActorResponse::ExecuteTool(rx))
@@ -309,19 +307,19 @@ impl McpServerActor {
             return;
         };
         match msg {
-            McpMessage::ToolsResult(res) => match res {
+            McpMessage::Tools(res) => match res {
                 Ok(tools) => self.tools = tools.into_iter().map(Into::into).collect(),
                 Err(err) => {
                     error!(?err, "failed to list tools");
                 },
             },
-            McpMessage::PromptsResult(res) => match res {
+            McpMessage::Prompts(res) => match res {
                 Ok(prompts) => self.prompts = prompts.into_iter().map(Into::into).collect(),
                 Err(err) => {
                     error!(?err, "failed to list prompts");
                 },
             },
-            McpMessage::ExecuteToolResult { request_id, result } => match self.executing_tools.remove(&request_id) {
+            McpMessage::ExecuteTool { request_id, result } => match self.executing_tools.remove(&request_id) {
                 Some(tx) => {
                     let _ = tx.send(result);
                 },
@@ -337,22 +335,24 @@ impl McpServerActor {
     }
 
     /// Asynchronously fetch all tools
+    #[allow(dead_code)]
     fn refresh_tools(&self) {
         let service_handle = self.service_handle.clone();
         let tx = self.message_tx.clone();
         tokio::spawn(async move {
             let res = service_handle.list_tools().await;
-            let _ = tx.send(McpMessage::ToolsResult(res)).await;
+            let _ = tx.send(McpMessage::Tools(res)).await;
         });
     }
 
     /// Asynchronously fetch all prompts
+    #[allow(dead_code)]
     fn refresh_prompts(&self) {
         let service_handle = self.service_handle.clone();
         let tx = self.message_tx.clone();
         tokio::spawn(async move {
             let res = service_handle.list_prompts().await;
-            let _ = tx.send(McpMessage::PromptsResult(res)).await;
+            let _ = tx.send(McpMessage::Prompts(res)).await;
         });
     }
 }