Add exec/run one-off turn API to app-server

codex-rs/app-server/tests/suite/v2/exec_run.rs

@@ -0,0 +1,139 @@
+use anyhow::Result;
+use app_test_support::McpProcess;
+use app_test_support::create_final_assistant_message_sse_response;
+use app_test_support::create_mock_responses_server_sequence_unchecked;
+use app_test_support::to_response;
+use codex_app_server_protocol::ExecRunParams;
+use codex_app_server_protocol::ExecRunResponse;
+use codex_app_server_protocol::JSONRPCResponse;
+use codex_app_server_protocol::RequestId;
+use codex_app_server_protocol::TurnStatus;
+use codex_app_server_protocol::UserInput as V2UserInput;
+use core_test_support::skip_if_no_network;
+use pretty_assertions::assert_eq;
+use std::path::Path;
+use tempfile::TempDir;
+use tokio::time::timeout;
+
+const DEFAULT_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
+const INVALID_REQUEST_ERROR_CODE: i64 = -32600;
+
+#[tokio::test]
+async fn exec_run_completes_turn_and_returns_final_message() -> Result<()> {
+    skip_if_no_network!(Ok(()));
+
+    let responses = vec![create_final_assistant_message_sse_response("Done")?];
+    let server = create_mock_responses_server_sequence_unchecked(responses).await;
+
+    let codex_home = TempDir::new()?;
+    create_config_toml(codex_home.path(), &server.uri())?;
+
+    let mut mcp = McpProcess::new(codex_home.path()).await?;
+    mcp.initialize().await?;
+
+    let request_id = mcp
+        .send_exec_run_request(ExecRunParams {
+            input: vec![V2UserInput::Text {
+                text: "Generate a title".to_string(),
+                text_elements: Vec::new(),
+            }],
+            model: None,
+            model_provider: None,
+            cwd: None,
+            approval_policy: None,
+            sandbox_policy: None,
+            effort: None,
+            summary: None,
+            collaboration_mode: None,
+            personality: None,
+            config: None,
+            base_instructions: None,
+            developer_instructions: None,
+            output_schema: None,
+            ephemeral: None,
+        })
+        .await?;
+
+    let response: JSONRPCResponse = timeout(
+        DEFAULT_READ_TIMEOUT,
+        mcp.read_stream_until_response_message(RequestId::Integer(request_id)),
+    )
+    .await??;
+    let response: ExecRunResponse = to_response(response)?;
+
+    assert_eq!(response.status, TurnStatus::Completed);
+    assert_eq!(response.last_agent_message, Some("Done".to_string()));
+    assert_eq!(response.error, None);
+    assert!(!response.thread_id.is_empty(), "thread_id should be set");
+    assert!(!response.turn_id.is_empty(), "turn_id should be set");
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn exec_run_rejects_empty_input() -> Result<()> {
+    skip_if_no_network!(Ok(()));
+
+    let responses = vec![create_final_assistant_message_sse_response("Done")?];
+    let server = create_mock_responses_server_sequence_unchecked(responses).await;
+
+    let codex_home = TempDir::new()?;
+    create_config_toml(codex_home.path(), &server.uri())?;
+
+    let mut mcp = McpProcess::new(codex_home.path()).await?;
+    mcp.initialize().await?;
+
+    let request_id = mcp
+        .send_exec_run_request(ExecRunParams {
+            input: Vec::new(),
+            model: None,
+            model_provider: None,
+            cwd: None,
+            approval_policy: None,
+            sandbox_policy: None,
+            effort: None,
+            summary: None,
+            collaboration_mode: None,
+            personality: None,
+            config: None,
+            base_instructions: None,
+            developer_instructions: None,
+            output_schema: None,
+            ephemeral: None,
+        })
+        .await?;
+
+    let error = timeout(
+        DEFAULT_READ_TIMEOUT,
+        mcp.read_stream_until_error_message(RequestId::Integer(request_id)),
+    )
+    .await??;
+
+    assert_eq!(error.error.code, INVALID_REQUEST_ERROR_CODE);
+    assert_eq!(error.error.message, "input must not be empty".to_string());
+
+    Ok(())
+}
+
+fn create_config_toml(codex_home: &Path, server_uri: &str) -> std::io::Result<()> {
+    let config_toml = codex_home.join("config.toml");
+    std::fs::write(
+        config_toml,
+        format!(
+            r#"
+model = "mock-model"
+approval_policy = "never"
+sandbox_mode = "read-only"
+
+model_provider = "mock_provider"
+
+[model_providers.mock_provider]
+name = "Mock provider for test"
+base_url = "{server_uri}/v1"
+wire_api = "responses"
+request_max_retries = 0
+stream_max_retries = 0
+"#
+        ),
+    )
+}