diff --git a/codex-rs/core/tests/common/test_codex.rs b/codex-rs/core/tests/common/test_codex.rs
index 30fb0b4598..53dc4197f4 100644
--- a/codex-rs/core/tests/common/test_codex.rs
+++ b/codex-rs/core/tests/common/test_codex.rs
@@ -324,14 +324,13 @@ impl TestCodexHarness {
     }
 
     pub async fn request_bodies(&self) -> Vec<Value> {
-        let method_matcher = method("POST");
         let path_matcher = path_regex(".*/responses$");
         self.server
             .received_requests()
             .await
             .expect("mock server should not fail")
             .into_iter()
-            .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+            .filter(|req| path_matcher.matches(req))
             .map(|req| {
                 req.body_json::<Value>()
                     .expect("request body to be valid JSON")
diff --git a/codex-rs/core/tests/suite/client.rs b/codex-rs/core/tests/suite/client.rs
index 4069d1a73d..9a62bfdc53 100644
--- a/codex-rs/core/tests/suite/client.rs
+++ b/codex-rs/core/tests/suite/client.rs
@@ -375,14 +375,13 @@ async fn includes_conversation_id_and_model_headers_in_request() {
     wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
 
     // get request from the server
-    let method_matcher = method("POST");
     let path_matcher = path_regex(".*/responses$");
     let requests = server
         .received_requests()
         .await
         .expect("mock server should not fail")
         .into_iter()
-        .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+        .filter(|req| path_matcher.matches(req))
         .collect::<Vec<_>>();
     let request = requests
         .first()
@@ -509,14 +508,13 @@ async fn chatgpt_auth_sends_correct_request() {
     wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
 
     // get request from the server
-    let method_matcher = method("POST");
     let path_matcher = path_regex(".*/responses$");
     let requests = server
         .received_requests()
         .await
         .expect("mock server should not fail")
         .into_iter()
-        .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+        .filter(|req| path_matcher.matches(req))
         .collect::<Vec<_>>();
     let request = requests
         .first()
@@ -1250,14 +1248,13 @@ async fn azure_responses_request_includes_store_and_reasoning_ids() {
         }
     }
 
-    let method_matcher = method("POST");
     let path_matcher = path_regex(".*/responses$");
     let requests = server
         .received_requests()
         .await
         .expect("mock server should not fail")
         .into_iter()
-        .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+        .filter(|req| path_matcher.matches(req))
         .collect::<Vec<_>>();
     assert_eq!(requests.len(), 1, "expected a single POST request");
     let body: serde_json::Value = requests[0]
@@ -1872,14 +1869,13 @@ async fn history_dedupes_streamed_and_final_messages_across_turns() {
     wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
 
     // Inspect the three captured requests.
-    let method_matcher = method("POST");
     let path_matcher = path_regex(".*/responses$");
     let requests = server
         .received_requests()
         .await
         .expect("mock server should not fail")
         .into_iter()
-        .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+        .filter(|req| path_matcher.matches(req))
         .collect::<Vec<_>>();
     assert_eq!(requests.len(), 3, "expected 3 requests (one per turn)");
 
diff --git a/codex-rs/core/tests/suite/compact.rs b/codex-rs/core/tests/suite/compact.rs
index 426f53025b..bf1497348a 100644
--- a/codex-rs/core/tests/suite/compact.rs
+++ b/codex-rs/core/tests/suite/compact.rs
@@ -42,7 +42,6 @@ use pretty_assertions::assert_eq;
 use serde_json::json;
 use wiremock::Match;
 use wiremock::MockServer;
-use wiremock::matchers::method;
 use wiremock::matchers::path_regex;
 // --- Test helpers -----------------------------------------------------------
 
@@ -360,14 +359,13 @@ async fn manual_compact_uses_custom_prompt() {
     assert_eq!(message, COMPACT_WARNING_MESSAGE);
     wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
 
-    let method_matcher = method("POST");
     let path_matcher = path_regex(".*/responses$");
     let requests = server
         .received_requests()
         .await
         .expect("mock server should not fail")
         .into_iter()
-        .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+        .filter(|req| path_matcher.matches(req))
         .collect::<Vec<_>>();
     let body = requests
         .iter()
@@ -596,14 +594,13 @@ async fn multiple_auto_compact_per_task_runs_after_token_limit_hit() {
     wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
 
     // collect the requests payloads from the model
-    let method_matcher = method("POST");
     let path_matcher = path_regex(".*/responses$");
     let requests_payloads = server
         .received_requests()
         .await
         .expect("mock server should not fail")
         .into_iter()
-        .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+        .filter(|req| path_matcher.matches(req))
         .collect::<Vec<_>>();
 
     let body = requests_payloads[0]
@@ -1129,14 +1126,13 @@ async fn auto_compact_runs_after_token_limit_hit() {
 
     wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
 
-    let method_matcher = method("POST");
     let path_matcher = path_regex(".*/responses$");
     let requests = server
         .received_requests()
         .await
         .expect("mock server should not fail")
         .into_iter()
-        .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+        .filter(|req| path_matcher.matches(req))
         .collect::<Vec<_>>();
     assert_eq!(
         requests.len(),
@@ -1923,14 +1919,13 @@ async fn auto_compact_allows_multiple_attempts_when_interleaved_with_other_turn_
         "auto compact should not emit task lifecycle events"
     );
 
-    let method_matcher = method("POST");
     let path_matcher = path_regex(".*/responses$");
     let requests = server
         .received_requests()
         .await
         .expect("mock server should not fail")
         .into_iter()
-        .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+        .filter(|req| path_matcher.matches(req))
         .collect::<Vec<_>>();
     let request_bodies: Vec<String> = requests
         .into_iter()
diff --git a/codex-rs/core/tests/suite/compact_resume_fork.rs b/codex-rs/core/tests/suite/compact_resume_fork.rs
index a651d139ba..9a85116778 100644
--- a/codex-rs/core/tests/suite/compact_resume_fork.rs
+++ b/codex-rs/core/tests/suite/compact_resume_fork.rs
@@ -774,14 +774,13 @@ fn normalize_line_endings(value: &mut Value) {
 }
 
 async fn gather_request_bodies(server: &MockServer) -> Vec<Value> {
-    let method_matcher = method("POST");
     let path_matcher = path_regex(".*/responses$");
     let mut bodies = server
         .received_requests()
         .await
         .expect("mock server should not fail")
         .into_iter()
-        .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+        .filter(|req| path_matcher.matches(req))
         .map(|req| {
             req.body_json::<Value>()
                 .expect("request body to be valid JSON")
diff --git a/codex-rs/core/tests/suite/review.rs b/codex-rs/core/tests/suite/review.rs
index f28bcfb334..8b6710f034 100644
--- a/codex-rs/core/tests/suite/review.rs
+++ b/codex-rs/core/tests/suite/review.rs
@@ -35,7 +35,6 @@ use wiremock::Match;
 use wiremock::Mock;
 use wiremock::MockServer;
 use wiremock::ResponseTemplate;
-use wiremock::matchers::method;
 use wiremock::matchers::path;
 use wiremock::matchers::path_regex;
 
@@ -427,14 +426,13 @@ async fn review_uses_custom_review_model_from_config() {
     let _complete = wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
 
     // Assert the request body model equals the configured review model
-    let method_matcher = method("POST");
     let path_matcher = path_regex(".*/responses$");
     let requests = server
         .received_requests()
         .await
         .expect("mock server should not fail")
         .into_iter()
-        .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+        .filter(|req| path_matcher.matches(req))
         .collect::<Vec<_>>();
     let request = requests
         .first()
@@ -556,14 +554,13 @@ async fn review_input_isolated_from_parent_history() {
     let _complete = wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
 
     // Assert the request `input` contains the environment context followed by the user review prompt.
-    let method_matcher = method("POST");
     let path_matcher = path_regex(".*/responses$");
     let requests = server
         .received_requests()
         .await
         .expect("mock server should not fail")
         .into_iter()
-        .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+        .filter(|req| path_matcher.matches(req))
         .collect::<Vec<_>>();
     let request = requests
         .first()
@@ -691,14 +688,13 @@ async fn review_history_surfaces_in_parent_session() {
     // Inspect the second request (parent turn) input contents.
     // Parent turns include session initial messages (user_instructions, environment_context).
     // Critically, no messages from the review thread should appear.
-    let method_matcher = method("POST");
     let path_matcher = path_regex(".*/responses$");
     let requests = server
         .received_requests()
         .await
         .expect("mock server should not fail")
         .into_iter()
-        .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+        .filter(|req| path_matcher.matches(req))
         .collect::<Vec<_>>();
     assert_eq!(requests.len(), 2);
     let body = requests[1].body_json::<serde_json::Value>().unwrap();
@@ -817,14 +813,13 @@ async fn review_uses_overridden_cwd_for_base_branch_merge_base() {
     let _entered = wait_for_event(&codex, |ev| matches!(ev, EventMsg::EnteredReviewMode(_))).await;
     let _complete = wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
 
-    let method_matcher = method("POST");
     let path_matcher = path_regex(".*/responses$");
     let requests = server
         .received_requests()
         .await
         .expect("mock server should not fail")
         .into_iter()
-        .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+        .filter(|req| path_matcher.matches(req))
         .collect::<Vec<_>>();
     assert_eq!(requests.len(), 1);
     let body = requests[0].body_json::<serde_json::Value>().unwrap();
diff --git a/codex-rs/core/tests/suite/unified_exec.rs b/codex-rs/core/tests/suite/unified_exec.rs
index 2096d121a9..7374a2edb3 100644
--- a/codex-rs/core/tests/suite/unified_exec.rs
+++ b/codex-rs/core/tests/suite/unified_exec.rs
@@ -1243,14 +1243,13 @@ async fn exec_command_reports_chunk_and_exit_metadata() -> Result<()> {
     let requests = server.received_requests().await.expect("recorded requests");
     assert!(!requests.is_empty(), "expected at least one POST request");
 
-    let method_matcher = method("POST");
     let path_matcher = path_regex(".*/responses$");
     let bodies = server
         .received_requests()
         .await
         .expect("mock server should not fail")
         .into_iter()
-        .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+        .filter(|req| path_matcher.matches(req))
         .map(|req| {
             req.body_json::<Value>()
                 .expect("request body to be valid JSON")
@@ -1359,14 +1358,13 @@ async fn unified_exec_respects_early_exit_notifications() -> Result<()> {
     let requests = server.received_requests().await.expect("recorded requests");
     assert!(!requests.is_empty(), "expected at least one POST request");
 
-    let method_matcher = method("POST");
     let path_matcher = path_regex(".*/responses$");
     let bodies = server
         .received_requests()
         .await
         .expect("mock server should not fail")
         .into_iter()
-        .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+        .filter(|req| path_matcher.matches(req))
         .map(|req| {
             req.body_json::<Value>()
                 .expect("request body to be valid JSON")
@@ -1496,14 +1494,13 @@ async fn write_stdin_returns_exit_metadata_and_clears_session() -> Result<()> {
     let requests = server.received_requests().await.expect("recorded requests");
     assert!(!requests.is_empty(), "expected at least one POST request");
 
-    let method_matcher = method("POST");
     let path_matcher = path_regex(".*/responses$");
     let bodies = server
         .received_requests()
         .await
         .expect("mock server should not fail")
         .into_iter()
-        .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+        .filter(|req| path_matcher.matches(req))
         .map(|req| {
             req.body_json::<Value>()
                 .expect("request body to be valid JSON")
@@ -1862,14 +1859,13 @@ async fn unified_exec_reuses_session_via_stdin() -> Result<()> {
     let requests = server.received_requests().await.expect("recorded requests");
     assert!(!requests.is_empty(), "expected at least one POST request");
 
-    let method_matcher = method("POST");
     let path_matcher = path_regex(".*/responses$");
     let bodies = server
         .received_requests()
         .await
         .expect("mock server should not fail")
         .into_iter()
-        .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+        .filter(|req| path_matcher.matches(req))
         .map(|req| {
             req.body_json::<Value>()
                 .expect("request body to be valid JSON")
@@ -2008,14 +2004,13 @@ PY
     let requests = server.received_requests().await.expect("recorded requests");
     assert!(!requests.is_empty(), "expected at least one POST request");
 
-    let method_matcher = method("POST");
     let path_matcher = path_regex(".*/responses$");
     let bodies = server
         .received_requests()
         .await
         .expect("mock server should not fail")
         .into_iter()
-        .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+        .filter(|req| path_matcher.matches(req))
         .map(|req| {
             req.body_json::<Value>()
                 .expect("request body to be valid JSON")
@@ -2129,14 +2124,13 @@ async fn unified_exec_timeout_and_followup_poll() -> Result<()> {
     let requests = server.received_requests().await.expect("recorded requests");
     assert!(!requests.is_empty(), "expected at least one POST request");
 
-    let method_matcher = method("POST");
     let path_matcher = path_regex(".*/responses$");
     let bodies = server
         .received_requests()
         .await
         .expect("mock server should not fail")
         .into_iter()
-        .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+        .filter(|req| path_matcher.matches(req))
         .map(|req| {
             req.body_json::<Value>()
                 .expect("request body to be valid JSON")
@@ -2227,14 +2221,13 @@ PY
     let requests = server.received_requests().await.expect("recorded requests");
     assert!(!requests.is_empty(), "expected at least one POST request");
 
-    let method_matcher = method("POST");
     let path_matcher = path_regex(".*/responses$");
     let bodies = server
         .received_requests()
         .await
         .expect("mock server should not fail")
         .into_iter()
-        .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+        .filter(|req| path_matcher.matches(req))
         .map(|req| {
             req.body_json::<Value>()
                 .expect("request body to be valid JSON")
@@ -2316,14 +2309,13 @@ async fn unified_exec_runs_under_sandbox() -> Result<()> {
     let requests = server.received_requests().await.expect("recorded requests");
     assert!(!requests.is_empty(), "expected at least one POST request");
 
-    let method_matcher = method("POST");
     let path_matcher = path_regex(".*/responses$");
     let bodies = server
         .received_requests()
         .await
         .expect("mock server should not fail")
         .into_iter()
-        .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+        .filter(|req| path_matcher.matches(req))
         .map(|req| {
             req.body_json::<Value>()
                 .expect("request body to be valid JSON")
@@ -2426,14 +2418,13 @@ async fn unified_exec_python_prompt_under_seatbelt() -> Result<()> {
     let requests = server.received_requests().await.expect("recorded requests");
     assert!(!requests.is_empty(), "expected at least one POST request");
 
-    let method_matcher = method("POST");
     let path_matcher = path_regex(".*/responses$");
     let bodies = server
         .received_requests()
         .await
         .expect("mock server should not fail")
         .into_iter()
-        .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+        .filter(|req| path_matcher.matches(req))
         .map(|req| {
             req.body_json::<Value>()
                 .expect("request body to be valid JSON")
@@ -2528,14 +2519,13 @@ async fn unified_exec_runs_on_all_platforms() -> Result<()> {
     let requests = server.received_requests().await.expect("recorded requests");
     assert!(!requests.is_empty(), "expected at least one POST request");
 
-    let method_matcher = method("POST");
     let path_matcher = path_regex(".*/responses$");
     let bodies = server
         .received_requests()
         .await
         .expect("mock server should not fail")
         .into_iter()
-        .filter(|req| method_matcher.matches(req) && path_matcher.matches(req))
+        .filter(|req| path_matcher.matches(req))
         .map(|req| {
             req.body_json::<Value>()
                 .expect("request body to be valid JSON")