Remove CODEX_RS_SSE_FIXTURE test hook (#22413)

## Why

`CODEX_RS_SSE_FIXTURE` let integration-style CLI, exec, and TUI tests
bypass the normal Responses transport by reading SSE from local files.
That kept test-only behavior wired through production client code. The
affected tests can stay hermetic by using the existing
`core_test_support::responses` mock server and passing `openai_base_url`
instead.

## What Changed

- Removed the `CODEX_RS_SSE_FIXTURE` flag,
`codex_api::stream_from_fixture`, the `env-flags` dependency, and the
checked-in SSE fixture files.
- Repointed the affected core, exec, and TUI tests at `MockServer` with
the existing SSE event constructors.
- Removed the Bazel test data plumbing for the deleted fixtures and
refreshed cargo/Bazel lock state.

## Verification

- `cargo build -p codex-cli`
- `cargo test -p codex-api`
- `cargo test -p codex-core --test all responses_api_stream_cli`
- `cargo test -p codex-core --test all
integration_creates_and_checks_session_file`
- `cargo test -p codex-exec --test all ephemeral`
- `cargo test -p codex-exec --test all resume`
- `cargo test -p codex-tui --test all
resume_startup_does_not_consume_model_availability_nux_count`
- `just bazel-lock-update`
- `just bazel-lock-check`
- `just fix -p codex-api -p codex-core -p codex-exec -p codex-tui`
- `git diff --check`

codex-rs/core/BUILD.bazel

@@ -1,13 +1,5 @@
 load("//:defs.bzl", "codex_rust_crate")
 
-filegroup(
-    name = "model_availability_nux_fixtures",
-    srcs = [
-        "tests/cli_responses_fixture.sse",
-    ],
-    visibility = ["//visibility:public"],
-)
-
 codex_rust_crate(
     name = "core",
     crate_name = "codex_core",

codex-rs/core/Cargo.toml

@@ -77,7 +77,6 @@ codex-windows-sandbox = { package = "codex-windows-sandbox", path = "../windows-
 csv = { workspace = true }
 dirs = { workspace = true }
 dunce = { workspace = true }
-env-flags = { workspace = true }
 eventsource-stream = { workspace = true }
 futures = { workspace = true }
 http = { workspace = true }

codex-rs/core/src/client.rs

@@ -112,7 +112,6 @@ use crate::client_common::Prompt;
 use crate::client_common::ResponseEvent;
 use crate::client_common::ResponseStream;
 use crate::feedback_tags;
-use crate::flags::CODEX_RS_SSE_FIXTURE;
 use crate::util::emit_feedback_auth_recovery_tags;
 use codex_api::map_api_error;
 use codex_feedback::FeedbackRequestTags;
@@ -772,7 +771,6 @@ impl ModelClient {
     pub fn responses_websocket_enabled(&self) -> bool {
         if !self.state.provider.info().supports_websockets
             || self.state.disable_websockets.load(Ordering::Relaxed)
-            || (*CODEX_RS_SSE_FIXTURE).is_some()
         {
             return false;
         }
@@ -1194,8 +1192,7 @@ impl ModelClientSession {
 
     /// Streams a turn via the OpenAI Responses API.
     ///
-    /// Handles SSE fixtures, reasoning summaries, verbosity, and the
-    /// `text` controls used for output schemas.
+    /// Handles reasoning summaries, verbosity, and the `text` controls used for output schemas.
     #[allow(clippy::too_many_arguments)]
     #[instrument(
         name = "model_client.stream_responses_api",
@@ -1221,21 +1218,6 @@ impl ModelClientSession {
         turn_metadata_header: Option<&str>,
         inference_trace: &InferenceTraceContext,
     ) -> Result<ResponseStream> {
-        if let Some(path) = &*CODEX_RS_SSE_FIXTURE {
-            warn!(path, "Streaming from fixture");
-            let stream = codex_api::stream_from_fixture(
-                path,
-                self.client.state.provider.info().stream_idle_timeout(),
-            )
-            .map_err(map_api_error)?;
-            let (stream, _last_request_rx) = map_response_stream(
-                stream,
-                session_telemetry.clone(),
-                InferenceTraceAttempt::disabled(),
-            );
-            return Ok(stream);
-        }
-
         let auth_manager = self.client.state.provider.auth_manager();
         let mut auth_recovery = auth_manager
             .as_ref()

codex-rs/core/src/config/config_tests.rs

@@ -7250,8 +7250,7 @@ model_verbosity = "high"
 /// 2. as part of a profile, where the `--profile` is specified via a CLI
 ///    (or in the config file itself)
 /// 3. as an entry in `config.toml`, e.g. `model = "o3"`
-/// 4. the default value for a required field defined in code, e.g.,
-///    `crate::flags::OPENAI_DEFAULT_MODEL`
+/// 4. the default value for a required field defined in code.
 ///
 /// Note that profiles are the recommended way to specify a group of
 /// configuration options together.

codex-rs/core/src/flags.rs

@@ -1,6 +0,0 @@
-use env_flags::env_flags;
-
-env_flags! {
-    /// Fixture path for offline tests (see client.rs).
-    pub CODEX_RS_SSE_FIXTURE: Option<&str> = None;
-}

codex-rs/core/src/lib.rs

@@ -35,7 +35,6 @@ mod environment_selection;
 pub mod exec;
 pub mod exec_env;
 mod exec_policy;
-mod flags;
 #[cfg(test)]
 mod git_info_tests;
 mod goals;

codex-rs/core/tests/cli_responses_fixture.sse

@@ -1,8 +0,0 @@
-event: response.created
-data: {"type":"response.created","response":{"id":"resp1"}}
-
-event: response.output_item.done
-data: {"type":"response.output_item.done","item":{"type":"message","role":"assistant","content":[{"type":"output_text","text":"fixture hello"}]}}
-
-event: response.completed
-data: {"type":"response.completed","response":{"id":"resp1","output":[]}}

codex-rs/core/tests/common/BUILD.bazel

@@ -4,9 +4,6 @@ codex_rust_crate(
     name = "common",
     crate_name = "core_test_support",
     crate_srcs = glob(["*.rs"]),
-    lib_data_extra = [
-        "//codex-rs/core:model_availability_nux_fixtures",
-    ],
     deps_extra = [
         "@crates//:similar",
     ],

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

@@ -2,7 +2,6 @@ use assert_cmd::Command as AssertCommand;
 use codex_git_utils::collect_git_info;
 use codex_login::CODEX_API_KEY_ENV_VAR;
 use codex_protocol::protocol::GitInfo;
-use codex_utils_cargo_bin::find_resource;
 use core_test_support::fs_wait;
 use core_test_support::responses;
 use core_test_support::skip_if_no_network;
@@ -16,9 +15,12 @@ fn repo_root() -> std::path::PathBuf {
     codex_utils_cargo_bin::repo_root().expect("failed to resolve repo root")
 }
 
-fn cli_responses_fixture() -> std::path::PathBuf {
-    #[expect(clippy::expect_used)]
-    find_resource!("tests/cli_responses_fixture.sse").expect("failed to resolve fixture path")
+fn cli_sse_response() -> String {
+    responses::sse(vec![
+        responses::ev_response_created("resp-fixture"),
+        responses::ev_assistant_message("msg-fixture", "fixture hello"),
+        responses::ev_completed("resp-fixture"),
+    ])
 }
 
 /// Tests streaming the Responses API through the CLI using a mock server.
@@ -262,37 +264,36 @@ async fn exec_cli_profile_applies_model_instructions_file() {
     );
 }
 
-/// Tests streaming responses through the CLI using a local SSE fixture file.
-/// This test:
-/// 1. Uses a pre-recorded SSE response fixture instead of a live server
-/// 2. Configures codex to read from this fixture via CODEX_RS_SSE_FIXTURE env var
-/// 3. Sends a "hello?" prompt and verifies the response
-/// 4. Ensures the fixture content is correctly streamed through the CLI
+/// Tests streaming responses through the CLI using a local Responses API server.
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn responses_api_stream_cli() {
     skip_if_no_network!();
 
-    let fixture = cli_responses_fixture();
+    let server = MockServer::start().await;
+    let resp_mock = responses::mount_sse_once(&server, cli_sse_response()).await;
     let repo_root = repo_root();
 
     let home = TempDir::new().unwrap();
     let bin = codex_utils_cargo_bin::cargo_bin("codex").unwrap();
     let mut cmd = AssertCommand::new(bin);
+    cmd.timeout(Duration::from_secs(30));
     cmd.arg("exec")
         .arg("--skip-git-repo-check")
         .arg("-c")
-        .arg("openai_base_url=\"http://unused.local\"")
+        .arg(format!("openai_base_url=\"{}/v1\"", server.uri()))
         .arg("-C")
         .arg(&repo_root)
         .arg("hello?");
     cmd.env("CODEX_HOME", home.path())
-        .env("OPENAI_API_KEY", "dummy")
-        .env("CODEX_RS_SSE_FIXTURE", fixture);
+        .env("OPENAI_API_KEY", "dummy");
 
     let output = cmd.output().unwrap();
     assert!(output.status.success());
     let stdout = String::from_utf8_lossy(&output.stdout);
     assert!(stdout.contains("fixture hello"));
+
+    let request = resp_mock.single_request();
+    assert_eq!(request.path(), "/v1/responses");
 }
 
 /// End-to-end: create a session (writes rollout), verify the file, then resume and confirm append.
@@ -308,23 +309,25 @@ async fn integration_creates_and_checks_session_file() -> anyhow::Result<()> {
     let marker = format!("integration-test-{}", Uuid::new_v4());
     let prompt = format!("echo {marker}");
 
-    // 3. Use the same offline SSE fixture as responses_api_stream_cli so the test is hermetic.
-    let fixture = cli_responses_fixture();
+    // 3. Serve two hermetic SSE responses, one for the initial run and one for resume.
+    let server = MockServer::start().await;
+    let resp_mock =
+        responses::mount_sse_sequence(&server, vec![cli_sse_response(), cli_sse_response()]).await;
     let repo_root = repo_root();
 
     // 4. Run the codex CLI and invoke `exec`, which is what records a session.
     let bin = codex_utils_cargo_bin::cargo_bin("codex").unwrap();
     let mut cmd = AssertCommand::new(bin);
+    cmd.timeout(Duration::from_secs(30));
     cmd.arg("exec")
         .arg("--skip-git-repo-check")
         .arg("-c")
-        .arg("openai_base_url=\"http://unused.local\"")
+        .arg(format!("openai_base_url=\"{}/v1\"", server.uri()))
         .arg("-C")
         .arg(&repo_root)
         .arg(&prompt);
     cmd.env("CODEX_HOME", home.path())
-        .env(CODEX_API_KEY_ENV_VAR, "dummy")
-        .env("CODEX_RS_SSE_FIXTURE", &fixture);
+        .env(CODEX_API_KEY_ENV_VAR, "dummy");
 
     let output = cmd.output().unwrap();
     assert!(
@@ -436,21 +439,22 @@ async fn integration_creates_and_checks_session_file() -> anyhow::Result<()> {
     let prompt2 = format!("echo {marker2}");
     let bin2 = codex_utils_cargo_bin::cargo_bin("codex").unwrap();
     let mut cmd2 = AssertCommand::new(bin2);
+    cmd2.timeout(Duration::from_secs(30));
     cmd2.arg("exec")
         .arg("--skip-git-repo-check")
         .arg("-c")
-        .arg("openai_base_url=\"http://unused.local\"")
+        .arg(format!("openai_base_url=\"{}/v1\"", server.uri()))
         .arg("-C")
         .arg(&repo_root)
         .arg(&prompt2)
         .arg("resume")
         .arg("--last");
     cmd2.env("CODEX_HOME", home.path())
-        .env("OPENAI_API_KEY", "dummy")
-        .env("CODEX_RS_SSE_FIXTURE", &fixture);
+        .env("OPENAI_API_KEY", "dummy");
 
     let output2 = cmd2.output().unwrap();
     assert!(output2.status.success(), "resume codex-cli run failed");
+    assert_eq!(resp_mock.requests().len(), 2);
 
     // Find the new session file containing the resumed marker.
     let marker2_clone = marker2.clone();