Add turn.failed and rename session created to thread started (#4478)

Don't produce completed when turn failed.

codex-rs/exec/src/exec_events.rs

@@ -6,12 +6,14 @@ use ts_rs::TS;
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, TS)]
 #[serde(tag = "type")]
 pub enum ConversationEvent {
-    #[serde(rename = "session.created")]
-    SessionCreated(SessionCreatedEvent),
+    #[serde(rename = "thread.started")]
+    ThreadStarted(ThreadStartedEvent),
     #[serde(rename = "turn.started")]
     TurnStarted(TurnStartedEvent),
     #[serde(rename = "turn.completed")]
     TurnCompleted(TurnCompletedEvent),
+    #[serde(rename = "turn.failed")]
+    TurnFailed(TurnFailedEvent),
     #[serde(rename = "item.started")]
     ItemStarted(ItemStartedEvent),
     #[serde(rename = "item.updated")]
@@ -23,8 +25,8 @@ pub enum ConversationEvent {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, TS)]
-pub struct SessionCreatedEvent {
-    pub session_id: String,
+pub struct ThreadStartedEvent {
+    pub thread_id: String,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, TS, Default)]
@@ -35,6 +37,11 @@ pub struct TurnCompletedEvent {
     pub usage: Usage,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, TS)]
+pub struct TurnFailedEvent {
+    pub error: ConversationErrorEvent,
+}
+
 /// Minimal usage summary for a turn.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, TS, Default)]
 pub struct Usage {

codex-rs/exec/src/experimental_event_processor_with_json_output.rs

@@ -20,10 +20,11 @@ use crate::exec_events::ItemUpdatedEvent;
 use crate::exec_events::PatchApplyStatus;
 use crate::exec_events::PatchChangeKind;
 use crate::exec_events::ReasoningItem;
-use crate::exec_events::SessionCreatedEvent;
+use crate::exec_events::ThreadStartedEvent;
 use crate::exec_events::TodoItem;
 use crate::exec_events::TodoListItem;
 use crate::exec_events::TurnCompletedEvent;
+use crate::exec_events::TurnFailedEvent;
 use crate::exec_events::TurnStartedEvent;
 use crate::exec_events::Usage;
 use codex_core::config::Config;
@@ -53,6 +54,7 @@ pub struct ExperimentalEventProcessorWithJsonOutput {
     // Tracks the todo list for the current turn (at most one per turn).
     running_todo_list: Option<RunningTodoList>,
     last_total_token_usage: Option<codex_core::protocol::TokenUsage>,
+    last_critical_error: Option<ConversationErrorEvent>,
 }
 
 #[derive(Debug, Clone)]
@@ -76,6 +78,7 @@ impl ExperimentalEventProcessorWithJsonOutput {
             running_patch_applies: HashMap::new(),
             running_todo_list: None,
             last_total_token_usage: None,
+            last_critical_error: None,
         }
     }
 
@@ -96,9 +99,13 @@ impl ExperimentalEventProcessorWithJsonOutput {
             }
             EventMsg::TaskStarted(ev) => self.handle_task_started(ev),
             EventMsg::TaskComplete(_) => self.handle_task_complete(),
-            EventMsg::Error(ev) => vec![ConversationEvent::Error(ConversationErrorEvent {
-                message: ev.message.clone(),
-            })],
+            EventMsg::Error(ev) => {
+                let error = ConversationErrorEvent {
+                    message: ev.message.clone(),
+                };
+                self.last_critical_error = Some(error.clone());
+                vec![ConversationEvent::Error(error)]
+            }
             EventMsg::StreamError(ev) => vec![ConversationEvent::Error(ConversationErrorEvent {
                 message: ev.message.clone(),
             })],
@@ -119,8 +126,8 @@ impl ExperimentalEventProcessorWithJsonOutput {
         &self,
         payload: &SessionConfiguredEvent,
     ) -> Vec<ConversationEvent> {
-        vec![ConversationEvent::SessionCreated(SessionCreatedEvent {
-            session_id: payload.session_id.to_string(),
+        vec![ConversationEvent::ThreadStarted(ThreadStartedEvent {
+            thread_id: payload.session_id.to_string(),
         })]
     }
 
@@ -296,7 +303,8 @@ impl ExperimentalEventProcessorWithJsonOutput {
         vec![ConversationEvent::ItemStarted(ItemStartedEvent { item })]
     }
 
-    fn handle_task_started(&self, _: &TaskStartedEvent) -> Vec<ConversationEvent> {
+    fn handle_task_started(&mut self, _: &TaskStartedEvent) -> Vec<ConversationEvent> {
+        self.last_critical_error = None;
         vec![ConversationEvent::TurnStarted(TurnStartedEvent {})]
     }
 
@@ -325,9 +333,13 @@ impl ExperimentalEventProcessorWithJsonOutput {
             }));
         }
 
-        items.push(ConversationEvent::TurnCompleted(TurnCompletedEvent {
-            usage,
-        }));
+        if let Some(error) = self.last_critical_error.take() {
+            items.push(ConversationEvent::TurnFailed(TurnFailedEvent { error }));
+        } else {
+            items.push(ConversationEvent::TurnCompleted(TurnCompletedEvent {
+                usage,
+            }));
+        }
 
         items
     }