Revert "Forward session and turn headers to MCP HTTP requests (#15011)"

This reverts commit b14689df3b.

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

@@ -5,7 +5,6 @@ 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;
@@ -23,7 +22,6 @@ use reqwest::header::HeaderMap;
 use reqwest::header::WWW_AUTHENTICATE;
 use rmcp::model::CallToolRequestParams;
 use rmcp::model::CallToolResult;
-use rmcp::model::ClientJsonRpcMessage;
 use rmcp::model::ClientNotification;
 use rmcp::model::ClientRequest;
 use rmcp::model::CreateElicitationRequestParams;
@@ -85,45 +83,14 @@ 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 message_uses_request_scoped_headers(message: &ClientJsonRpcMessage) -> bool {
-    matches!(
-        message,
-        ClientJsonRpcMessage::Request(request)
-            if request.request.method() == "tools/call"
-    )
-}
-
-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,
-        request_headers_state: Arc<StdMutex<Option<HeaderMap>>>,
-    ) -> Self {
-        Self {
-            inner,
-            request_headers_state,
-        }
+    fn new(inner: reqwest::Client) -> Self {
+        Self { inner }
     }
 
     fn reqwest_error(
@@ -166,9 +133,6 @@ 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());
         }
-        if message_uses_request_scoped_headers(&message) {
-            request = apply_request_scoped_headers(request, &self.request_headers_state);
-        }
 
         let response = request
             .json(&message)
@@ -508,7 +472,6 @@ pub struct RmcpClient {
     transport_recipe: TransportRecipe,
     initialize_context: Mutex<Option<InitializeContext>>,
     session_recovery_lock: Mutex<()>,
-    request_headers: Option<Arc<StdMutex<Option<HeaderMap>>>>,
 }
 
 impl RmcpClient {
@@ -526,10 +489,9 @@ impl RmcpClient {
             env_vars: env_vars.to_vec(),
             cwd,
         };
-        let transport =
-            Self::create_pending_transport(&transport_recipe, /*request_headers*/ None)
-                .await
-                .map_err(io::Error::other)?;
+        let transport = Self::create_pending_transport(&transport_recipe)
+            .await
+            .map_err(io::Error::other)?;
 
         Ok(Self {
             state: Mutex::new(ClientState::Connecting {
@@ -538,7 +500,6 @@ impl RmcpClient {
             transport_recipe,
             initialize_context: Mutex::new(None),
             session_recovery_lock: Mutex::new(()),
-            request_headers: None,
         })
     }
 
@@ -550,7 +511,6 @@ impl RmcpClient {
         http_headers: Option<HashMap<String, String>>,
         env_http_headers: Option<HashMap<String, String>>,
         store_mode: OAuthCredentialsStoreMode,
-        request_headers: Arc<StdMutex<Option<HeaderMap>>>,
     ) -> Result<Self> {
         let transport_recipe = TransportRecipe::StreamableHttp {
             server_name: server_name.to_string(),
@@ -560,9 +520,7 @@ impl RmcpClient {
             env_http_headers,
             store_mode,
         };
-        let transport =
-            Self::create_pending_transport(&transport_recipe, Some(Arc::clone(&request_headers)))
-                .await?;
+        let transport = Self::create_pending_transport(&transport_recipe).await?;
         Ok(Self {
             state: Mutex::new(ClientState::Connecting {
                 transport: Some(transport),
@@ -570,7 +528,6 @@ impl RmcpClient {
             transport_recipe,
             initialize_context: Mutex::new(None),
             session_recovery_lock: Mutex::new(()),
-            request_headers: Some(request_headers),
         })
     }
 
@@ -873,7 +830,6 @@ impl RmcpClient {
 
     async fn create_pending_transport(
         transport_recipe: &TransportRecipe,
-        request_headers: Option<Arc<StdMutex<Option<HeaderMap>>>>,
     ) -> Result<PendingTransport> {
         match transport_recipe {
             TransportRecipe::Stdio {
@@ -990,12 +946,7 @@ impl RmcpClient {
                                     .auth_header(access_token);
                             let http_client = build_http_client(&default_headers)?;
                             let transport = StreamableHttpClientTransport::with_client(
-                                StreamableHttpResponseClient::new(
-                                    http_client,
-                                    request_headers
-                                        .clone()
-                                        .unwrap_or_else(|| Arc::new(StdMutex::new(None))),
-                                ),
+                                StreamableHttpResponseClient::new(http_client),
                                 http_config,
                             );
                             Ok(PendingTransport::StreamableHttp { transport })
@@ -1012,12 +963,7 @@ impl RmcpClient {
                     let http_client = build_http_client(&default_headers)?;
 
                     let transport = StreamableHttpClientTransport::with_client(
-                        StreamableHttpResponseClient::new(
-                            http_client,
-                            request_headers
-                                .clone()
-                                .unwrap_or_else(|| Arc::new(StdMutex::new(None))),
-                        ),
+                        StreamableHttpResponseClient::new(http_client),
                         http_config,
                     );
                     Ok(PendingTransport::StreamableHttp { transport })
@@ -1165,9 +1111,7 @@ 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, self.request_headers.clone())
-                .await?;
+        let pending_transport = Self::create_pending_transport(&self.transport_recipe).await?;
         let (service, oauth_persistor, process_group_guard) = Self::connect_pending_transport(
             pending_transport,
             initialize_context.handler,
@@ -1222,10 +1166,7 @@ async fn create_oauth_transport_and_runtime(
         }
     };
 
-    let auth_client = AuthClient::new(
-        StreamableHttpResponseClient::new(http_client, Arc::new(StdMutex::new(None))),
-        manager,
-    );
+    let auth_client = AuthClient::new(StreamableHttpResponseClient::new(http_client), manager);
     let auth_manager = auth_client.auth_manager.clone();
 
     let transport = StreamableHttpClientTransport::with_client(