Promote shared helpers for suite tests (#6460)

## Summary
- add `TestCodex::submit_turn_with_policies` and extend the response
helpers with reusable tool-call utilities
- update the grep_files, read_file, list_dir, shell_serialization, and
tools suites to rely on the shared helpers instead of local copies
- make the list_dir helper return `anyhow::Result` so clippy no longer
warns about `expect`

## Testing
- `just fix -p codex-core`
- `cargo test -p codex-core --test all
suite::grep_files::grep_files_tool_collects_matches`
- `cargo test -p codex-core
suite::grep_files::grep_files_tool_collects_matches -- --ignored`
(filter requests ignored tests so nothing runs, but the build stays
clean)


------
[Codex
Task](https://chatgpt.com/codex/tasks/task_i_69112d53abac83219813cab4d7cb6446)

codex-rs/core/tests/suite/grep_files.rs

@@ -2,28 +2,14 @@
 
 use anyhow::Result;
 use codex_core::model_family::find_family_for_model;
-use codex_core::protocol::AskForApproval;
-use codex_core::protocol::EventMsg;
-use codex_core::protocol::Op;
-use codex_core::protocol::SandboxPolicy;
-use codex_protocol::config_types::ReasoningSummary;
-use codex_protocol::user_input::UserInput;
-use core_test_support::responses;
-use core_test_support::responses::ev_assistant_message;
-use core_test_support::responses::ev_completed;
-use core_test_support::responses::ev_function_call;
-use core_test_support::responses::ev_response_created;
-use core_test_support::responses::sse;
+use core_test_support::responses::mount_function_call_agent_response;
 use core_test_support::responses::start_mock_server;
 use core_test_support::skip_if_no_network;
 use core_test_support::test_codex::TestCodex;
 use core_test_support::test_codex::test_codex;
-use core_test_support::wait_for_event;
-use serde_json::Value;
 use std::collections::HashSet;
 use std::path::Path;
 use std::process::Command as StdCommand;
-use wiremock::matchers::any;
 
 const MODEL_WITH_TOOL: &str = "test-gpt-5-codex";
 
@@ -69,18 +55,22 @@ async fn grep_files_tool_collects_matches() -> Result<()> {
     })
     .to_string();
 
-    mount_tool_sequence(&server, call_id, &arguments, "grep_files").await;
-    submit_turn(&test, "please find uses of needle").await?;
+    let mocks =
+        mount_function_call_agent_response(&server, call_id, &arguments, "grep_files").await;
+    test.submit_turn("please find uses of needle").await?;
 
-    let bodies = recorded_bodies(&server).await?;
-    let tool_output = find_tool_output(&bodies, call_id).expect("tool output present");
-    let payload = tool_output.get("output").expect("output field present");
-    let (content_opt, success_opt) = extract_content_and_success(payload);
+    let req = mocks.completion.single_request();
+    let (content_opt, success_opt) = req
+        .function_call_output_content_and_success(call_id)
+        .expect("tool output present");
     let content = content_opt.expect("content present");
     let success = success_opt.unwrap_or(true);
-    assert!(success, "expected success for matches, got {payload:?}");
+    assert!(
+        success,
+        "expected success for matches, got content={content}"
+    );
 
-    let entries = collect_file_names(content);
+    let entries = collect_file_names(&content);
     assert_eq!(entries.len(), 2, "content: {content}");
     assert!(
         entries.contains("alpha.rs"),
@@ -118,16 +108,17 @@ async fn grep_files_tool_reports_empty_results() -> Result<()> {
     })
     .to_string();
 
-    mount_tool_sequence(&server, call_id, &arguments, "grep_files").await;
-    submit_turn(&test, "search again").await?;
+    let mocks =
+        mount_function_call_agent_response(&server, call_id, &arguments, "grep_files").await;
+    test.submit_turn("search again").await?;
 
-    let bodies = recorded_bodies(&server).await?;
-    let tool_output = find_tool_output(&bodies, call_id).expect("tool output present");
-    let payload = tool_output.get("output").expect("output field present");
-    let (content_opt, success_opt) = extract_content_and_success(payload);
+    let req = mocks.completion.single_request();
+    let (content_opt, success_opt) = req
+        .function_call_output_content_and_success(call_id)
+        .expect("tool output present");
     let content = content_opt.expect("content present");
     if let Some(success) = success_opt {
-        assert!(!success, "expected success=false payload: {payload:?}");
+        assert!(!success, "expected success=false content={content}");
     }
     assert_eq!(content, "No matches found.");
 
@@ -144,73 +135,6 @@ async fn build_test_codex(server: &wiremock::MockServer) -> Result<TestCodex> {
     builder.build(server).await
 }
 
-async fn submit_turn(test: &TestCodex, prompt: &str) -> Result<()> {
-    let session_model = test.session_configured.model.clone();
-
-    test.codex
-        .submit(Op::UserTurn {
-            items: vec![UserInput::Text {
-                text: prompt.into(),
-            }],
-            final_output_json_schema: None,
-            cwd: test.cwd.path().to_path_buf(),
-            approval_policy: AskForApproval::Never,
-            sandbox_policy: SandboxPolicy::DangerFullAccess,
-            model: session_model,
-            effort: None,
-            summary: ReasoningSummary::Auto,
-        })
-        .await?;
-
-    wait_for_event(&test.codex, |event| {
-        matches!(event, EventMsg::TaskComplete(_))
-    })
-    .await;
-    Ok(())
-}
-
-async fn mount_tool_sequence(
-    server: &wiremock::MockServer,
-    call_id: &str,
-    arguments: &str,
-    tool_name: &str,
-) {
-    let first_response = sse(vec![
-        ev_response_created("resp-1"),
-        ev_function_call(call_id, tool_name, arguments),
-        ev_completed("resp-1"),
-    ]);
-    responses::mount_sse_once_match(server, any(), first_response).await;
-
-    let second_response = sse(vec![
-        ev_assistant_message("msg-1", "done"),
-        ev_completed("resp-2"),
-    ]);
-    responses::mount_sse_once_match(server, any(), second_response).await;
-}
-
-#[allow(clippy::expect_used)]
-async fn recorded_bodies(server: &wiremock::MockServer) -> Result<Vec<Value>> {
-    let requests = server.received_requests().await.expect("requests recorded");
-    Ok(requests
-        .iter()
-        .map(|req| req.body_json::<Value>().expect("request json"))
-        .collect())
-}
-
-fn find_tool_output<'a>(requests: &'a [Value], call_id: &str) -> Option<&'a Value> {
-    requests.iter().find_map(|body| {
-        body.get("input")
-            .and_then(Value::as_array)
-            .and_then(|items| {
-                items.iter().find(|item| {
-                    item.get("type").and_then(Value::as_str) == Some("function_call_output")
-                        && item.get("call_id").and_then(Value::as_str) == Some(call_id)
-                })
-            })
-    })
-}
-
 fn collect_file_names(content: &str) -> HashSet<String> {
     content
         .lines()
@@ -224,14 +148,3 @@ fn collect_file_names(content: &str) -> HashSet<String> {
         })
         .collect()
 }
-
-fn extract_content_and_success(value: &Value) -> (Option<&str>, Option<bool>) {
-    match value {
-        Value::String(text) => (Some(text.as_str()), None),
-        Value::Object(obj) => (
-            obj.get("content").and_then(Value::as_str),
-            obj.get("success").and_then(Value::as_bool),
-        ),
-        _ => (None, None),
-    }
-}