Replay EventMsgs from Response Items when resuming a session with history. (#3123)

### Overview

This PR introduces the following changes:
	1.	Adds a unified mechanism to convert ResponseItem into EventMsg.
2. Ensures that when a session is initialized with initial history, a
vector of EventMsg is sent along with the session configuration. This
allows clients to re-render the UI accordingly.
	3. 	Added integration testing

### Caveats

This implementation does not send every EventMsg that was previously
dispatched to clients. The excluded events fall into two categories:
	•	“Arguably” rolled-out events
Examples include tool calls and apply-patch calls. While these events
are conceptually rolled out, we currently only roll out ResponseItems.
These events are already being handled elsewhere and transformed into
EventMsg before being sent.
	•	Non-rolled-out events
Certain events such as TurnDiff, Error, and TokenCount are not rolled
out at all.

### Future Directions

At present, resuming a session involves maintaining two states:
	•	UI State
Clients can replay most of the important UI from the provided EventMsg
history.
	•	Model State
The model receives the complete session history to reconstruct its
internal state.

This design provides a solid foundation. If, in the future, more precise
UI reconstruction is needed, we have two potential paths:
1. Introduce a third data structure that allows us to derive both
ResponseItems and EventMsgs.
2. Clearly divide responsibilities: the core system ensures the
integrity of the model state, while clients are responsible for
reconstructing the UI.

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

@@ -13,6 +13,7 @@ use core_test_support::load_default_config_for_test;
 use core_test_support::load_sse_fixture_with_id;
 use core_test_support::wait_for_event;
 use serde_json::json;
+use std::io::Write;
 use tempfile::TempDir;
 use wiremock::Mock;
 use wiremock::MockServer;
@@ -108,6 +109,107 @@ fn write_auth_json(
     fake_jwt
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn resume_includes_initial_messages_and_sends_prior_items() {
+    if std::env::var(CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR).is_ok() {
+        println!(
+            "Skipping test because it cannot execute when network is disabled in a Codex sandbox."
+        );
+        return;
+    }
+
+    // Create a fake rollout session file with one prior assistant message.
+    let tmpdir = TempDir::new().unwrap();
+    let session_path = tmpdir.path().join("resume-session.jsonl");
+    let mut f = std::fs::File::create(&session_path).unwrap();
+    // First line: meta (content not used by reader other than non-empty)
+    writeln!(f, "{}", serde_json::json!({"meta":"test"})).unwrap();
+
+    // Prior item: assistant message
+    let prior_item = codex_protocol::models::ResponseItem::Message {
+        id: None,
+        role: "assistant".to_string(),
+        content: vec![codex_protocol::models::ContentItem::OutputText {
+            text: "resumed assistant message".to_string(),
+        }],
+    };
+    writeln!(f, "{}", serde_json::to_string(&prior_item).unwrap()).unwrap();
+    drop(f);
+
+    // Mock server that will receive the resumed request
+    let server = MockServer::start().await;
+    let first = ResponseTemplate::new(200)
+        .insert_header("content-type", "text/event-stream")
+        .set_body_raw(sse_completed("resp1"), "text/event-stream");
+    Mock::given(method("POST"))
+        .and(path("/v1/responses"))
+        .respond_with(first)
+        .expect(1)
+        .mount(&server)
+        .await;
+
+    // Configure Codex to resume from our file
+    let model_provider = ModelProviderInfo {
+        base_url: Some(format!("{}/v1", server.uri())),
+        ..built_in_model_providers()["openai"].clone()
+    };
+    let codex_home = TempDir::new().unwrap();
+    let mut config = load_default_config_for_test(&codex_home);
+    config.model_provider = model_provider;
+    config.experimental_resume = Some(session_path.clone());
+
+    let conversation_manager =
+        ConversationManager::with_auth(CodexAuth::from_api_key("Test API Key"));
+    let NewConversation {
+        conversation: codex,
+        session_configured,
+        ..
+    } = conversation_manager
+        .new_conversation(config)
+        .await
+        .expect("create new conversation");
+
+    // 1) Assert initial_messages contains the prior assistant message as an EventMsg
+    let initial_msgs = session_configured
+        .initial_messages
+        .clone()
+        .expect("expected initial messages for resumed session");
+    let initial_json = serde_json::to_value(&initial_msgs).unwrap();
+    let expected_initial_json = serde_json::json!([
+        { "type": "agent_message", "message": "resumed assistant message" }
+    ]);
+    assert_eq!(initial_json, expected_initial_json);
+
+    // 2) Submit new input; the request body must include the prior item followed by the new user input.
+    codex
+        .submit(Op::UserInput {
+            items: vec![InputItem::Text {
+                text: "hello".into(),
+            }],
+        })
+        .await
+        .unwrap();
+    wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
+
+    let request = &server.received_requests().await.unwrap()[0];
+    let request_body = request.body_json::<serde_json::Value>().unwrap();
+    let expected_input = serde_json::json!([
+        {
+            "type": "message",
+            "id": null,
+            "role": "assistant",
+            "content": [{ "type": "output_text", "text": "resumed assistant message" }]
+        },
+        {
+            "type": "message",
+            "id": null,
+            "role": "user",
+            "content": [{ "type": "input_text", "text": "hello" }]
+        }
+    ]);
+    assert_eq!(request_body["input"], expected_input);
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn includes_session_id_and_model_headers_in_request() {
     if std::env::var(CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR).is_ok() {