modelcontextprotocol 0.2.4

Filesystem, Fetch, Memory, Shell, Skills, and Agents MCP servers in a single binary, implementing the Model Context Protocol 2026-07-28 specification.
use crate::agents::definition::*;
use anyhow::{Context, Result, bail};
use std::{collections::BTreeMap, path::PathBuf};
use toml::Table;
use url::Url;
const MAX_FILE_BYTES: usize = 1024 * 1024;
pub(crate) fn parse_toml(path: PathBuf, input: &str) -> Result<AgentDefinition> {
    if input.len() > MAX_FILE_BYTES {
        bail!("agent TOML exceeds 1 MiB")
    }
    let t: Table = toml::from_str(input).context("invalid agent TOML")?;
    reject_provider_secrets(&t)?;
    let name = required(&t, "name")?;
    validate_name(&name)?;
    let description = required(&t, "description")?;
    let instructions = string(&t, "instructions")
        .or_else(|| string(&t, "developer_instructions"))
        .filter(|v| !v.trim().is_empty())
        .context("instructions is required")?;
    let model = required(&t, "model")?;
    let provider = parse_provider(
        &string_alias(&t, &["model_provider", "modelProvider"]).unwrap_or_else(|| "openai".into()),
    )?;
    let (base_url, env_key, wire_api) = endpoint(
        &provider,
        string_alias(&t, &["base_url", "baseUrl"]).as_deref(),
        string_alias(&t, &["env_key", "envKey"]).as_deref(),
        string_alias(&t, &["wire_api", "wireApi"]).as_deref(),
    )?;
    let temperature = t
        .get("temperature")
        .and_then(|v| v.as_float())
        .map(|v| v as f32);
    if let Some(v) = temperature {
        validate_temperature(v, &wire_api)?
    }
    let reasoning_effort = string_alias(&t, &["model_reasoning_effort", "reasoning_effort"])
        .map(|v| normalize_reasoning_effort(&v))
        .transpose()?;
    let turns =
        integer_alias(&t, &["max_turns", "maxTurns", "steps"]).unwrap_or(DEFAULT_MAX_TURNS as i64);
    if !(1..=MAX_TURNS as i64).contains(&turns) {
        bail!("max_turns must be between 1 and {MAX_TURNS}")
    }
    Ok(AgentDefinition {
        name,
        description,
        instructions,
        model,
        provider,
        base_url,
        env_key,
        wire_api,
        reasoning_effort,
        temperature,
        max_turns: turns as u32,
        permission: PermissionPolicy {
            mode: string_alias(&t, &["permission", "permission_mode"])
                .as_deref()
                .map(parse_permission)
                .transpose()?
                .unwrap_or(PermissionMode::Default),
            allowed_mcp_tools: None,
            disallowed_mcp_tools: Default::default(),
        },
        sandbox: string(&t, "sandbox_mode")
            .as_deref()
            .map(parse_sandbox)
            .transpose()?
            .unwrap_or(SandboxMode::Default),
        isolation: string(&t, "isolation")
            .as_deref()
            .map(parse_isolation)
            .transpose()?
            .unwrap_or(IsolationMode::None),
        skills: strings(&t, "skills")?,
        mcp_servers: mcp_servers(&t)?,
        source_path: path,
    })
}
fn string(t: &Table, k: &str) -> Option<String> {
    t.get(k).and_then(|v| v.as_str()).map(str::to_owned)
}
fn string_alias(t: &Table, keys: &[&str]) -> Option<String> {
    keys.iter().find_map(|k| string(t, k))
}
fn required(t: &Table, k: &str) -> Result<String> {
    string(t, k)
        .filter(|v| !v.trim().is_empty())
        .context(format!("{k} is required"))
}
fn integer_alias(t: &Table, keys: &[&str]) -> Option<i64> {
    keys.iter()
        .find_map(|k| t.get(*k).and_then(|v| v.as_integer()))
}
fn strings(t: &Table, k: &str) -> Result<Vec<String>> {
    match t.get(k) {
        None => Ok(vec![]),
        Some(v) => v
            .as_array()
            .context(format!("{k} must be an array"))?
            .iter()
            .map(|v| {
                v.as_str()
                    .map(str::to_owned)
                    .context("array entries must be strings")
            })
            .collect(),
    }
}
fn reject_provider_secrets(t: &Table) -> Result<()> {
    for k in ["api_key", "apiKey", "token", "access_token", "accessToken"] {
        if t.contains_key(k) {
            bail!("literal secret field {k} is prohibited")
        }
    }
    if let Some(provider) = t.get("provider").and_then(|v| v.as_table()) {
        for k in ["api_key", "apiKey", "token", "access_token", "accessToken"] {
            if provider.contains_key(k) {
                bail!("literal provider secret field {k} is prohibited")
            }
        }
    }
    Ok(())
}
fn endpoint(
    provider: &ModelProviderKind,
    base: Option<&str>,
    env: Option<&str>,
    wire: Option<&str>,
) -> Result<(Url, String, WireApi)> {
    if matches!(provider, ModelProviderKind::Custom) {
        let url = Url::parse(base.context("custom provider requires base_url")?)?;
        validate_endpoint(&url)?;
        let key = env.context("custom provider requires env_key")?.to_owned();
        validate_env_key(&key)?;
        return Ok((
            url,
            key,
            parse_wire_api(wire.context("custom provider requires wire_api")?)?,
        ));
    }
    let (mut url, mut key, mut api) = defaults_for(provider)?;
    if let Some(v) = base {
        url = Url::parse(v)?;
        validate_endpoint(&url)?
    }
    if let Some(v) = env {
        validate_env_key(v)?;
        key = v.into()
    }
    if let Some(v) = wire {
        api = parse_wire_api(v)?
    }
    validate_provider_wire(provider, &api)?;
    Ok((url, key, api))
}
fn mcp_servers(t: &Table) -> Result<BTreeMap<String, McpServerDefinition>> {
    let Some(servers) = t.get("mcp_servers").or_else(|| t.get("mcpServers")) else {
        return Ok(BTreeMap::new());
    };
    servers
        .as_table()
        .context("mcp_servers must be a table")?
        .iter()
        .map(|(name, value)| {
            let c = value.as_table().context("MCP server must be a table")?;
            let server = match string(c, "type").as_deref() {
                Some("sse") => bail!("MCP server type sse is deprecated"),
                Some("http") => McpServerDefinition::Http {
                    url: checked_url(&required(c, "url")?)?,
                    headers: string_map(c, "headers")?,
                },
                Some("stdio") | None if c.contains_key("command") => McpServerDefinition::Stdio {
                    command: required(c, "command")?,
                    args: strings(c, "args")?,
                    env: string_map(c, "env")?,
                },
                _ => bail!("unsupported MCP server type"),
            };
            Ok((name.clone(), server))
        })
        .collect()
}
fn checked_url(s: &str) -> Result<Url> {
    let u = Url::parse(s)?;
    validate_endpoint(&u)?;
    Ok(u)
}
fn string_map(t: &Table, k: &str) -> Result<BTreeMap<String, String>> {
    match t.get(k) {
        None => Ok(BTreeMap::new()),
        Some(v) => v
            .as_table()
            .context(format!("{k} must be a table"))?
            .iter()
            .map(|(k, v)| {
                Ok((
                    k.clone(),
                    v.as_str().context("map values must be strings")?.into(),
                ))
            })
            .collect(),
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn codex_reasoning_temperature_and_sse_validation() {
        let valid = "name='a'\ndescription='x'\ninstructions='body'\nmodel='gpt'\nmodel_reasoning_effort='medium'\ntemperature=2.0\n[mcp_servers.local]\ntype='stdio'\ncommand='node'";
        let agent = parse_toml(PathBuf::from("a.toml"), valid).unwrap();
        assert_eq!(agent.reasoning_effort.as_deref(), Some("medium"));
        let invalid = "name='a'\ndescription='x'\ninstructions='body'\nmodel='gpt'\n[mcp_servers.old]\ntype='sse'\nurl='https://example.test'";
        assert!(parse_toml(PathBuf::from("a.toml"), invalid).is_err());
    }
    #[test]
    fn provider_wire_conflicts_are_rejected() {
        let input = "name='a'\ndescription='x'\ninstructions='body'\nmodel='gpt'\nwire_api='anthropic-messages'";
        assert!(parse_toml(PathBuf::from("a.toml"), input).is_err());
    }

    #[test]
    fn toml_security_modes_fail_closed() {
        let base = "name='a'\ndescription='x'\ninstructions='body'\nmodel='gpt'\n";
        assert!(parse_toml(PathBuf::from("a.toml"), &format!("{base}isolation='none'")).is_ok());
        for field in [
            "isolation='worktree'",
            "isolation='container'",
            "sandbox_mode='workspace-write'",
            "sandbox_mode='danger-full-access'",
        ] {
            assert!(parse_toml(PathBuf::from("a.toml"), &format!("{base}{field}")).is_err());
        }
    }
}