codex_protocol/
legacy_events.rs

1use crate::ThreadId;
2use crate::dynamic_tools::DynamicToolCallRequest;
3use crate::items::AgentMessageContent;
4use crate::items::AgentMessageItem;
5use crate::items::CollabAgentTool;
6use crate::items::CollabAgentToolCallItem;
7use crate::items::CollabAgentToolCallStatus;
8use crate::items::CommandExecutionItem;
9use crate::items::CommandExecutionStatus;
10use crate::items::ContextCompactionItem;
11use crate::items::DynamicToolCallItem;
12use crate::items::DynamicToolCallStatus;
13use crate::items::EnteredReviewModeItem;
14use crate::items::ExitedReviewModeItem;
15use crate::items::FileChangeItem;
16use crate::items::ImageGenerationItem;
17use crate::items::McpToolCallItem;
18use crate::items::ReasoningItem;
19use crate::items::SubAgentActivityItem;
20use crate::items::TurnItem;
21use crate::items::UserMessageItem;
22use crate::items::WebSearchItem;
23use crate::protocol::AgentMessageContentDeltaEvent;
24use crate::protocol::AgentMessageEvent;
25use crate::protocol::AgentReasoningEvent;
26use crate::protocol::AgentReasoningRawContentEvent;
27use crate::protocol::AgentStatus;
28use crate::protocol::CollabAgentInteractionBeginEvent;
29use crate::protocol::CollabAgentInteractionEndEvent;
30use crate::protocol::CollabAgentSpawnBeginEvent;
31use crate::protocol::CollabAgentSpawnEndEvent;
32use crate::protocol::CollabAgentStatusEntry;
33use crate::protocol::CollabCloseBeginEvent;
34use crate::protocol::CollabCloseEndEvent;
35use crate::protocol::CollabResumeBeginEvent;
36use crate::protocol::CollabResumeEndEvent;
37use crate::protocol::CollabWaitingBeginEvent;
38use crate::protocol::CollabWaitingEndEvent;
39use crate::protocol::ContextCompactedEvent;
40use crate::protocol::DynamicToolCallResponseEvent;
41use crate::protocol::EnteredReviewModeEvent;
42use crate::protocol::EventMsg;
43use crate::protocol::ExecCommandBeginEvent;
44use crate::protocol::ExecCommandEndEvent;
45use crate::protocol::ExecCommandStatus;
46use crate::protocol::ExitedReviewModeEvent;
47use crate::protocol::ImageGenerationBeginEvent;
48use crate::protocol::ImageGenerationEndEvent;
49use crate::protocol::ItemCompletedEvent;
50use crate::protocol::ItemStartedEvent;
51use crate::protocol::McpInvocation;
52use crate::protocol::McpToolCallBeginEvent;
53use crate::protocol::McpToolCallEndEvent;
54use crate::protocol::PatchApplyBeginEvent;
55use crate::protocol::PatchApplyEndEvent;
56use crate::protocol::PatchApplyStatus;
57use crate::protocol::ReasoningContentDeltaEvent;
58use crate::protocol::ReasoningRawContentDeltaEvent;
59use crate::protocol::SubAgentActivityEvent;
60use crate::protocol::UserMessageEvent;
61use crate::protocol::ViewImageToolCallEvent;
62use crate::protocol::WebSearchBeginEvent;
63use crate::protocol::WebSearchEndEvent;
64
65/// Converts canonical item lifecycle events back into the legacy raw event stream used by
66/// compatibility consumers that have not migrated to `TurnItem`.
67pub trait HasLegacyEvent {
68    fn as_legacy_events(&self, show_raw_agent_reasoning: bool) -> Vec<EventMsg>;
69}
70
71impl ContextCompactionItem {
72    pub fn as_legacy_event(&self) -> EventMsg {
73        EventMsg::ContextCompacted(ContextCompactedEvent {})
74    }
75}
76
77impl UserMessageItem {
78    pub fn as_legacy_user_message_event(&self) -> UserMessageEvent {
79        // Legacy user-message events flatten only text inputs into `message` and
80        // rebase text element ranges onto that concatenated text.
81        UserMessageEvent {
82            client_id: self.client_id.clone(),
83            message: self.message(),
84            images: Some(self.image_urls()),
85            image_details: self.image_details(),
86            local_images: self.local_image_paths(),
87            local_image_details: self.local_image_details(),
88            audio: Some(self.audio_urls()),
89            local_audio: self.local_audio_paths(),
90            text_elements: self.text_elements(),
91        }
92    }
93
94    pub fn as_legacy_event(&self) -> EventMsg {
95        EventMsg::UserMessage(self.as_legacy_user_message_event())
96    }
97}
98
99impl AgentMessageItem {
100    pub fn as_legacy_events(&self) -> Vec<EventMsg> {
101        self.content
102            .iter()
103            .map(|c| match c {
104                AgentMessageContent::Text { text } => EventMsg::AgentMessage(AgentMessageEvent {
105                    message: text.clone(),
106                    phase: self.phase.clone(),
107                    memory_citation: self.memory_citation.clone(),
108                }),
109            })
110            .collect()
111    }
112}
113
114impl EnteredReviewModeItem {
115    pub fn as_legacy_event(&self, turn_id: String) -> EventMsg {
116        EventMsg::EnteredReviewMode(EnteredReviewModeEvent {
117            target: self.target.clone(),
118            user_facing_hint: Some(self.user_facing_hint.clone()),
119            turn_id: Some(turn_id),
120            item_id: Some(self.id.clone()),
121        })
122    }
123}
124
125impl ExitedReviewModeItem {
126    pub fn as_legacy_event(&self, turn_id: String) -> EventMsg {
127        EventMsg::ExitedReviewMode(ExitedReviewModeEvent {
128            turn_id: Some(turn_id),
129            item_id: Some(self.id.clone()),
130            review_output: self.review_output.clone(),
131        })
132    }
133}
134
135impl ReasoningItem {
136    pub fn as_legacy_events(&self, show_raw_agent_reasoning: bool) -> Vec<EventMsg> {
137        let mut events = Vec::new();
138        for summary in &self.summary_text {
139            events.push(EventMsg::AgentReasoning(AgentReasoningEvent {
140                text: summary.clone(),
141            }));
142        }
143
144        if show_raw_agent_reasoning {
145            for entry in &self.raw_content {
146                events.push(EventMsg::AgentReasoningRawContent(
147                    AgentReasoningRawContentEvent {
148                        text: entry.clone(),
149                    },
150                ));
151            }
152        }
153
154        events
155    }
156}
157
158impl CommandExecutionItem {
159    pub(crate) fn as_legacy_begin_event(&self, turn_id: String, started_at_ms: i64) -> EventMsg {
160        EventMsg::ExecCommandBegin(ExecCommandBeginEvent {
161            call_id: self.id.clone(),
162            process_id: self.process_id.clone(),
163            turn_id,
164            started_at_ms,
165            command: self.command.clone(),
166            cwd: self.cwd.clone(),
167            parsed_cmd: self.parsed_cmd.clone(),
168            source: self.source,
169            interaction_input: self.interaction_input.clone(),
170        })
171    }
172
173    pub(crate) fn as_legacy_end_event(
174        &self,
175        turn_id: String,
176        completed_at_ms: i64,
177    ) -> Option<EventMsg> {
178        let status = match self.status {
179            CommandExecutionStatus::InProgress => return None,
180            CommandExecutionStatus::Completed => ExecCommandStatus::Completed,
181            CommandExecutionStatus::Failed => ExecCommandStatus::Failed,
182            CommandExecutionStatus::Declined => ExecCommandStatus::Declined,
183        };
184        Some(EventMsg::ExecCommandEnd(ExecCommandEndEvent {
185            call_id: self.id.clone(),
186            process_id: self.process_id.clone(),
187            turn_id,
188            completed_at_ms,
189            command: self.command.clone(),
190            cwd: self.cwd.clone(),
191            parsed_cmd: self.parsed_cmd.clone(),
192            source: self.source,
193            interaction_input: self.interaction_input.clone(),
194            stdout: self.stdout.clone().unwrap_or_default(),
195            stderr: self.stderr.clone().unwrap_or_default(),
196            aggregated_output: self.aggregated_output.clone().unwrap_or_default(),
197            exit_code: self.exit_code.unwrap_or_default(),
198            duration: self.duration.unwrap_or_default(),
199            formatted_output: self.formatted_output.clone().unwrap_or_default(),
200            status,
201        }))
202    }
203}
204
205impl DynamicToolCallItem {
206    pub(crate) fn as_legacy_request_event(&self, turn_id: String, started_at_ms: i64) -> EventMsg {
207        EventMsg::DynamicToolCallRequest(DynamicToolCallRequest {
208            call_id: self.id.clone(),
209            turn_id,
210            started_at_ms,
211            namespace: self.namespace.clone(),
212            tool: self.tool.clone(),
213            arguments: self.arguments.clone(),
214        })
215    }
216
217    pub(crate) fn as_legacy_response_event(
218        &self,
219        turn_id: String,
220        completed_at_ms: i64,
221    ) -> Option<EventMsg> {
222        if matches!(self.status, DynamicToolCallStatus::InProgress) {
223            return None;
224        }
225        Some(EventMsg::DynamicToolCallResponse(
226            DynamicToolCallResponseEvent {
227                call_id: self.id.clone(),
228                turn_id,
229                completed_at_ms,
230                namespace: self.namespace.clone(),
231                tool: self.tool.clone(),
232                arguments: self.arguments.clone(),
233                content_items: self.content_items.clone().unwrap_or_default(),
234                success: self.success.unwrap_or(false),
235                error: self.error.clone(),
236                duration: self.duration.unwrap_or_default(),
237            },
238        ))
239    }
240}
241
242impl CollabAgentToolCallItem {
243    pub(crate) fn as_legacy_begin_event(&self, started_at_ms: i64) -> Option<EventMsg> {
244        let receiver_thread_id = self.receiver_thread_ids.first().copied();
245        match self.tool {
246            CollabAgentTool::SpawnAgent => Some(EventMsg::CollabAgentSpawnBegin(
247                CollabAgentSpawnBeginEvent {
248                    call_id: self.id.clone(),
249                    started_at_ms,
250                    sender_thread_id: self.sender_thread_id,
251                    prompt: self.prompt.clone().unwrap_or_default(),
252                    model: self.model.clone().unwrap_or_default(),
253                    reasoning_effort: self.reasoning_effort.clone().unwrap_or_default(),
254                },
255            )),
256            CollabAgentTool::SendInput => receiver_thread_id.map(|receiver_thread_id| {
257                EventMsg::CollabAgentInteractionBegin(CollabAgentInteractionBeginEvent {
258                    call_id: self.id.clone(),
259                    started_at_ms,
260                    sender_thread_id: self.sender_thread_id,
261                    receiver_thread_id,
262                    prompt: self.prompt.clone().unwrap_or_default(),
263                })
264            }),
265            CollabAgentTool::ResumeAgent => receiver_thread_id.map(|receiver_thread_id| {
266                let (receiver_agent_nickname, receiver_agent_role) =
267                    self.receiver_agent_identity(receiver_thread_id);
268                EventMsg::CollabResumeBegin(CollabResumeBeginEvent {
269                    call_id: self.id.clone(),
270                    started_at_ms,
271                    sender_thread_id: self.sender_thread_id,
272                    receiver_thread_id,
273                    receiver_agent_nickname,
274                    receiver_agent_role,
275                })
276            }),
277            CollabAgentTool::Wait => Some(EventMsg::CollabWaitingBegin(CollabWaitingBeginEvent {
278                started_at_ms,
279                sender_thread_id: self.sender_thread_id,
280                receiver_thread_ids: self.receiver_thread_ids.clone(),
281                receiver_agents: self.receiver_agents.clone(),
282                call_id: self.id.clone(),
283            })),
284            CollabAgentTool::CloseAgent => receiver_thread_id.map(|receiver_thread_id| {
285                EventMsg::CollabCloseBegin(CollabCloseBeginEvent {
286                    call_id: self.id.clone(),
287                    started_at_ms,
288                    sender_thread_id: self.sender_thread_id,
289                    receiver_thread_id,
290                })
291            }),
292        }
293    }
294
295    pub(crate) fn as_legacy_end_event(&self, completed_at_ms: i64) -> Option<EventMsg> {
296        if matches!(self.status, CollabAgentToolCallStatus::InProgress) {
297            return None;
298        }
299        let receiver_thread_id = self.receiver_thread_ids.first().copied();
300        match self.tool {
301            CollabAgentTool::SpawnAgent => {
302                let (new_agent_nickname, new_agent_role) = receiver_thread_id
303                    .map(|thread_id| self.receiver_agent_identity(thread_id))
304                    .unwrap_or_default();
305                Some(EventMsg::CollabAgentSpawnEnd(CollabAgentSpawnEndEvent {
306                    call_id: self.id.clone(),
307                    completed_at_ms,
308                    sender_thread_id: self.sender_thread_id,
309                    new_thread_id: receiver_thread_id,
310                    new_agent_nickname,
311                    new_agent_role,
312                    prompt: self.prompt.clone().unwrap_or_default(),
313                    model: self.model.clone().unwrap_or_default(),
314                    reasoning_effort: self.reasoning_effort.clone().unwrap_or_default(),
315                    status: receiver_thread_id
316                        .map(|thread_id| self.agent_status(thread_id))
317                        .unwrap_or(AgentStatus::NotFound),
318                }))
319            }
320            CollabAgentTool::SendInput => receiver_thread_id.map(|receiver_thread_id| {
321                let (receiver_agent_nickname, receiver_agent_role) =
322                    self.receiver_agent_identity(receiver_thread_id);
323                EventMsg::CollabAgentInteractionEnd(CollabAgentInteractionEndEvent {
324                    call_id: self.id.clone(),
325                    completed_at_ms,
326                    sender_thread_id: self.sender_thread_id,
327                    receiver_thread_id,
328                    receiver_agent_nickname,
329                    receiver_agent_role,
330                    prompt: self.prompt.clone().unwrap_or_default(),
331                    status: self.agent_status(receiver_thread_id),
332                })
333            }),
334            CollabAgentTool::ResumeAgent => receiver_thread_id.map(|receiver_thread_id| {
335                let (receiver_agent_nickname, receiver_agent_role) =
336                    self.receiver_agent_identity(receiver_thread_id);
337                EventMsg::CollabResumeEnd(CollabResumeEndEvent {
338                    call_id: self.id.clone(),
339                    completed_at_ms,
340                    sender_thread_id: self.sender_thread_id,
341                    receiver_thread_id,
342                    receiver_agent_nickname,
343                    receiver_agent_role,
344                    status: self.agent_status(receiver_thread_id),
345                })
346            }),
347            CollabAgentTool::Wait => Some(EventMsg::CollabWaitingEnd(CollabWaitingEndEvent {
348                sender_thread_id: self.sender_thread_id,
349                call_id: self.id.clone(),
350                completed_at_ms,
351                agent_statuses: self
352                    .receiver_agents
353                    .iter()
354                    .map(|agent| CollabAgentStatusEntry {
355                        thread_id: agent.thread_id,
356                        agent_nickname: agent.agent_nickname.clone(),
357                        agent_role: agent.agent_role.clone(),
358                        status: self.agent_status(agent.thread_id),
359                    })
360                    .collect(),
361                statuses: self.agents_states.clone(),
362            })),
363            CollabAgentTool::CloseAgent => receiver_thread_id.map(|receiver_thread_id| {
364                let (receiver_agent_nickname, receiver_agent_role) =
365                    self.receiver_agent_identity(receiver_thread_id);
366                EventMsg::CollabCloseEnd(CollabCloseEndEvent {
367                    call_id: self.id.clone(),
368                    completed_at_ms,
369                    sender_thread_id: self.sender_thread_id,
370                    receiver_thread_id,
371                    receiver_agent_nickname,
372                    receiver_agent_role,
373                    status: self.agent_status(receiver_thread_id),
374                })
375            }),
376        }
377    }
378
379    fn receiver_agent_identity(&self, thread_id: ThreadId) -> (Option<String>, Option<String>) {
380        let receiver_agent = self
381            .receiver_agents
382            .iter()
383            .find(|agent| agent.thread_id == thread_id);
384        (
385            receiver_agent.and_then(|agent| agent.agent_nickname.clone()),
386            receiver_agent.and_then(|agent| agent.agent_role.clone()),
387        )
388    }
389
390    fn agent_status(&self, thread_id: ThreadId) -> AgentStatus {
391        self.agents_states
392            .get(&thread_id)
393            .cloned()
394            .unwrap_or(AgentStatus::NotFound)
395    }
396}
397
398impl SubAgentActivityItem {
399    pub(crate) fn as_legacy_event(&self, occurred_at_ms: i64) -> EventMsg {
400        EventMsg::SubAgentActivity(SubAgentActivityEvent {
401            event_id: self.id.clone(),
402            occurred_at_ms,
403            agent_thread_id: self.agent_thread_id,
404            agent_path: self.agent_path.clone(),
405            kind: self.kind,
406        })
407    }
408}
409
410impl WebSearchItem {
411    pub fn as_legacy_event(&self) -> EventMsg {
412        EventMsg::WebSearchEnd(WebSearchEndEvent {
413            call_id: self.id.clone(),
414            query: self.query.clone(),
415            action: self.action.clone(),
416            results: self.results.clone(),
417        })
418    }
419}
420
421impl ImageGenerationItem {
422    pub fn as_legacy_event(&self) -> EventMsg {
423        EventMsg::ImageGenerationEnd(ImageGenerationEndEvent {
424            call_id: self.id.clone(),
425            status: self.status.clone(),
426            revised_prompt: self.revised_prompt.clone(),
427            result: self.result.clone(),
428            saved_path: self.saved_path.clone(),
429        })
430    }
431}
432
433impl FileChangeItem {
434    pub fn as_legacy_begin_event(&self, turn_id: String) -> EventMsg {
435        EventMsg::PatchApplyBegin(PatchApplyBeginEvent {
436            call_id: self.id.clone(),
437            turn_id,
438            auto_approved: self.auto_approved.unwrap_or(false),
439            changes: self.changes.clone(),
440        })
441    }
442
443    pub fn as_legacy_end_event(&self, turn_id: String) -> Option<EventMsg> {
444        let status = self.status.clone()?;
445        Some(EventMsg::PatchApplyEnd(PatchApplyEndEvent {
446            call_id: self.id.clone(),
447            turn_id,
448            stdout: self.stdout.clone().unwrap_or_default(),
449            stderr: self.stderr.clone().unwrap_or_default(),
450            success: status == PatchApplyStatus::Completed,
451            changes: self.changes.clone(),
452            status,
453        }))
454    }
455}
456
457impl McpToolCallItem {
458    pub fn as_legacy_begin_event(&self) -> EventMsg {
459        EventMsg::McpToolCallBegin(McpToolCallBeginEvent {
460            call_id: self.id.clone(),
461            invocation: McpInvocation {
462                server: self.server.clone(),
463                tool: self.tool.clone(),
464                arguments: (!self.arguments.is_null()).then(|| self.arguments.clone()),
465            },
466            connector_id: self.connector_id.clone(),
467            mcp_app_resource_uri: self.mcp_app_resource_uri.clone(),
468            link_id: self.link_id.clone(),
469            app_name: self.app_name.clone(),
470            action_name: self.action_name.clone(),
471            plugin_id: self.plugin_id.clone(),
472        })
473    }
474
475    pub fn as_legacy_end_event(&self) -> Option<EventMsg> {
476        let result = match (&self.result, &self.error) {
477            (Some(result), _) => Ok(result.clone()),
478            (None, Some(error)) => Err(error.message.clone()),
479            (None, None) => return None,
480        };
481
482        Some(EventMsg::McpToolCallEnd(McpToolCallEndEvent {
483            call_id: self.id.clone(),
484            invocation: McpInvocation {
485                server: self.server.clone(),
486                tool: self.tool.clone(),
487                arguments: (!self.arguments.is_null()).then(|| self.arguments.clone()),
488            },
489            mcp_app_resource_uri: self.mcp_app_resource_uri.clone(),
490            connector_id: self.connector_id.clone(),
491            link_id: self.link_id.clone(),
492            app_name: self.app_name.clone(),
493            action_name: self.action_name.clone(),
494            plugin_id: self.plugin_id.clone(),
495            duration: self.duration?,
496            result,
497        }))
498    }
499}
500
501impl TurnItem {
502    pub fn as_legacy_events(&self, show_raw_agent_reasoning: bool) -> Vec<EventMsg> {
503        match self {
504            TurnItem::UserMessage(item) => vec![item.as_legacy_event()],
505            TurnItem::HookPrompt(_) => Vec::new(),
506            TurnItem::AgentMessage(item) => item.as_legacy_events(),
507            TurnItem::Plan(_) => Vec::new(),
508            TurnItem::CommandExecution(_)
509            | TurnItem::DynamicToolCall(_)
510            | TurnItem::CollabAgentToolCall(_) => Vec::new(),
511            TurnItem::SubAgentActivity(_) => Vec::new(),
512            TurnItem::WebSearch(item) => vec![item.as_legacy_event()],
513            TurnItem::ImageView(item) => {
514                vec![EventMsg::ViewImageToolCall(ViewImageToolCallEvent {
515                    call_id: item.id.clone(),
516                    path: item.path.clone(),
517                })]
518            }
519            TurnItem::Extension(_) => Vec::new(),
520            TurnItem::ImageGeneration(item) => vec![item.as_legacy_event()],
521            TurnItem::EnteredReviewMode(_) | TurnItem::ExitedReviewMode(_) => Vec::new(),
522            TurnItem::FileChange(item) => item
523                .as_legacy_end_event(String::new())
524                .into_iter()
525                .collect(),
526            TurnItem::McpToolCall(item) => item.as_legacy_end_event().into_iter().collect(),
527            TurnItem::Reasoning(item) => item.as_legacy_events(show_raw_agent_reasoning),
528            TurnItem::ContextCompaction(item) => vec![item.as_legacy_event()],
529        }
530    }
531}
532
533impl HasLegacyEvent for ItemStartedEvent {
534    fn as_legacy_events(&self, _: bool) -> Vec<EventMsg> {
535        match &self.item {
536            TurnItem::WebSearch(item) => vec![EventMsg::WebSearchBegin(WebSearchBeginEvent {
537                call_id: item.id.clone(),
538            })],
539            TurnItem::ImageView(_) => Vec::new(),
540            TurnItem::ImageGeneration(item) => {
541                vec![EventMsg::ImageGenerationBegin(ImageGenerationBeginEvent {
542                    call_id: item.id.clone(),
543                })]
544            }
545            TurnItem::FileChange(item) => vec![item.as_legacy_begin_event(self.turn_id.clone())],
546            TurnItem::McpToolCall(item) => vec![item.as_legacy_begin_event()],
547            TurnItem::CommandExecution(item) => {
548                vec![item.as_legacy_begin_event(self.turn_id.clone(), self.started_at_ms)]
549            }
550            TurnItem::DynamicToolCall(item) => {
551                vec![item.as_legacy_request_event(self.turn_id.clone(), self.started_at_ms)]
552            }
553            TurnItem::CollabAgentToolCall(item) => item
554                .as_legacy_begin_event(self.started_at_ms)
555                .into_iter()
556                .collect(),
557            _ => Vec::new(),
558        }
559    }
560}
561
562impl HasLegacyEvent for ItemCompletedEvent {
563    fn as_legacy_events(&self, show_raw_agent_reasoning: bool) -> Vec<EventMsg> {
564        match &self.item {
565            TurnItem::FileChange(item) => item
566                .as_legacy_end_event(self.turn_id.clone())
567                .into_iter()
568                .collect(),
569            TurnItem::CommandExecution(item) => item
570                .as_legacy_end_event(self.turn_id.clone(), self.completed_at_ms)
571                .into_iter()
572                .collect(),
573            TurnItem::DynamicToolCall(item) => item
574                .as_legacy_response_event(self.turn_id.clone(), self.completed_at_ms)
575                .into_iter()
576                .collect(),
577            TurnItem::CollabAgentToolCall(item) => item
578                .as_legacy_end_event(self.completed_at_ms)
579                .into_iter()
580                .collect(),
581            TurnItem::SubAgentActivity(item) => {
582                vec![item.as_legacy_event(self.completed_at_ms)]
583            }
584            TurnItem::EnteredReviewMode(item) => {
585                vec![item.as_legacy_event(self.turn_id.clone())]
586            }
587            TurnItem::ExitedReviewMode(item) => {
588                vec![item.as_legacy_event(self.turn_id.clone())]
589            }
590            _ => self.item.as_legacy_events(show_raw_agent_reasoning),
591        }
592    }
593}
594
595impl HasLegacyEvent for AgentMessageContentDeltaEvent {
596    fn as_legacy_events(&self, _: bool) -> Vec<EventMsg> {
597        Vec::new()
598    }
599}
600
601impl HasLegacyEvent for ReasoningContentDeltaEvent {
602    fn as_legacy_events(&self, _: bool) -> Vec<EventMsg> {
603        Vec::new()
604    }
605}
606
607impl HasLegacyEvent for ReasoningRawContentDeltaEvent {
608    fn as_legacy_events(&self, _: bool) -> Vec<EventMsg> {
609        Vec::new()
610    }
611}
612
613impl HasLegacyEvent for EventMsg {
614    fn as_legacy_events(&self, show_raw_agent_reasoning: bool) -> Vec<EventMsg> {
615        match self {
616            EventMsg::ItemStarted(event) => event.as_legacy_events(show_raw_agent_reasoning),
617            EventMsg::ItemCompleted(event) => event.as_legacy_events(show_raw_agent_reasoning),
618            EventMsg::AgentMessageContentDelta(event) => {
619                event.as_legacy_events(show_raw_agent_reasoning)
620            }
621            EventMsg::ReasoningContentDelta(event) => {
622                event.as_legacy_events(show_raw_agent_reasoning)
623            }
624            EventMsg::ReasoningRawContentDelta(event) => {
625                event.as_legacy_events(show_raw_agent_reasoning)
626            }
627            _ => Vec::new(),
628        }
629    }
630}
codex_protocol/legacy_events.rs

codex_protocol/
legacy_events.rs
