fix: change EventMsg enum so every variant takes a single struct (#925)

https://github.com/openai/codex/pull/922 did this for the
`SessionConfigured` enum variant, and I think it is generally helpful to
be able to work with the values as each enum variant as their own type,
so this converts the remaining variants and updates all of the
callsites.

Added a simple unit test to verify that the JSON-serialized version of
`Event` does not have any unexpected nesting.

codex-rs/exec/src/event_processor.rs

@@ -1,8 +1,17 @@
 use chrono::Utc;
 use codex_common::elapsed::format_elapsed;
+use codex_core::protocol::AgentMessageEvent;
+use codex_core::protocol::BackgroundEventEvent;
+use codex_core::protocol::ErrorEvent;
 use codex_core::protocol::Event;
 use codex_core::protocol::EventMsg;
+use codex_core::protocol::ExecCommandBeginEvent;
+use codex_core::protocol::ExecCommandEndEvent;
 use codex_core::protocol::FileChange;
+use codex_core::protocol::McpToolCallBeginEvent;
+use codex_core::protocol::McpToolCallEndEvent;
+use codex_core::protocol::PatchApplyBeginEvent;
+use codex_core::protocol::PatchApplyEndEvent;
 use owo_colors::OwoColorize;
 use owo_colors::Style;
 use shlex::try_join;
@@ -95,11 +104,11 @@ impl EventProcessor {
     pub(crate) fn process_event(&mut self, event: Event) {
         let Event { id, msg } = event;
         match msg {
-            EventMsg::Error { message } => {
+            EventMsg::Error(ErrorEvent { message }) => {
                 let prefix = "ERROR:".style(self.red);
                 ts_println!("{prefix} {message}");
             }
-            EventMsg::BackgroundEvent { message } => {
+            EventMsg::BackgroundEvent(BackgroundEventEvent { message }) => {
                 ts_println!("{}", message.style(self.dimmed));
             }
             EventMsg::TaskStarted => {
@@ -110,15 +119,15 @@ impl EventProcessor {
                 let msg = format!("Task complete: {id}");
                 ts_println!("{}", msg.style(self.bold));
             }
-            EventMsg::AgentMessage { message } => {
+            EventMsg::AgentMessage(AgentMessageEvent { message }) => {
                 let prefix = "Agent message:".style(self.bold);
                 ts_println!("{prefix} {message}");
             }
-            EventMsg::ExecCommandBegin {
+            EventMsg::ExecCommandBegin(ExecCommandBeginEvent {
                 call_id,
                 command,
                 cwd,
-            } => {
+            }) => {
                 self.call_id_to_command.insert(
                     call_id.clone(),
                     ExecCommandBegin {
@@ -133,12 +142,12 @@ impl EventProcessor {
                     cwd.to_string_lossy(),
                 );
             }
-            EventMsg::ExecCommandEnd {
+            EventMsg::ExecCommandEnd(ExecCommandEndEvent {
                 call_id,
                 stdout,
                 stderr,
                 exit_code,
-            } => {
+            }) => {
                 let exec_command = self.call_id_to_command.remove(&call_id);
                 let (duration, call) = if let Some(ExecCommandBegin {
                     command,
@@ -173,19 +182,21 @@ impl EventProcessor {
             }
 
             // Handle MCP tool calls (e.g. calling external functions via MCP).
-            EventMsg::McpToolCallBegin {
+            EventMsg::McpToolCallBegin(McpToolCallBeginEvent {
                 call_id,
                 server,
                 tool,
                 arguments,
-            } => {
+            }) => {
                 // Build fully-qualified tool name: server.tool
                 let fq_tool_name = format!("{server}.{tool}");
 
                 // Format arguments as compact JSON so they fit on one line.
                 let args_str = arguments
                     .as_ref()
-                    .map(|v| serde_json::to_string(v).unwrap_or_else(|_| v.to_string()))
+                    .map(|v: &serde_json::Value| {
+                        serde_json::to_string(v).unwrap_or_else(|_| v.to_string())
+                    })
                     .unwrap_or_default();
 
                 let invocation = if args_str.is_empty() {
@@ -208,11 +219,11 @@ impl EventProcessor {
                     invocation.style(self.bold),
                 );
             }
-            EventMsg::McpToolCallEnd {
+            EventMsg::McpToolCallEnd(McpToolCallEndEvent {
                 call_id,
                 success,
                 result,
-            } => {
+            }) => {
                 // Retrieve start time and invocation for duration calculation and labeling.
                 let info = self.call_id_to_tool_call.remove(&call_id);
 
@@ -243,11 +254,11 @@ impl EventProcessor {
                     }
                 }
             }
-            EventMsg::PatchApplyBegin {
+            EventMsg::PatchApplyBegin(PatchApplyBeginEvent {
                 call_id,
                 auto_approved,
                 changes,
-            } => {
+            }) => {
                 // Store metadata so we can calculate duration later when we
                 // receive the corresponding PatchApplyEnd event.
                 self.call_id_to_patch.insert(
@@ -321,12 +332,12 @@ impl EventProcessor {
                     }
                 }
             }
-            EventMsg::PatchApplyEnd {
+            EventMsg::PatchApplyEnd(PatchApplyEndEvent {
                 call_id,
                 stdout,
                 stderr,
                 success,
-            } => {
+            }) => {
                 let patch_begin = self.call_id_to_patch.remove(&call_id);
 
                 // Compute duration and summary label similar to exec commands.
@@ -355,10 +366,10 @@ impl EventProcessor {
                     println!("{}", line.style(self.dimmed));
                 }
             }
-            EventMsg::ExecApprovalRequest { .. } => {
+            EventMsg::ExecApprovalRequest(_) => {
                 // Should we exit?
             }
-            EventMsg::ApplyPatchApprovalRequest { .. } => {
+            EventMsg::ApplyPatchApprovalRequest(_) => {
                 // Should we exit?
             }
             _ => {