chore: nuke chat/completions API (#10157)

codex-rs/mcp-server/tests/common/lib.rs

@@ -6,7 +6,7 @@ pub use core_test_support::format_with_current_shell;
 pub use core_test_support::format_with_current_shell_display_non_login;
 pub use core_test_support::format_with_current_shell_non_login;
 pub use mcp_process::McpProcess;
-pub use mock_model_server::create_mock_chat_completions_server;
+pub use mock_model_server::create_mock_responses_server;
 pub use responses::create_apply_patch_sse_response;
 pub use responses::create_final_assistant_message_sse_response;
 pub use responses::create_shell_command_sse_response;

codex-rs/mcp-server/tests/common/mock_model_server.rs

@@ -9,8 +9,8 @@ use wiremock::matchers::method;
 use wiremock::matchers::path;
 
 /// Create a mock server that will provide the responses, in order, for
-/// requests to the `/v1/chat/completions` endpoint.
-pub async fn create_mock_chat_completions_server(responses: Vec<String>) -> MockServer {
+/// requests to the `/v1/responses` endpoint.
+pub async fn create_mock_responses_server(responses: Vec<String>) -> MockServer {
     let server = MockServer::start().await;
 
     let num_calls = responses.len();
@@ -20,7 +20,7 @@ pub async fn create_mock_chat_completions_server(responses: Vec<String>) -> Mock
     };
 
     Mock::given(method("POST"))
-        .and(path("/v1/chat/completions"))
+        .and(path("/v1/responses"))
         .respond_with(seq_responder)
         .expect(num_calls as u64)
         .mount(&server)

codex-rs/mcp-server/tests/common/responses.rs

@@ -1,96 +1,47 @@
-use serde_json::json;
 use std::path::Path;
 
+use core_test_support::responses;
+use serde_json::json;
+
 pub fn create_shell_command_sse_response(
     command: Vec<String>,
     workdir: Option<&Path>,
     timeout_ms: Option<u64>,
     call_id: &str,
 ) -> anyhow::Result<String> {
-    // The `arguments` for the `shell_command` tool is a serialized JSON object.
     let command_str = shlex::try_join(command.iter().map(String::as_str))?;
-    let tool_call_arguments = serde_json::to_string(&json!({
+    let arguments = serde_json::to_string(&json!({
         "command": command_str,
         "workdir": workdir.map(|w| w.to_string_lossy()),
-        "timeout_ms": timeout_ms
+        "timeout_ms": timeout_ms,
     }))?;
-    let tool_call = json!({
-        "choices": [
-            {
-                "delta": {
-                    "tool_calls": [
-                        {
-                            "id": call_id,
-                            "function": {
-                                "name": "shell_command",
-                                "arguments": tool_call_arguments
-                            }
-                        }
-                    ]
-                },
-                "finish_reason": "tool_calls"
-            }
-        ]
-    });
-
-    let sse = format!(
-        "data: {}\n\ndata: DONE\n\n",
-        serde_json::to_string(&tool_call)?
-    );
-    Ok(sse)
+    let response_id = format!("resp-{call_id}");
+    Ok(responses::sse(vec![
+        responses::ev_response_created(&response_id),
+        responses::ev_function_call(call_id, "shell_command", &arguments),
+        responses::ev_completed(&response_id),
+    ]))
 }
 
 pub fn create_final_assistant_message_sse_response(message: &str) -> anyhow::Result<String> {
-    let assistant_message = json!({
-        "choices": [
-            {
-                "delta": {
-                    "content": message
-                },
-                "finish_reason": "stop"
-            }
-        ]
-    });
-
-    let sse = format!(
-        "data: {}\n\ndata: DONE\n\n",
-        serde_json::to_string(&assistant_message)?
-    );
-    Ok(sse)
+    let response_id = "resp-final";
+    Ok(responses::sse(vec![
+        responses::ev_response_created(response_id),
+        responses::ev_assistant_message("msg-final", message),
+        responses::ev_completed(response_id),
+    ]))
 }
 
 pub fn create_apply_patch_sse_response(
     patch_content: &str,
     call_id: &str,
 ) -> anyhow::Result<String> {
-    // Use shell_command to call apply_patch with heredoc format
     let command = format!("apply_patch <<'EOF'\n{patch_content}\nEOF");
-    let tool_call_arguments = serde_json::to_string(&json!({
-        "command": command
-    }))?;
-
-    let tool_call = json!({
-        "choices": [
-            {
-                "delta": {
-                    "tool_calls": [
-                        {
-                            "id": call_id,
-                            "function": {
-                                "name": "shell_command",
-                                "arguments": tool_call_arguments
-                            }
-                        }
-                    ]
-                },
-                "finish_reason": "tool_calls"
-            }
-        ]
-    });
-
-    let sse = format!(
-        "data: {}\n\ndata: DONE\n\n",
-        serde_json::to_string(&tool_call)?
-    );
-    Ok(sse)
+    let arguments = serde_json::to_string(&json!({ "command": command }))?;
+    let response_id = format!("resp-{call_id}");
+    Ok(responses::sse(vec![
+        responses::ev_response_created(&response_id),
+        responses::ev_function_call(call_id, "shell_command", &arguments),
+        responses::ev_completed(&response_id),
+    ]))
 }