rho-coding-agent 2.22.0

A fast Rust agent harness with a small footprint and opinionated defaults
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! Converts host-supplied ACP `mcpServers` into session-scoped MCP config.
//!
//! Hosts such as T3 Code hand every session the MCP servers that expose host
//! features (browser preview, orchestration). Rho connects them alongside the
//! servers from its own config. A host entry whose name matches a config
//! server replaces it for that session, because the host's entry carries
//! session-specific credentials. That holds even when the host entry is
//! invalid: the config server is suppressed rather than silently connected
//! under an identity the host meant to replace.

use std::collections::BTreeMap;

use agent_client_protocol::schema::v1::{McpServer, McpServerHttp, McpServerStdio};

use crate::tools::mcp::{
    config::{
        InvalidMcpServer, McpConfig, McpSamplingPolicy, McpServerConfig, McpToolFilter,
        McpTransport,
    },
    parse_remote_url, validate_identity, validate_literal_headers, validate_stdio_environment,
};

/// Overlays host `mcpServers` onto the process MCP config for one session.
pub(super) fn overlay_host_mcp(process: &mut McpConfig, servers: &[McpServer]) {
    let host = host_mcp_config(servers);
    for invalid in &host.invalid_servers {
        if process.servers.remove(&invalid.identity).is_some() {
            tracing::warn!(server = %invalid.identity, "host MCP entry is invalid; not connecting the configured server it replaces");
        }
    }
    process.merge(host);
}

/// Builds the session's host MCP config. When a name repeats, the last entry
/// wins whether it is valid or not. Invalid entries land in `invalid_servers`
/// so the MCP report shows them; transports Rho cannot speak are logged and
/// skipped.
fn host_mcp_config(servers: &[McpServer]) -> McpConfig {
    let mut config = McpConfig::default();
    for server in servers {
        let (name, converted) = match server {
            McpServer::Stdio(stdio) => (stdio.name.as_str(), stdio_server(stdio)),
            McpServer::Http(http) => (http.name.as_str(), http_server(http)),
            McpServer::Sse(sse) => {
                tracing::warn!(server = %sse.name, "skipping host MCP server: SSE transport is not supported");
                continue;
            }
            // McpServer is non_exhaustive; a transport Rho does not know cannot connect.
            _ => {
                tracing::warn!("skipping host MCP server with an unsupported transport");
                continue;
            }
        };
        let converted =
            validate_identity(name).and_then(|()| converted.map(|server| (name, server)));
        let replaced_valid = config.servers.remove(name).is_some();
        let before = config.invalid_servers.len();
        config
            .invalid_servers
            .retain(|invalid| invalid.identity != name);
        if replaced_valid || config.invalid_servers.len() != before {
            tracing::warn!(server = %name, "host MCP server listed twice; keeping the last entry");
        }
        match converted {
            Ok((name, server)) => {
                config.servers.insert(name.to_string(), server);
            }
            Err(error) => config.invalid_servers.push(InvalidMcpServer {
                identity: name.to_string(),
                error: format!("{error:#}"),
            }),
        }
    }
    config
}

fn stdio_server(server: &McpServerStdio) -> anyhow::Result<McpServerConfig> {
    let command = server.command.to_string_lossy().into_owned();
    if command.trim().is_empty() {
        anyhow::bail!("stdio command must not be empty");
    }
    let mut env = BTreeMap::new();
    for variable in &server.env {
        if env
            .insert(variable.name.clone(), variable.value.clone())
            .is_some()
        {
            anyhow::bail!("stdio env repeats child variable `{}`", variable.name);
        }
    }
    let env_from_env = BTreeMap::new();
    validate_stdio_environment(&env, &env_from_env)?;
    Ok(host_server(McpTransport::Stdio {
        command,
        args: server.args.clone(),
        cwd: None,
        env,
        env_from_env,
    }))
}

fn http_server(server: &McpServerHttp) -> anyhow::Result<McpServerConfig> {
    // Host entries get the same transport rule as plugin servers: HTTPS, or
    // plain HTTP only to loopback. Only the user's own config may opt out.
    parse_remote_url(&server.url)?;
    let mut headers = BTreeMap::new();
    for header in &server.headers {
        if headers
            .insert(header.name.clone(), header.value.clone())
            .is_some()
        {
            anyhow::bail!("header `{}` is listed twice", header.name);
        }
    }
    validate_literal_headers(&headers)?;
    Ok(host_server(McpTransport::StreamableHttp {
        url: server.url.clone(),
        headers,
        headers_from_env: BTreeMap::new(),
        oauth: None,
        allow_insecure_http: false,
    }))
}

fn host_server(transport: McpTransport) -> McpServerConfig {
    McpServerConfig {
        enabled: true,
        tools: McpToolFilter::default(),
        log_level: None,
        // A host cannot opt a server into spending the user's model tokens.
        sampling: McpSamplingPolicy::Deny,
        transport,
        filesystem: None,
    }
}

#[cfg(test)]
#[path = "host_mcp_tests.rs"]
mod tests;