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/codex-api/src/lib.rs

@@ -63,7 +63,6 @@ pub use crate::provider::Provider;
 pub use crate::provider::RetryConfig;
 pub use crate::provider::is_azure_responses_provider;
 pub use crate::requests::Compression;
-pub use crate::sse::stream_from_fixture;
 pub use crate::telemetry::SseTelemetry;
 pub use crate::telemetry::WebsocketTelemetry;
 pub use codex_protocol::protocol::RealtimeAudioFrame;

codex-rs/codex-api/src/sse/mod.rs

@@ -3,4 +3,3 @@ pub(crate) mod responses;
 pub(crate) use responses::ResponsesStreamEvent;
 pub(crate) use responses::process_responses_event;
 pub use responses::spawn_response_stream;
-pub use responses::stream_from_fixture;

codex-rs/codex-api/src/sse/responses.rs

@@ -5,24 +5,19 @@ use crate::rate_limits::parse_all_rate_limits;
 use crate::telemetry::SseTelemetry;
 use codex_client::ByteStream;
 use codex_client::StreamResponse;
-use codex_client::TransportError;
 use codex_protocol::models::ResponseItem;
 use codex_protocol::protocol::ModelVerification;
 use codex_protocol::protocol::TokenUsage;
 use eventsource_stream::Eventsource;
 use futures::StreamExt;
-use futures::TryStreamExt;
 use serde::Deserialize;
 use serde_json::Value;
-use std::io::BufRead;
-use std::path::Path;
 use std::sync::Arc;
 use std::sync::OnceLock;
 use std::time::Duration;
 use tokio::sync::mpsc;
 use tokio::time::Instant;
 use tokio::time::timeout;
-use tokio_util::io::ReaderStream;
 use tracing::debug;
 use tracing::trace;
 
@@ -31,35 +26,6 @@ const OPENAI_MODEL_HEADER: &str = "openai-model";
 const REQUEST_ID_HEADER: &str = "x-request-id";
 const TRUSTED_ACCESS_FOR_CYBER_VERIFICATION: &str = "trusted_access_for_cyber";
 
-/// Streams SSE events from an on-disk fixture for tests.
-pub fn stream_from_fixture(
-    path: impl AsRef<Path>,
-    idle_timeout: Duration,
-) -> Result<ResponseStream, ApiError> {
-    let file =
-        std::fs::File::open(path.as_ref()).map_err(|err| ApiError::Stream(err.to_string()))?;
-    let mut content = String::new();
-    for line in std::io::BufReader::new(file).lines() {
-        let line = line.map_err(|err| ApiError::Stream(err.to_string()))?;
-        content.push_str(&line);
-        content.push_str("\n\n");
-    }
-
-    let reader = std::io::Cursor::new(content);
-    let stream = ReaderStream::new(reader).map_err(|err| TransportError::Network(err.to_string()));
-    let (tx_event, rx_event) = mpsc::channel::<Result<ResponseEvent, ApiError>>(1600);
-    tokio::spawn(process_sse(
-        Box::pin(stream),
-        tx_event,
-        idle_timeout,
-        /*telemetry*/ None,
-    ));
-    Ok(ResponseStream {
-        rx_event,
-        upstream_request_id: None,
-    })
-}
-
 pub fn spawn_response_stream(
     stream_response: StreamResponse,
     idle_timeout: Duration,
@@ -593,8 +559,10 @@ mod tests {
     use assert_matches::assert_matches;
     use bytes::Bytes;
     use codex_client::StreamResponse;
+    use codex_client::TransportError;
     use codex_protocol::models::MessagePhase;
     use codex_protocol::models::ResponseItem;
+    use futures::TryStreamExt;
     use futures::stream;
     use http::HeaderMap;
     use http::HeaderValue;
@@ -603,6 +571,7 @@ mod tests {
     use serde_json::json;
     use tokio::sync::mpsc;
     use tokio_test::io::Builder as IoBuilder;
+    use tokio_util::io::ReaderStream;
 
     async fn collect_events(chunks: &[&[u8]]) -> Vec<Result<ResponseEvent, ApiError>> {
         let mut builder = IoBuilder::new();