Add integ tests, update agent protocol

Author: brandonskiser

Cargo.lock

@@ -216,6 +216,3 @@ opt-level = 3
 
 [profile.dev.package.similar]
 opt-level = 3
-
-[profile.dev.package.backtrace]
-opt-level = 3

Cargo.toml

@@ -58,6 +58,7 @@ rustls-native-certs.workspace = true
 schemars = "1.0.4"
 semver.workspace = true
 serde.workspace = true
+serde_bytes = "0.11.19"
 serde_json.workspace = true
 sha2.workspace = true
 shellexpand.workspace = true

crates/agent/Cargo.toml

@@ -14,78 +14,77 @@ use crate::agent::consts::DEFAULT_AGENT_NAME;
 use crate::agent::tools::BuiltInToolName;
 
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
-// #[serde(tag = "specVersion")]
 #[serde(untagged)]
-pub enum Config {
+pub enum AgentConfig {
     #[serde(rename = "2025_08_22")]
     V2025_08_22(AgentConfigV2025_08_22),
 }
 
-impl Default for Config {
+impl Default for AgentConfig {
     fn default() -> Self {
         Self::V2025_08_22(AgentConfigV2025_08_22::default())
     }
 }
 
-impl Config {
+impl AgentConfig {
     pub fn name(&self) -> &str {
         match self {
-            Config::V2025_08_22(a) => a.name.as_str(),
+            AgentConfig::V2025_08_22(a) => a.name.as_str(),
         }
     }
 
     pub fn system_prompt(&self) -> Option<&str> {
         match self {
-            Config::V2025_08_22(a) => a.system_prompt.as_deref(),
+            AgentConfig::V2025_08_22(a) => a.system_prompt.as_deref(),
         }
     }
 
     pub fn tools(&self) -> Vec<String> {
         match self {
-            Config::V2025_08_22(a) => a.tools.clone(),
+            AgentConfig::V2025_08_22(a) => a.tools.clone(),
         }
     }
 
     pub fn tool_aliases(&self) -> &HashMap<String, String> {
         match self {
-            Config::V2025_08_22(a) => &a.tool_aliases,
+            AgentConfig::V2025_08_22(a) => &a.tool_aliases,
         }
     }
 
     pub fn tool_settings(&self) -> Option<&ToolSettings> {
         match self {
-            Config::V2025_08_22(a) => a.tool_settings.as_ref(),
+            AgentConfig::V2025_08_22(a) => a.tool_settings.as_ref(),
         }
     }
 
     pub fn allowed_tools(&self) -> &HashSet<String> {
         match self {
-            Config::V2025_08_22(a) => &a.allowed_tools,
+            AgentConfig::V2025_08_22(a) => &a.allowed_tools,
         }
     }
 
     pub fn hooks(&self) -> &HashMap<HookTrigger, Vec<HookConfig>> {
         match self {
-            Config::V2025_08_22(a) => &a.hooks,
+            AgentConfig::V2025_08_22(a) => &a.hooks,
         }
     }
 
     // pub fn resources(&self) -> &[impl AsRef<str>] {
     pub fn resources(&self) -> &[impl AsRef<str>] {
         match self {
-            Config::V2025_08_22(a) => a.resources.as_slice(),
+            AgentConfig::V2025_08_22(a) => a.resources.as_slice(),
         }
     }
 
     pub fn mcp_servers(&self) -> &HashMap<String, McpServerConfig> {
         match self {
-            Config::V2025_08_22(a) => &a.mcp_servers,
+            AgentConfig::V2025_08_22(a) => &a.mcp_servers,
         }
     }
 
     pub fn use_legacy_mcp_json(&self) -> bool {
         match self {
-            Config::V2025_08_22(a) => a.use_legacy_mcp_json,
+            AgentConfig::V2025_08_22(a) => a.use_legacy_mcp_json,
         }
     }
 }
@@ -112,7 +111,6 @@ pub struct AgentConfigV2025_08_22 {
     ///
     /// fs_read
     /// fs_write
-    /// directory
     /// @mcp_server_name/tool_name
     /// #agent_name
     #[serde(default)]
@@ -193,18 +191,18 @@ impl Default for AgentConfigV2025_08_22 {
 
 #[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema)]
 pub struct ToolSettings {
-    pub file_read: FileReadSettings,
-    pub file_write: FileWriteSettings,
+    pub fs_read: FsReadSettings,
+    pub fs_write: FsWriteSettings,
 }
 
 #[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema)]
-pub struct FileReadSettings {
+pub struct FsReadSettings {
     pub allowed_paths: Vec<String>,
     pub denied_paths: Vec<String>,
 }
 
 #[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema)]
-pub struct FileWriteSettings {
+pub struct FsWriteSettings {
     pub allowed_paths: Vec<String>,
     pub denied_paths: Vec<String>,
 }
@@ -392,6 +390,6 @@ mod tests {
             "description": "The orchestrator agent",
         });
 
-        let _: Config = serde_json::from_value(agent).unwrap();
+        let _: AgentConfig = serde_json::from_value(agent).unwrap();
     }
 }

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

@@ -12,7 +12,7 @@ use std::path::{
 };
 
 use definitions::{
-    Config,
+    AgentConfig,
     HookConfig,
     HookTrigger,
     McpServerConfig,
@@ -53,11 +53,11 @@ pub struct LoadedAgentConfig {
     #[allow(dead_code)]
     source: ConfigSource,
     /// The actual config content
-    config: Config,
+    config: AgentConfig,
 }
 
 impl LoadedAgentConfig {
-    pub fn config(&self) -> &Config {
+    pub fn config(&self) -> &AgentConfig {
         &self.config
     }
 
@@ -190,18 +190,18 @@ pub async fn load_agents() -> Result<(Vec<LoadedAgentConfig>, Vec<AgentConfigErr
     Ok((agent_configs, invalid_agents))
 }
 
-pub async fn load_workspace_agents() -> Result<(Vec<(PathBuf, Config)>, Vec<AgentConfigError>)> {
+pub async fn load_workspace_agents() -> Result<(Vec<(PathBuf, AgentConfig)>, Vec<AgentConfigError>)> {
     load_agents_from_dir(local_agents_path()?, true).await
 }
 
-pub async fn load_global_agents() -> Result<(Vec<(PathBuf, Config)>, Vec<AgentConfigError>)> {
+pub async fn load_global_agents() -> Result<(Vec<(PathBuf, AgentConfig)>, Vec<AgentConfigError>)> {
     load_agents_from_dir(global_agents_path()?, true).await
 }
 
 async fn load_agents_from_dir(
     dir: impl AsRef<Path>,
     create_if_missing: bool,
-) -> Result<(Vec<(PathBuf, Config)>, Vec<AgentConfigError>)> {
+) -> Result<(Vec<(PathBuf, AgentConfig)>, Vec<AgentConfigError>)> {
     let dir = dir.as_ref();
 
     if !dir.exists() && create_if_missing {
@@ -214,7 +214,7 @@ async fn load_agents_from_dir(
         .await
         .with_context(|| format!("failed to read local agents directory {:?}", &dir))?;
 
-    let mut agents: Vec<(PathBuf, Config)> = vec![];
+    let mut agents: Vec<(PathBuf, AgentConfig)> = vec![];
     let mut invalid_agents: Vec<AgentConfigError> = vec![];
 
     loop {
@@ -294,7 +294,7 @@ pub struct LoadedMcpServerConfigs {
 impl LoadedMcpServerConfigs {
     /// Loads MCP configs from the given agent config, taking into consideration global and
     /// workspace MCP config files for when the use_legacy_mcp_json field is true.
-    pub async fn from_agent_config(config: &Config) -> LoadedMcpServerConfigs {
+    pub async fn from_agent_config(config: &AgentConfig) -> LoadedMcpServerConfigs {
         let mut configs = vec![];
         let mut overwritten_configs = vec![];
 

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

@@ -3,8 +3,6 @@
 use std::borrow::Cow;
 use std::str::FromStr;
 
-use crate::agent::agent_loop::types::ToolUseBlock;
-use crate::agent::protocol::AgentError;
 use crate::agent::tools::BuiltInToolName;
 use crate::agent::util::path::canonicalize_path_sys;
 use crate::agent::util::providers::{
@@ -125,51 +123,6 @@ impl<'a> ToolNameKind<'a> {
     }
 }
 
-#[derive(Debug, Clone, thiserror::Error)]
-#[error("Failed to parse the tool use: {}", .kind)]
-pub struct ToolParseError {
-    pub tool_use: ToolUseBlock,
-    #[source]
-    pub kind: ToolParseErrorKind,
-}
-
-impl ToolParseError {
-    pub fn new(tool_use: ToolUseBlock, kind: ToolParseErrorKind) -> Self {
-        Self { tool_use, kind }
-    }
-}
-
-/// Errors associated with parsing a tool use as requested by the model into a tool ready to be
-/// executed.
-///
-/// Captures any errors that can occur right up to tool execution.
-///
-/// Tool parsing failures can occur in different stages:
-/// - Mapping the tool name to an actual tool JSON schema
-/// - Parsing the tool input arguments according to the tool's JSON schema
-/// - Tool-specific semantic validation of the input arguments
-#[derive(Debug, Clone, thiserror::Error)]
-pub enum ToolParseErrorKind {
-    #[error("A tool with the name '{}' does not exist", .0)]
-    NameDoesNotExist(String),
-    #[error("The tool input does not match the tool schema: {}", .0)]
-    SchemaFailure(String),
-    #[error("The tool arguments failed validation: {}", .0)]
-    InvalidArgs(String),
-    #[error("An unexpected error occurred parsing the tools: {}", .0)]
-    Other(#[from] AgentError),
-}
-
-impl ToolParseErrorKind {
-    pub fn schema_failure<T: std::error::Error>(error: T) -> Self {
-        Self::SchemaFailure(error.to_string())
-    }
-
-    pub fn invalid_args(error_message: String) -> Self {
-        Self::InvalidArgs(error_message)
-    }
-}
-
 /// Represents the authoritative source of a single tool name - essentially, tool names before
 /// undergoing any transformations.
 ///