Forward tool call task headers to MCP HTTP requests

Co-authored-by: Codex <noreply@openai.com>
This commit is contained in:
nicholasclark-openai
2026-03-17 18:14:32 -07:00
co-authored by Codex
parent 0d2ff40a58
commit bccce0f2d8
8 changed files with 283 additions and 41 deletions
+2 -1
View File
@@ -3912,12 +3912,13 @@ impl Session {
tool: &str,
arguments: Option<serde_json::Value>,
meta: Option<serde_json::Value>,
request_headers: Option<reqwest::header::HeaderMap>,
) -> anyhow::Result<CallToolResult> {
self.services
.mcp_connection_manager
.read()
.await
.call_tool(server, tool, arguments, meta)
.call_tool(server, tool, arguments, meta, request_headers)
.await
}
+1
View File
@@ -669,6 +669,7 @@ async fn maybe_auto_review_mcp_request_user_input(
parent_ctx.as_ref(),
&invocation.server,
&invocation.tool,
None,
)
.await;
let review_cancel = cancel_token.child_token();
+112 -25
View File
@@ -378,7 +378,7 @@ struct ManagedClient {
}
impl ManagedClient {
fn listed_tools(&self) -> Vec<ToolInfo> {
fn listed_tools(&self, _request_headers: Option<reqwest::header::HeaderMap>) -> Vec<ToolInfo> {
let total_start = Instant::now();
if let Some(cache_context) = self.codex_apps_tools_cache_context.as_ref()
&& let CachedCodexAppsToolsLoad::Hit(tools) =
@@ -425,9 +425,42 @@ struct AsyncManagedClient {
client: Shared<BoxFuture<'static, Result<ManagedClient, StartupOutcomeError>>>,
startup_snapshot: Option<Vec<ToolInfo>>,
startup_complete: Arc<AtomicBool>,
startup_request_headers: Arc<StdMutex<Option<reqwest::header::HeaderMap>>>,
tool_plugin_provenance: Arc<ToolPluginProvenance>,
}
struct StartupRequestHeadersGuard {
state: Arc<StdMutex<Option<reqwest::header::HeaderMap>>>,
previous: Option<reqwest::header::HeaderMap>,
}
impl StartupRequestHeadersGuard {
fn set(
state: Arc<StdMutex<Option<reqwest::header::HeaderMap>>>,
headers: Option<reqwest::header::HeaderMap>,
) -> Self {
let previous = {
let mut guard = state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
let previous = guard.clone();
*guard = headers;
previous
};
Self { state, previous }
}
}
impl Drop for StartupRequestHeadersGuard {
fn drop(&mut self) {
let mut guard = self
.state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
*guard = self.previous.clone();
}
}
impl AsyncManagedClient {
// Keep this constructor flat so the startup inputs remain readable at the
// single call site instead of introducing a one-off params wrapper.
@@ -451,6 +484,8 @@ impl AsyncManagedClient {
let startup_tool_filter = tool_filter;
let startup_complete = Arc::new(AtomicBool::new(false));
let startup_complete_for_fut = Arc::clone(&startup_complete);
let startup_request_headers = Arc::new(StdMutex::new(None));
let startup_request_headers_for_fut = Arc::clone(&startup_request_headers);
let fut = async move {
let outcome = async {
if let Err(error) = validate_mcp_server_name(&server_name) {
@@ -471,6 +506,7 @@ impl AsyncManagedClient {
tx_event,
elicitation_requests,
codex_apps_tools_cache_context,
startup_request_headers: startup_request_headers_for_fut,
},
)
.or_cancel(&cancel_token)
@@ -497,11 +533,17 @@ impl AsyncManagedClient {
client,
startup_snapshot,
startup_complete,
startup_request_headers,
tool_plugin_provenance,
}
}
async fn client(&self) -> Result<ManagedClient, StartupOutcomeError> {
async fn client(
&self,
request_headers: Option<reqwest::header::HeaderMap>,
) -> Result<ManagedClient, StartupOutcomeError> {
let _request_headers_guard =
StartupRequestHeadersGuard::set(self.startup_request_headers.clone(), request_headers);
self.client.clone().await
}
@@ -512,7 +554,10 @@ impl AsyncManagedClient {
None
}
async fn listed_tools(&self) -> Option<Vec<ToolInfo>> {
async fn listed_tools(
&self,
request_headers: Option<reqwest::header::HeaderMap>,
) -> Option<Vec<ToolInfo>> {
let annotate_tools = |tools: Vec<ToolInfo>| {
let mut tools = tools;
for tool in &mut tools {
@@ -564,8 +609,8 @@ impl AsyncManagedClient {
let tools = if let Some(startup_tools) = self.startup_snapshot_while_initializing() {
Some(startup_tools)
} else {
match self.client().await {
Ok(client) => Some(client.listed_tools()),
match self.client(request_headers.clone()).await {
Ok(client) => Some(client.listed_tools(request_headers)),
Err(_) => self.startup_snapshot.clone(),
}
};
@@ -573,7 +618,7 @@ impl AsyncManagedClient {
}
async fn notify_sandbox_state_change(&self, sandbox_state: &SandboxState) -> Result<()> {
let managed = self.client().await?;
let managed = self.client(None).await?;
managed.notify_sandbox_state_change(sandbox_state).await
}
}
@@ -686,7 +731,7 @@ impl McpConnectionManager {
let auth_entry = auth_entries.get(&server_name).cloned();
let sandbox_state = initial_sandbox_state.clone();
join_set.spawn(async move {
let outcome = async_managed_client.client().await;
let outcome = async_managed_client.client(None).await;
if cancel_token.is_cancelled() {
return (server_name, Err(StartupOutcomeError::Cancelled));
}
@@ -755,11 +800,15 @@ impl McpConnectionManager {
(manager, cancel_token)
}
async fn client_by_name(&self, name: &str) -> Result<ManagedClient> {
async fn client_by_name(
&self,
name: &str,
request_headers: Option<reqwest::header::HeaderMap>,
) -> Result<ManagedClient> {
self.clients
.get(name)
.ok_or_else(|| anyhow!("unknown MCP server '{name}'"))?
.client()
.client(request_headers)
.await
.context("failed to get client")
}
@@ -780,7 +829,7 @@ impl McpConnectionManager {
return false;
};
match tokio::time::timeout(timeout, async_managed_client.client()).await {
match tokio::time::timeout(timeout, async_managed_client.client(None)).await {
Ok(Ok(_)) => true,
Ok(Err(_)) | Err(_) => false,
}
@@ -800,7 +849,7 @@ impl McpConnectionManager {
continue;
};
match async_managed_client.client().await {
match async_managed_client.client(None).await {
Ok(_) => {}
Err(error) => failures.push(McpStartupFailure {
server: server_name.clone(),
@@ -815,9 +864,18 @@ impl McpConnectionManager {
/// fully-qualified name for the tool.
#[instrument(level = "trace", skip_all)]
pub async fn list_all_tools(&self) -> HashMap<String, ToolInfo> {
self.list_all_tools_with_request_headers(None).await
}
#[instrument(level = "trace", skip_all)]
pub async fn list_all_tools_with_request_headers(
&self,
request_headers: Option<reqwest::header::HeaderMap>,
) -> HashMap<String, ToolInfo> {
let mut tools = HashMap::new();
for managed_client in self.clients.values() {
let Some(server_tools) = managed_client.listed_tools().await else {
let Some(server_tools) = managed_client.listed_tools(request_headers.clone()).await
else {
continue;
};
tools.extend(qualify_tools(server_tools));
@@ -835,7 +893,7 @@ impl McpConnectionManager {
.clients
.get(CODEX_APPS_MCP_SERVER_NAME)
.ok_or_else(|| anyhow!("unknown MCP server '{CODEX_APPS_MCP_SERVER_NAME}'"))?
.client()
.client(None)
.await
.context("failed to get client")?;
@@ -845,6 +903,7 @@ impl McpConnectionManager {
CODEX_APPS_MCP_SERVER_NAME,
&managed_client.client,
managed_client.tool_timeout,
None,
)
.await
.with_context(|| {
@@ -881,7 +940,7 @@ impl McpConnectionManager {
for (server_name, async_managed_client) in clients_snapshot {
let server_name = server_name.clone();
let Ok(managed_client) = async_managed_client.client().await else {
let Ok(managed_client) = async_managed_client.client(None).await else {
continue;
};
let timeout = managed_client.tool_timeout;
@@ -947,7 +1006,7 @@ impl McpConnectionManager {
for (server_name, async_managed_client) in clients_snapshot {
let server_name_cloned = server_name.clone();
let Ok(managed_client) = async_managed_client.client().await else {
let Ok(managed_client) = async_managed_client.client(None).await else {
continue;
};
let client = managed_client.client.clone();
@@ -1015,8 +1074,9 @@ impl McpConnectionManager {
tool: &str,
arguments: Option<serde_json::Value>,
meta: Option<serde_json::Value>,
request_headers: Option<reqwest::header::HeaderMap>,
) -> Result<CallToolResult> {
let client = self.client_by_name(server).await?;
let client = self.client_by_name(server, request_headers.clone()).await?;
if !client.tool_filter.allows(tool) {
return Err(anyhow!(
"tool '{tool}' is disabled for MCP server '{server}'"
@@ -1025,7 +1085,13 @@ impl McpConnectionManager {
let result: rmcp::model::CallToolResult = client
.client
.call_tool(tool.to_string(), arguments, meta, client.tool_timeout)
.call_tool(
tool.to_string(),
arguments,
meta,
client.tool_timeout,
request_headers,
)
.await
.with_context(|| format!("tool call failed for `{server}/{tool}`"))?;
@@ -1052,7 +1118,7 @@ impl McpConnectionManager {
server: &str,
params: Option<PaginatedRequestParams>,
) -> Result<ListResourcesResult> {
let managed = self.client_by_name(server).await?;
let managed = self.client_by_name(server, None).await?;
let timeout = managed.tool_timeout;
managed
@@ -1068,7 +1134,7 @@ impl McpConnectionManager {
server: &str,
params: Option<PaginatedRequestParams>,
) -> Result<ListResourceTemplatesResult> {
let managed = self.client_by_name(server).await?;
let managed = self.client_by_name(server, None).await?;
let client = managed.client.clone();
let timeout = managed.tool_timeout;
@@ -1084,7 +1150,7 @@ impl McpConnectionManager {
server: &str,
params: ReadResourceRequestParams,
) -> Result<ReadResourceResult> {
let managed = self.client_by_name(server).await?;
let managed = self.client_by_name(server, None).await?;
let client = managed.client.clone();
let timeout = managed.tool_timeout;
let uri = params.uri.clone();
@@ -1344,6 +1410,7 @@ async fn start_server_task(
tx_event,
elicitation_requests,
codex_apps_tools_cache_context,
startup_request_headers,
} = params;
let elicitation = elicitation_capability_for_server(&server_name);
let params = InitializeRequestParams {
@@ -1369,16 +1436,34 @@ async fn start_server_task(
let send_elicitation = elicitation_requests.make_sender(server_name.clone(), tx_event);
let initialize_request_headers = startup_request_headers
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.clone();
let initialize_result = client
.initialize(params, startup_timeout, send_elicitation)
.initialize(
params,
startup_timeout,
send_elicitation,
initialize_request_headers,
)
.await
.map_err(StartupOutcomeError::from)?;
let list_start = Instant::now();
let fetch_start = Instant::now();
let tools = list_tools_for_client_uncached(&server_name, &client, startup_timeout)
.await
.map_err(StartupOutcomeError::from)?;
let list_request_headers = startup_request_headers
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.clone();
let tools = list_tools_for_client_uncached(
&server_name,
&client,
startup_timeout,
list_request_headers,
)
.await
.map_err(StartupOutcomeError::from)?;
emit_duration(
MCP_TOOLS_FETCH_UNCACHED_DURATION_METRIC,
fetch_start.elapsed(),
@@ -1423,6 +1508,7 @@ struct StartServerTaskParams {
tx_event: Sender<Event>,
elicitation_requests: ElicitationRequestManager,
codex_apps_tools_cache_context: Option<CodexAppsToolsCacheContext>,
startup_request_headers: Arc<StdMutex<Option<reqwest::header::HeaderMap>>>,
}
async fn make_rmcp_client(
@@ -1584,9 +1670,10 @@ async fn list_tools_for_client_uncached(
server_name: &str,
client: &Arc<RmcpClient>,
timeout: Option<Duration>,
request_headers: Option<reqwest::header::HeaderMap>,
) -> Result<Vec<ToolInfo>> {
let resp = client
.list_tools_with_connector_ids(/*params*/ None, timeout)
.list_tools_with_connector_ids(/*params*/ None, timeout, request_headers)
.await?;
let tools = resp
.tools
@@ -4,6 +4,7 @@ use codex_protocol::protocol::McpAuthStatus;
use rmcp::model::JsonObject;
use std::collections::HashSet;
use std::sync::Arc;
use std::sync::Mutex as StdMutex;
use tempfile::tempdir;
fn create_test_tool(server_name: &str, tool_name: &str) -> ToolInfo {
@@ -415,6 +416,7 @@ async fn list_all_tools_uses_startup_snapshot_while_client_is_pending() {
client: pending_client,
startup_snapshot: Some(startup_tools),
startup_complete: Arc::new(std::sync::atomic::AtomicBool::new(false)),
startup_request_headers: Arc::new(StdMutex::new(None)),
tool_plugin_provenance: Arc::new(ToolPluginProvenance::default()),
},
);
@@ -440,6 +442,7 @@ async fn list_all_tools_blocks_while_client_is_pending_without_startup_snapshot(
client: pending_client,
startup_snapshot: None,
startup_complete: Arc::new(std::sync::atomic::AtomicBool::new(false)),
startup_request_headers: Arc::new(StdMutex::new(None)),
tool_plugin_provenance: Arc::new(ToolPluginProvenance::default()),
},
);
@@ -462,6 +465,7 @@ async fn list_all_tools_does_not_block_when_startup_snapshot_cache_hit_is_empty(
client: pending_client,
startup_snapshot: Some(Vec::new()),
startup_complete: Arc::new(std::sync::atomic::AtomicBool::new(false)),
startup_request_headers: Arc::new(StdMutex::new(None)),
tool_plugin_provenance: Arc::new(ToolPluginProvenance::default()),
},
);
@@ -494,6 +498,7 @@ async fn list_all_tools_uses_startup_snapshot_when_client_startup_fails() {
client: failed_client,
startup_snapshot: Some(startup_tools),
startup_complete,
startup_request_headers: Arc::new(StdMutex::new(None)),
tool_plugin_provenance: Arc::new(ToolPluginProvenance::default()),
},
);
+62 -7
View File
@@ -45,6 +45,8 @@ use codex_protocol::request_user_input::RequestUserInputQuestionOption;
use codex_protocol::request_user_input::RequestUserInputResponse;
use codex_rmcp_client::ElicitationAction;
use codex_rmcp_client::ElicitationResponse;
use reqwest::header::HeaderMap;
use reqwest::header::HeaderValue;
use rmcp::model::ToolAnnotations;
use serde::Serialize;
use std::path::Path;
@@ -81,8 +83,15 @@ pub(crate) async fn handle_mcp_tool_call(
arguments: arguments_value.clone(),
};
let metadata =
lookup_mcp_tool_metadata(sess.as_ref(), turn_context.as_ref(), &server, &tool_name).await;
let request_headers = build_mcp_request_headers(sess.as_ref(), turn_context.as_ref(), &server);
let metadata = lookup_mcp_tool_metadata(
sess.as_ref(),
turn_context.as_ref(),
&server,
&tool_name,
request_headers.clone(),
)
.await;
let app_tool_policy = if server == CODEX_APPS_MCP_SERVER_NAME {
connectors::app_tool_policy(
&turn_context.config,
@@ -150,6 +159,7 @@ pub(crate) async fn handle_mcp_tool_call(
&tool_name,
arguments_value.clone(),
request_meta.clone(),
request_headers.clone(),
)
.await
.map_err(|e| format!("tool call error: {e:?}"));
@@ -180,6 +190,7 @@ pub(crate) async fn handle_mcp_tool_call(
turn_context.as_ref(),
&server,
&tool_name,
request_headers.clone(),
)
.await;
result
@@ -236,7 +247,13 @@ pub(crate) async fn handle_mcp_tool_call(
let start = Instant::now();
// Perform the tool call.
let result = sess
.call_tool(&server, &tool_name, arguments_value.clone(), request_meta)
.call_tool(
&server,
&tool_name,
arguments_value.clone(),
request_meta,
request_headers.clone(),
)
.await
.map_err(|e| format!("tool call error: {e:?}"));
let result = sanitize_mcp_tool_result_for_model(
@@ -262,7 +279,14 @@ pub(crate) async fn handle_mcp_tool_call(
tool_call_end_event.clone(),
)
.await;
maybe_track_codex_app_used(sess.as_ref(), turn_context.as_ref(), &server, &tool_name).await;
maybe_track_codex_app_used(
sess.as_ref(),
turn_context.as_ref(),
&server,
&tool_name,
request_headers.clone(),
)
.await;
let status = if result.is_ok() { "ok" } else { "error" };
turn_context
@@ -333,11 +357,12 @@ async fn maybe_track_codex_app_used(
turn_context: &TurnContext,
server: &str,
tool_name: &str,
request_headers: Option<HeaderMap>,
) {
if server != CODEX_APPS_MCP_SERVER_NAME {
return;
}
let metadata = lookup_mcp_app_usage_metadata(sess, server, tool_name).await;
let metadata = lookup_mcp_app_usage_metadata(sess, server, tool_name, request_headers).await;
let (connector_id, app_name) = metadata
.map(|metadata| (metadata.connector_id, metadata.app_name))
.unwrap_or((None, None));
@@ -389,6 +414,34 @@ pub(crate) struct McpToolApprovalMetadata {
const MCP_TOOL_CODEX_APPS_META_KEY: &str = "_codex_apps";
fn build_mcp_request_headers(
sess: &Session,
turn_context: &TurnContext,
server: &str,
) -> Option<HeaderMap> {
if server != CODEX_APPS_MCP_SERVER_NAME {
return None;
}
let session_id = sess.conversation_id.to_string();
let mut headers = HeaderMap::new();
if let Ok(value) = HeaderValue::from_str(&session_id) {
headers.insert("session_id", value.clone());
headers.insert("x-client-request-id", value);
}
if let Some(turn_metadata) = turn_context.turn_metadata_state.current_header_value()
&& let Ok(value) = HeaderValue::from_str(&turn_metadata)
{
headers.insert(crate::X_CODEX_TURN_METADATA_HEADER, value);
}
if headers.is_empty() {
None
} else {
Some(headers)
}
}
fn build_mcp_tool_call_request_meta(
server: &str,
metadata: Option<&McpToolApprovalMetadata>,
@@ -741,13 +794,14 @@ pub(crate) async fn lookup_mcp_tool_metadata(
turn_context: &TurnContext,
server: &str,
tool_name: &str,
request_headers: Option<HeaderMap>,
) -> Option<McpToolApprovalMetadata> {
let tools = sess
.services
.mcp_connection_manager
.read()
.await
.list_all_tools()
.list_all_tools_with_request_headers(request_headers.clone())
.await;
let tool_info = tools
@@ -798,13 +852,14 @@ async fn lookup_mcp_app_usage_metadata(
sess: &Session,
server: &str,
tool_name: &str,
request_headers: Option<HeaderMap>,
) -> Option<McpAppUsageMetadata> {
let tools = sess
.services
.mcp_connection_manager
.read()
.await
.list_all_tools()
.list_all_tools_with_request_headers(request_headers)
.await;
tools.into_values().find_map(|tool_info| {
+98 -8
View File
@@ -5,6 +5,7 @@ use std::io;
use std::path::PathBuf;
use std::process::Stdio;
use std::sync::Arc;
use std::sync::Mutex as StdMutex;
use std::time::Duration;
use anyhow::Result;
@@ -82,15 +83,37 @@ const JSON_MIME_TYPE: &str = "application/json";
const HEADER_LAST_EVENT_ID: &str = "Last-Event-Id";
const HEADER_SESSION_ID: &str = "Mcp-Session-Id";
const NON_JSON_RESPONSE_BODY_PREVIEW_BYTES: usize = 8_192;
fn apply_request_scoped_headers(
mut request: reqwest::RequestBuilder,
request_headers_state: &Arc<StdMutex<Option<HeaderMap>>>,
) -> reqwest::RequestBuilder {
let extra_headers = request_headers_state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.clone();
if let Some(extra_headers) = extra_headers {
for (name, value) in &extra_headers {
request = request.header(name, value.clone());
}
}
request
}
#[derive(Clone)]
struct StreamableHttpResponseClient {
inner: reqwest::Client,
request_headers_state: Arc<StdMutex<Option<HeaderMap>>>,
}
impl StreamableHttpResponseClient {
fn new(inner: reqwest::Client) -> Self {
Self { inner }
fn new(
inner: reqwest::Client,
request_headers_state: Arc<StdMutex<Option<HeaderMap>>>,
) -> Self {
Self {
inner,
request_headers_state,
}
}
fn reqwest_error(
@@ -133,6 +156,7 @@ impl StreamableHttpClient for StreamableHttpResponseClient {
if let Some(session_id_value) = session_id.as_ref() {
request = request.header(HEADER_SESSION_ID, session_id_value.as_ref());
}
request = apply_request_scoped_headers(request, &self.request_headers_state);
let response = request
.json(&message)
@@ -228,6 +252,8 @@ impl StreamableHttpClient for StreamableHttpResponseClient {
if let Some(auth_header) = auth_token {
request_builder = request_builder.bearer_auth(auth_header);
}
request_builder =
apply_request_scoped_headers(request_builder, &self.request_headers_state);
let response = request_builder
.header(HEADER_SESSION_ID, session.as_ref())
.send()
@@ -265,6 +291,8 @@ impl StreamableHttpClient for StreamableHttpResponseClient {
if let Some(auth_header) = auth_token {
request_builder = request_builder.bearer_auth(auth_header);
}
request_builder =
apply_request_scoped_headers(request_builder, &self.request_headers_state);
let response = request_builder
.send()
@@ -472,6 +500,39 @@ pub struct RmcpClient {
transport_recipe: TransportRecipe,
initialize_context: Mutex<Option<InitializeContext>>,
session_recovery_lock: Mutex<()>,
request_headers: Option<Arc<StdMutex<Option<HeaderMap>>>>,
}
struct RequestHeadersGuard {
state: Option<Arc<StdMutex<Option<HeaderMap>>>>,
previous: Option<HeaderMap>,
}
impl RequestHeadersGuard {
fn set(state: Option<Arc<StdMutex<Option<HeaderMap>>>>, headers: Option<HeaderMap>) -> Self {
let previous = if let Some(state_ref) = state.as_ref() {
let mut guard = state_ref
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
let previous = guard.clone();
*guard = headers;
previous
} else {
None
};
Self { state, previous }
}
}
impl Drop for RequestHeadersGuard {
fn drop(&mut self) {
if let Some(state) = self.state.as_ref() {
let mut guard = state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
*guard = self.previous.clone();
}
}
}
impl RmcpClient {
@@ -489,7 +550,7 @@ impl RmcpClient {
env_vars: env_vars.to_vec(),
cwd,
};
let transport = Self::create_pending_transport(&transport_recipe)
let transport = Self::create_pending_transport(&transport_recipe, None)
.await
.map_err(io::Error::other)?;
@@ -500,6 +561,7 @@ impl RmcpClient {
transport_recipe,
initialize_context: Mutex::new(None),
session_recovery_lock: Mutex::new(()),
request_headers: None,
})
}
@@ -520,7 +582,9 @@ impl RmcpClient {
env_http_headers,
store_mode,
};
let transport = Self::create_pending_transport(&transport_recipe).await?;
let request_headers = Some(Arc::new(StdMutex::new(None)));
let transport =
Self::create_pending_transport(&transport_recipe, request_headers.clone()).await?;
Ok(Self {
state: Mutex::new(ClientState::Connecting {
transport: Some(transport),
@@ -528,6 +592,7 @@ impl RmcpClient {
transport_recipe,
initialize_context: Mutex::new(None),
session_recovery_lock: Mutex::new(()),
request_headers,
})
}
@@ -538,6 +603,7 @@ impl RmcpClient {
params: InitializeRequestParams,
timeout: Option<Duration>,
send_elicitation: SendElicitation,
request_headers: Option<HeaderMap>,
) -> Result<InitializeResult> {
let client_handler = LoggingClientHandler::new(params.clone(), send_elicitation);
let pending_transport = {
@@ -551,6 +617,8 @@ impl RmcpClient {
}
};
let _request_headers_guard =
RequestHeadersGuard::set(self.request_headers.clone(), request_headers);
let (service, oauth_persistor, process_group_guard) =
Self::connect_pending_transport(pending_transport, client_handler.clone(), timeout)
.await?;
@@ -607,8 +675,11 @@ impl RmcpClient {
&self,
params: Option<PaginatedRequestParams>,
timeout: Option<Duration>,
request_headers: Option<HeaderMap>,
) -> Result<ListToolsWithConnectorIdResult> {
self.refresh_oauth_if_needed().await;
let _request_headers_guard =
RequestHeadersGuard::set(self.request_headers.clone(), request_headers);
let result = self
.run_service_operation("tools/list", timeout, move |service| {
let params = params.clone();
@@ -702,6 +773,7 @@ impl RmcpClient {
arguments: Option<serde_json::Value>,
meta: Option<serde_json::Value>,
timeout: Option<Duration>,
request_headers: Option<HeaderMap>,
) -> Result<CallToolResult> {
self.refresh_oauth_if_needed().await;
let arguments = match arguments {
@@ -728,6 +800,8 @@ impl RmcpClient {
arguments,
task: None,
};
let _request_headers_guard =
RequestHeadersGuard::set(self.request_headers.clone(), request_headers);
let result = self
.run_service_operation("tools/call", timeout, move |service| {
let rmcp_params = rmcp_params.clone();
@@ -830,6 +904,7 @@ impl RmcpClient {
async fn create_pending_transport(
transport_recipe: &TransportRecipe,
request_headers: Option<Arc<StdMutex<Option<HeaderMap>>>>,
) -> Result<PendingTransport> {
match transport_recipe {
TransportRecipe::Stdio {
@@ -946,7 +1021,12 @@ impl RmcpClient {
.auth_header(access_token);
let http_client = build_http_client(&default_headers)?;
let transport = StreamableHttpClientTransport::with_client(
StreamableHttpResponseClient::new(http_client),
StreamableHttpResponseClient::new(
http_client,
request_headers
.clone()
.unwrap_or_else(|| Arc::new(StdMutex::new(None))),
),
http_config,
);
Ok(PendingTransport::StreamableHttp { transport })
@@ -963,7 +1043,12 @@ impl RmcpClient {
let http_client = build_http_client(&default_headers)?;
let transport = StreamableHttpClientTransport::with_client(
StreamableHttpResponseClient::new(http_client),
StreamableHttpResponseClient::new(
http_client,
request_headers
.clone()
.unwrap_or_else(|| Arc::new(StdMutex::new(None))),
),
http_config,
);
Ok(PendingTransport::StreamableHttp { transport })
@@ -1111,7 +1196,9 @@ impl RmcpClient {
.await
.clone()
.ok_or_else(|| anyhow!("MCP client cannot recover before initialize succeeds"))?;
let pending_transport = Self::create_pending_transport(&self.transport_recipe).await?;
let pending_transport =
Self::create_pending_transport(&self.transport_recipe, self.request_headers.clone())
.await?;
let (service, oauth_persistor, process_group_guard) = Self::connect_pending_transport(
pending_transport,
initialize_context.handler,
@@ -1166,7 +1253,10 @@ async fn create_oauth_transport_and_runtime(
}
};
let auth_client = AuthClient::new(StreamableHttpResponseClient::new(http_client), manager);
let auth_client = AuthClient::new(
StreamableHttpResponseClient::new(http_client, Arc::new(StdMutex::new(None))),
manager,
);
let auth_manager = auth_client.auth_manager.clone();
let transport = StreamableHttpClientTransport::with_client(
+1
View File
@@ -78,6 +78,7 @@ async fn rmcp_client_can_list_and_read_resources() -> anyhow::Result<()> {
}
.boxed()
}),
/*request_headers*/ None,
)
.await?;
@@ -94,6 +94,7 @@ async fn create_client(base_url: &str) -> anyhow::Result<RmcpClient> {
}
.boxed()
}),
/*request_headers*/ None,
)
.await?;
@@ -107,6 +108,7 @@ async fn call_echo_tool(client: &RmcpClient, message: &str) -> anyhow::Result<Ca
Some(json!({ "message": message })),
None,
Some(Duration::from_secs(5)),
/*request_headers*/ None,
)
.await
}