[MCP] Add experimental support for streamable HTTP MCP servers (#4317)

This PR adds support for streamable HTTP MCP servers when the
`experimental_use_rmcp_client` is enabled.

To set one up, simply add a new mcp server config with the url:
```
[mcp_servers.figma]
url = "http://127.0.0.1:3845/mcp"
```

It also supports an optional `bearer_token` which will be provided in an
authorization header. The full oauth flow is not supported yet.

The config parsing will throw if it detects that the user mixed and
matched config fields (like command + bearer token or url + env).

The best way to review it is to review `core/src` and then
`rmcp-client/src/rmcp_client.rs` first. The rest is tests and
propagating the `Transport` struct around the codebase.

Example with the Figma MCP:
<img width="5084" height="1614" alt="CleanShot 2025-09-26 at 13 35 40"
src="https://github.com/user-attachments/assets/eaf2771e-df3e-4300-816b-184d7dec5a28"
/>

codex-rs/rmcp-client/src/rmcp_client.rs

@@ -7,6 +7,7 @@ use std::time::Duration;
 
 use anyhow::Result;
 use anyhow::anyhow;
+use futures::FutureExt;
 use mcp_types::CallToolRequestParams;
 use mcp_types::CallToolResult;
 use mcp_types::InitializeRequestParams;
@@ -19,7 +20,9 @@ use rmcp::model::PaginatedRequestParam;
 use rmcp::service::RoleClient;
 use rmcp::service::RunningService;
 use rmcp::service::{self};
+use rmcp::transport::StreamableHttpClientTransport;
 use rmcp::transport::child_process::TokioChildProcess;
+use rmcp::transport::streamable_http_client::StreamableHttpClientTransportConfig;
 use tokio::io::AsyncBufReadExt;
 use tokio::io::BufReader;
 use tokio::process::Command;
@@ -35,9 +38,14 @@ use crate::utils::convert_to_rmcp;
 use crate::utils::create_env_for_mcp_server;
 use crate::utils::run_with_timeout;
 
+enum PendingTransport {
+    ChildProcess(TokioChildProcess),
+    StreamableHttp(StreamableHttpClientTransport<reqwest::Client>),
+}
+
 enum ClientState {
     Connecting {
-        transport: Option<TokioChildProcess>,
+        transport: Option<PendingTransport>,
     },
     Ready {
         service: Arc<RunningService<RoleClient, LoggingClientHandler>>,
@@ -90,7 +98,22 @@ impl RmcpClient {
 
         Ok(Self {
             state: Mutex::new(ClientState::Connecting {
-                transport: Some(transport),
+                transport: Some(PendingTransport::ChildProcess(transport)),
+            }),
+        })
+    }
+
+    pub fn new_streamable_http_client(url: String, bearer_token: Option<String>) -> Result<Self> {
+        let mut config = StreamableHttpClientTransportConfig::with_uri(url);
+        if let Some(token) = bearer_token {
+            config = config.auth_header(format!("Bearer {token}"));
+        }
+
+        let transport = StreamableHttpClientTransport::from_config(config);
+
+        Ok(Self {
+            state: Mutex::new(ClientState::Connecting {
+                transport: Some(PendingTransport::StreamableHttp(transport)),
             }),
         })
     }
@@ -116,7 +139,14 @@ impl RmcpClient {
 
         let client_info = convert_to_rmcp::<_, InitializeRequestParam>(params.clone())?;
         let client_handler = LoggingClientHandler::new(client_info);
-        let service_future = service::serve_client(client_handler, transport);
+        let service_future = match transport {
+            PendingTransport::ChildProcess(transport) => {
+                service::serve_client(client_handler.clone(), transport).boxed()
+            }
+            PendingTransport::StreamableHttp(transport) => {
+                service::serve_client(client_handler, transport).boxed()
+            }
+        };
 
         let service = match timeout {
             Some(duration) => time::timeout(duration, service_future)