Support alternative websocket API (#10861)

**Test plan**

```
cargo build -p codex-cli && RUST_LOG='codex_api::endpoint::responses_websocket=trace,codex_core::client=debug,codex_core::codex=debug' \
  ./target/debug/codex \
    --enable responses_websockets_v2 \
    --profile byok \
    --full-auto
```

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

@@ -1,4 +1,5 @@
 use anyhow::Result;
+use codex_core::features::Feature;
 use core_test_support::responses::WebSocketConnectionConfig;
 use core_test_support::responses::ev_assistant_message;
 use core_test_support::responses::ev_completed;
@@ -13,6 +14,8 @@ use pretty_assertions::assert_eq;
 use serde_json::Value;
 use std::time::Duration;
 
+const WS_V2_BETA_HEADER_VALUE: &str = "responses_websockets=2026-02-06";
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn websocket_test_codex_shell_chain() -> Result<()> {
     skip_if_no_network!(Ok(()));
@@ -120,3 +123,70 @@ async fn websocket_first_turn_waits_for_inflight_preconnect() -> Result<()> {
     server.shutdown().await;
     Ok(())
 }
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn websocket_v2_test_codex_shell_chain() -> Result<()> {
+    skip_if_no_network!(Ok(()));
+
+    let call_id = "shell-command-call";
+    let server = start_websocket_server(vec![vec![
+        vec![
+            ev_response_created("resp-1"),
+            ev_shell_command_call(call_id, "echo websocket"),
+            ev_completed("resp-1"),
+        ],
+        vec![
+            ev_response_created("resp-2"),
+            ev_assistant_message("msg-1", "done"),
+            ev_completed("resp-2"),
+        ],
+    ]])
+    .await;
+
+    let mut builder = test_codex().with_config(|config| {
+        config.features.enable(Feature::ResponsesWebsocketsV2);
+    });
+
+    let test = builder.build_with_websocket_server(&server).await?;
+    test.submit_turn("run the echo command").await?;
+
+    let connection = server.single_connection();
+    assert_eq!(connection.len(), 2);
+
+    let first = connection
+        .first()
+        .expect("missing first request")
+        .body_json();
+    let second = connection
+        .get(1)
+        .expect("missing second request")
+        .body_json();
+
+    assert_eq!(first["type"].as_str(), Some("response.create"));
+    assert_eq!(second["type"].as_str(), Some("response.create"));
+    assert_eq!(second["previous_response_id"].as_str(), Some("resp-1"));
+
+    let create_items = second
+        .get("input")
+        .and_then(Value::as_array)
+        .expect("response.create input array");
+    assert!(!create_items.is_empty());
+
+    let output_item = create_items
+        .iter()
+        .find(|item| item.get("type").and_then(Value::as_str) == Some("function_call_output"))
+        .expect("function_call_output in create");
+    assert_eq!(
+        output_item.get("call_id").and_then(Value::as_str),
+        Some(call_id)
+    );
+
+    let handshake = server.single_handshake();
+    assert_eq!(
+        handshake.header("openai-beta"),
+        Some(WS_V2_BETA_HEADER_VALUE.to_string())
+    );
+
+    server.shutdown().await;
+    Ok(())
+}

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

@@ -1273,6 +1273,7 @@ async fn azure_responses_request_includes_store_and_reasoning_ids() {
         false,
         false,
         false,
+        false,
         None,
     );
     let mut client_session = client.new_session();

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

@@ -42,6 +42,7 @@ use tracing_test::traced_test;
 const MODEL: &str = "gpt-5.2-codex";
 const OPENAI_BETA_HEADER: &str = "OpenAI-Beta";
 const OPENAI_BETA_RESPONSES_WEBSOCKETS: &str = "responses_websockets=2026-02-04";
+const WS_V2_BETA_HEADER_VALUE: &str = "responses_websockets=2026-02-06";
 
 struct WebsocketTestHarness {
     _codex_home: TempDir,
@@ -456,6 +457,165 @@ async fn responses_websocket_creates_on_non_prefix() {
     server.shutdown().await;
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn responses_websocket_v2_creates_with_previous_response_id_on_prefix() {
+    skip_if_no_network!();
+
+    let server = start_websocket_server(vec![vec![
+        vec![ev_response_created("resp-1"), ev_completed("resp-1")],
+        vec![ev_response_created("resp-2"), ev_completed("resp-2")],
+    ]])
+    .await;
+
+    let harness = websocket_harness_with_v2(&server, true).await;
+    let mut session = harness.client.new_session();
+    let prompt_one = prompt_with_input(vec![message_item("hello")]);
+    let prompt_two = prompt_with_input(vec![message_item("hello"), message_item("second")]);
+
+    stream_until_complete(&mut session, &harness, &prompt_one).await;
+    stream_until_complete(&mut session, &harness, &prompt_two).await;
+
+    let connection = server.single_connection();
+    assert_eq!(connection.len(), 2);
+    let first = connection.first().expect("missing request").body_json();
+    let second = connection.get(1).expect("missing request").body_json();
+
+    assert_eq!(first["type"].as_str(), Some("response.create"));
+    assert_eq!(second["type"].as_str(), Some("response.create"));
+    assert_eq!(second["previous_response_id"].as_str(), Some("resp-1"));
+    assert_eq!(
+        second["input"],
+        serde_json::to_value(&prompt_two.input[1..]).unwrap()
+    );
+
+    server.shutdown().await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn responses_websocket_v2_after_error_uses_full_create_without_previous_response_id() {
+    skip_if_no_network!();
+
+    let server = start_websocket_server(vec![
+        vec![
+            vec![ev_response_created("resp-1"), ev_completed("resp-1")],
+            vec![json!({
+                "type": "response.failed",
+                "response": {
+                    "error": {
+                        "code": "invalid_prompt",
+                        "message": "synthetic websocket failure"
+                    }
+                }
+            })],
+        ],
+        vec![vec![ev_response_created("resp-3"), ev_completed("resp-3")]],
+    ])
+    .await;
+
+    let harness = websocket_harness_with_v2(&server, true).await;
+    let mut session = harness.client.new_session();
+    let prompt_one = prompt_with_input(vec![message_item("hello")]);
+    let prompt_two = prompt_with_input(vec![message_item("hello"), message_item("second")]);
+    let prompt_three = prompt_with_input(vec![
+        message_item("hello"),
+        message_item("second"),
+        message_item("third"),
+    ]);
+
+    stream_until_complete(&mut session, &harness, &prompt_one).await;
+
+    let mut second_stream = session
+        .stream(
+            &prompt_two,
+            &harness.model_info,
+            &harness.otel_manager,
+            harness.effort,
+            harness.summary,
+            None,
+        )
+        .await
+        .expect("websocket stream failed");
+    let mut saw_error = false;
+    while let Some(event) = second_stream.next().await {
+        if event.is_err() {
+            saw_error = true;
+            break;
+        }
+    }
+    assert!(saw_error, "expected second websocket stream to error");
+
+    stream_until_complete(&mut session, &harness, &prompt_three).await;
+
+    assert_eq!(server.handshakes().len(), 2);
+
+    let connections = server.connections();
+    assert_eq!(connections.len(), 2);
+    let first_connection = connections.first().expect("missing first connection");
+    assert_eq!(first_connection.len(), 2);
+
+    let first = first_connection
+        .first()
+        .expect("missing first request")
+        .body_json();
+    let second = first_connection
+        .get(1)
+        .expect("missing second request")
+        .body_json();
+    let third = connections
+        .get(1)
+        .and_then(|connection| connection.first())
+        .expect("missing third request")
+        .body_json();
+
+    assert_eq!(first["type"].as_str(), Some("response.create"));
+    assert_eq!(second["type"].as_str(), Some("response.create"));
+    assert_eq!(second["previous_response_id"].as_str(), Some("resp-1"));
+    assert_eq!(third["type"].as_str(), Some("response.create"));
+    assert_eq!(third.get("previous_response_id"), None);
+    assert_eq!(
+        third["input"],
+        serde_json::to_value(&prompt_three.input).unwrap()
+    );
+
+    server.shutdown().await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn responses_websocket_v2_sets_openai_beta_header() {
+    skip_if_no_network!();
+
+    let server = start_websocket_server(vec![vec![vec![
+        ev_response_created("resp-1"),
+        ev_completed("resp-1"),
+    ]]])
+    .await;
+
+    let harness = websocket_harness_with_v2(&server, true).await;
+    let mut session = harness.client.new_session();
+    let prompt = prompt_with_input(vec![message_item("hello")]);
+
+    stream_until_complete(&mut session, &harness, &prompt).await;
+
+    let handshake = server.single_handshake();
+    let openai_beta_header = handshake
+        .header(OPENAI_BETA_HEADER)
+        .expect("missing OpenAI-Beta header");
+    assert!(
+        openai_beta_header
+            .split(',')
+            .map(str::trim)
+            .any(|value| value == WS_V2_BETA_HEADER_VALUE)
+    );
+    assert!(
+        !openai_beta_header
+            .split(',')
+            .map(str::trim)
+            .any(|value| value == OPENAI_BETA_RESPONSES_WEBSOCKETS)
+    );
+
+    server.shutdown().await;
+}
+
 fn message_item(text: &str) -> ResponseItem {
     ResponseItem::Message {
         id: None,
@@ -498,6 +658,21 @@ async fn websocket_harness(server: &WebSocketTestServer) -> WebsocketTestHarness
 async fn websocket_harness_with_runtime_metrics(
     server: &WebSocketTestServer,
     runtime_metrics_enabled: bool,
+) -> WebsocketTestHarness {
+    websocket_harness_with_options(server, runtime_metrics_enabled, false).await
+}
+
+async fn websocket_harness_with_v2(
+    server: &WebSocketTestServer,
+    websocket_v2_enabled: bool,
+) -> WebsocketTestHarness {
+    websocket_harness_with_options(server, false, websocket_v2_enabled).await
+}
+
+async fn websocket_harness_with_options(
+    server: &WebSocketTestServer,
+    runtime_metrics_enabled: bool,
+    websocket_v2_enabled: bool,
 ) -> WebsocketTestHarness {
     let provider = websocket_provider(server);
     let codex_home = TempDir::new().unwrap();
@@ -507,6 +682,9 @@ async fn websocket_harness_with_runtime_metrics(
     if runtime_metrics_enabled {
         config.features.enable(Feature::RuntimeMetrics);
     }
+    if websocket_v2_enabled {
+        config.features.enable(Feature::ResponsesWebsocketsV2);
+    }
     let config = Arc::new(config);
     let model_info = ModelsManager::construct_model_info_offline(MODEL, &config);
     let conversation_id = ThreadId::new();
@@ -538,6 +716,7 @@ async fn websocket_harness_with_runtime_metrics(
         SessionSource::Exec,
         config.model_verbosity,
         true,
+        websocket_v2_enabled,
         false,
         runtime_metrics_enabled,
         None,