fix: change EventMsg enum so every variant takes a single struct

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?
             }
             _ => {