[App-server] add new v2 events:item/reasoning/delta, item/agentMessage/delta & item/reasoning/summaryPartAdded (#6559)

celia-oai · web-flow · commit b8ec97c0ef37 · 2025-11-14T00:25:01.000Z
core event to app server event mapping:
1. `codex/event/reasoning_content_delta` -&gt;
`item/reasoning/summaryTextDelta`.
2. `codex/event/reasoning_raw_content_delta` -&gt;
`item/reasoning/textDelta`
3. `codex/event/agent_message_content_delta` →
`item/agentMessage/delta`.
4. `codex/event/agent_reasoning_section_break` -&gt;
`item/reasoning/summaryPartAdded`.

Also added a change in core to pass down content index, summary index
and item id from events.

Tested with the `git checkout owen/app_server_test_client &amp;&amp; cargo run
-p codex-app-server-test-client -- send-message-v2 "hello"` and verified
that new events are emitted correctly.
diff --git a/codex-rs/app-server-protocol/src/protocol/common.rs b/codex-rs/app-server-protocol/src/protocol/common.rs
@@ -508,6 +508,9 @@ server_notification_definitions! {
     McpToolCallProgress => "item/mcpToolCall/progress" (v2::McpToolCallProgressNotification),
     AccountUpdated => "account/updated" (v2::AccountUpdatedNotification),
     AccountRateLimitsUpdated => "account/rateLimits/updated" (v2::AccountRateLimitsUpdatedNotification),
+    ReasoningSummaryTextDelta => "item/reasoning/summaryTextDelta" (v2::ReasoningSummaryTextDeltaNotification),
+    ReasoningSummaryPartAdded => "item/reasoning/summaryPartAdded" (v2::ReasoningSummaryPartAddedNotification),
+    ReasoningTextDelta => "item/reasoning/textDelta" (v2::ReasoningTextDeltaNotification),
 
     #[serde(rename = "account/login/completed")]
     #[ts(rename = "account/login/completed")]
diff --git a/codex-rs/app-server-protocol/src/protocol/v2.rs b/codex-rs/app-server-protocol/src/protocol/v2.rs
@@ -516,7 +516,10 @@ pub enum ThreadItem {
     },
     Reasoning {
         id: String,
-        text: String,
+        #[serde(default)]
+        summary: Vec<String>,
+        #[serde(default)]
+        content: Vec<String>,
     },
     CommandExecution {
         id: String,
@@ -575,17 +578,11 @@ impl From<CoreTurnItem> for ThreadItem {
                     .collect::<String>();
                 ThreadItem::AgentMessage { id: agent.id, text }
             }
-            CoreTurnItem::Reasoning(reasoning) => {
-                let text = if !reasoning.summary_text.is_empty() {
-                    reasoning.summary_text.join("\n")
-                } else {
-                    reasoning.raw_content.join("\n")
-                };
-                ThreadItem::Reasoning {
-                    id: reasoning.id,
-                    text,
-                }
-            }
+            CoreTurnItem::Reasoning(reasoning) => ThreadItem::Reasoning {
+                id: reasoning.id,
+                summary: reasoning.summary_text,
+                content: reasoning.raw_content,
+            },
             CoreTurnItem::WebSearch(search) => ThreadItem::WebSearch {
                 id: search.id,
                 query: search.query,
@@ -719,6 +716,32 @@ pub struct AgentMessageDeltaNotification {
     pub delta: String,
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export_to = "v2/")]
+pub struct ReasoningSummaryTextDeltaNotification {
+    pub item_id: String,
+    pub delta: String,
+    pub summary_index: i64,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export_to = "v2/")]
+pub struct ReasoningSummaryPartAddedNotification {
+    pub item_id: String,
+    pub summary_index: i64,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export_to = "v2/")]
+pub struct ReasoningTextDeltaNotification {
+    pub item_id: String,
+    pub delta: String,
+    pub content_index: i64,
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export_to = "v2/")]
@@ -867,7 +890,8 @@ mod tests {
             ThreadItem::from(reasoning_item),
             ThreadItem::Reasoning {
                 id: "reasoning-1".to_string(),
-                text: "line one\nline two".to_string(),
+                summary: vec!["line one".to_string(), "line two".to_string()],
+                content: vec![],
             }
         );
 
diff --git a/codex-rs/app-server/src/codex_message_processor.rs b/codex-rs/app-server/src/codex_message_processor.rs
@@ -12,6 +12,7 @@ use codex_app_server_protocol::AccountRateLimitsUpdatedNotification;
 use codex_app_server_protocol::AccountUpdatedNotification;
 use codex_app_server_protocol::AddConversationListenerParams;
 use codex_app_server_protocol::AddConversationSubscriptionResponse;
+use codex_app_server_protocol::AgentMessageDeltaNotification;
 use codex_app_server_protocol::ApplyPatchApprovalParams;
 use codex_app_server_protocol::ApplyPatchApprovalResponse;
 use codex_app_server_protocol::ArchiveConversationParams;
@@ -62,6 +63,9 @@ use codex_app_server_protocol::ModelListParams;
 use codex_app_server_protocol::ModelListResponse;
 use codex_app_server_protocol::NewConversationParams;
 use codex_app_server_protocol::NewConversationResponse;
+use codex_app_server_protocol::ReasoningSummaryPartAddedNotification;
+use codex_app_server_protocol::ReasoningSummaryTextDeltaNotification;
+use codex_app_server_protocol::ReasoningTextDeltaNotification;
 use codex_app_server_protocol::RemoveConversationListenerParams;
 use codex_app_server_protocol::RemoveConversationSubscriptionResponse;
 use codex_app_server_protocol::RequestId;
@@ -2681,6 +2685,48 @@ async fn apply_bespoke_event_handling(
                 on_patch_approval_response(event_id, rx, conversation).await;
             });
         }
+        EventMsg::AgentMessageContentDelta(event) => {
+            let notification = AgentMessageDeltaNotification {
+                item_id: event.item_id,
+                delta: event.delta,
+            };
+            outgoing
+                .send_server_notification(ServerNotification::AgentMessageDelta(notification))
+                .await;
+        }
+        EventMsg::ReasoningContentDelta(event) => {
+            let notification = ReasoningSummaryTextDeltaNotification {
+                item_id: event.item_id,
+                delta: event.delta,
+                summary_index: event.summary_index,
+            };
+            outgoing
+                .send_server_notification(ServerNotification::ReasoningSummaryTextDelta(
+                    notification,
+                ))
+                .await;
+        }
+        EventMsg::ReasoningRawContentDelta(event) => {
+            let notification = ReasoningTextDeltaNotification {
+                item_id: event.item_id,
+                delta: event.delta,
+                content_index: event.content_index,
+            };
+            outgoing
+                .send_server_notification(ServerNotification::ReasoningTextDelta(notification))
+                .await;
+        }
+        EventMsg::AgentReasoningSectionBreak(event) => {
+            let notification = ReasoningSummaryPartAddedNotification {
+                item_id: event.item_id,
+                summary_index: event.summary_index,
+            };
+            outgoing
+                .send_server_notification(ServerNotification::ReasoningSummaryPartAdded(
+                    notification,
+                ))
+                .await;
+        }
         EventMsg::ExecApprovalRequest(ExecApprovalRequestEvent {
             call_id,
             command,
diff --git a/codex-rs/core/src/chat_completions.rs b/codex-rs/core/src/chat_completions.rs
@@ -477,10 +477,14 @@ async fn append_reasoning_text(
         ..
     }) = reasoning_item
     {
+        let content_index = content.len() as i64;
         content.push(ReasoningItemContent::ReasoningText { text: text.clone() });
 
         let _ = tx_event
-            .send(Ok(ResponseEvent::ReasoningContentDelta(text.clone())))
+            .send(Ok(ResponseEvent::ReasoningContentDelta {
+                delta: text.clone(),
+                content_index,
+            }))
             .await;
     }
 }
@@ -898,20 +902,26 @@ where
                         continue;
                     }
                 }
-                Poll::Ready(Some(Ok(ResponseEvent::ReasoningContentDelta(delta)))) => {
+                Poll::Ready(Some(Ok(ResponseEvent::ReasoningContentDelta {
+                    delta,
+                    content_index,
+                }))) => {
                     // Always accumulate reasoning deltas so we can emit a final Reasoning item at Completed.
                     this.cumulative_reasoning.push_str(&delta);
                     if matches!(this.mode, AggregateMode::Streaming) {
                         // In streaming mode, also forward the delta immediately.
-                        return Poll::Ready(Some(Ok(ResponseEvent::ReasoningContentDelta(delta))));
+                        return Poll::Ready(Some(Ok(ResponseEvent::ReasoningContentDelta {
+                            delta,
+                            content_index,
+                        })));
                     } else {
                         continue;
                     }
                 }
-                Poll::Ready(Some(Ok(ResponseEvent::ReasoningSummaryDelta(_)))) => {
+                Poll::Ready(Some(Ok(ResponseEvent::ReasoningSummaryDelta { .. }))) => {
                     continue;
                 }
-                Poll::Ready(Some(Ok(ResponseEvent::ReasoningSummaryPartAdded))) => {
+                Poll::Ready(Some(Ok(ResponseEvent::ReasoningSummaryPartAdded { .. }))) => {
                     continue;
                 }
                 Poll::Ready(Some(Ok(ResponseEvent::OutputItemAdded(item)))) => {
diff --git a/codex-rs/core/src/client.rs b/codex-rs/core/src/client.rs
@@ -560,6 +560,8 @@ struct SseEvent {
     response: Option<Value>,
     item: Option<Value>,
     delta: Option<String>,
+    summary_index: Option<i64>,
+    content_index: Option<i64>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -819,16 +821,22 @@ async fn process_sse<S>(
                 }
             }
             "response.reasoning_summary_text.delta" => {
-                if let Some(delta) = event.delta {
-                    let event = ResponseEvent::ReasoningSummaryDelta(delta);
+                if let (Some(delta), Some(summary_index)) = (event.delta, event.summary_index) {
+                    let event = ResponseEvent::ReasoningSummaryDelta {
+                        delta,
+                        summary_index,
+                    };
                     if tx_event.send(Ok(event)).await.is_err() {
                         return;
                     }
                 }
             }
             "response.reasoning_text.delta" => {
-                if let Some(delta) = event.delta {
-                    let event = ResponseEvent::ReasoningContentDelta(delta);
+                if let (Some(delta), Some(content_index)) = (event.delta, event.content_index) {
+                    let event = ResponseEvent::ReasoningContentDelta {
+                        delta,
+                        content_index,
+                    };
                     if tx_event.send(Ok(event)).await.is_err() {
                         return;
                     }
@@ -905,10 +913,12 @@ async fn process_sse<S>(
                 }
             }
             "response.reasoning_summary_part.added" => {
-                // Boundary between reasoning summary sections (e.g., titles).
-                let event = ResponseEvent::ReasoningSummaryPartAdded;
-                if tx_event.send(Ok(event)).await.is_err() {
-                    return;
+                if let Some(summary_index) = event.summary_index {
+                    // Boundary between reasoning summary sections (e.g., titles).
+                    let event = ResponseEvent::ReasoningSummaryPartAdded { summary_index };
+                    if tx_event.send(Ok(event)).await.is_err() {
+                        return;
+                    }
                 }
             }
             "response.reasoning_summary_text.done" => {}
diff --git a/codex-rs/core/src/client_common.rs b/codex-rs/core/src/client_common.rs
@@ -203,9 +203,17 @@ pub enum ResponseEvent {
         token_usage: Option<TokenUsage>,
     },
     OutputTextDelta(String),
-    ReasoningSummaryDelta(String),
-    ReasoningContentDelta(String),
-    ReasoningSummaryPartAdded,
+    ReasoningSummaryDelta {
+        delta: String,
+        summary_index: i64,
+    },
+    ReasoningContentDelta {
+        delta: String,
+        content_index: i64,
+    },
+    ReasoningSummaryPartAdded {
+        summary_index: i64,
+    },
     RateLimits(RateLimitSnapshot),
 }
 
diff --git a/codex-rs/core/src/codex.rs b/codex-rs/core/src/codex.rs
@@ -2232,32 +2232,47 @@ async fn try_run_turn(
                     error_or_panic("ReasoningSummaryDelta without active item".to_string());
                 }
             }
-            ResponseEvent::ReasoningSummaryDelta(delta) => {
+            ResponseEvent::ReasoningSummaryDelta {
+                delta,
+                summary_index,
+            } => {
                 if let Some(active) = active_item.as_ref() {
                     let event = ReasoningContentDeltaEvent {
                         thread_id: sess.conversation_id.to_string(),
                         turn_id: turn_context.sub_id.clone(),
                         item_id: active.id(),
-                        delta: delta.clone(),
+                        delta,
+                        summary_index,
                     };
                     sess.send_event(&turn_context, EventMsg::ReasoningContentDelta(event))
                         .await;
                 } else {
                     error_or_panic("ReasoningSummaryDelta without active item".to_string());
                 }
             }
-            ResponseEvent::ReasoningSummaryPartAdded => {
-                let event =
-                    EventMsg::AgentReasoningSectionBreak(AgentReasoningSectionBreakEvent {});
-                sess.send_event(&turn_context, event).await;
+            ResponseEvent::ReasoningSummaryPartAdded { summary_index } => {
+                if let Some(active) = active_item.as_ref() {
+                    let event =
+                        EventMsg::AgentReasoningSectionBreak(AgentReasoningSectionBreakEvent {
+                            item_id: active.id(),
+                            summary_index,
+                        });
+                    sess.send_event(&turn_context, event).await;
+                } else {
+                    error_or_panic("ReasoningSummaryPartAdded without active item".to_string());
+                }
             }
-            ResponseEvent::ReasoningContentDelta(delta) => {
+            ResponseEvent::ReasoningContentDelta {
+                delta,
+                content_index,
+            } => {
                 if let Some(active) = active_item.as_ref() {
                     let event = ReasoningRawContentDeltaEvent {
                         thread_id: sess.conversation_id.to_string(),
                         turn_id: turn_context.sub_id.clone(),
                         item_id: active.id(),
-                        delta: delta.clone(),
+                        delta,
+                        content_index,
                     };
                     sess.send_event(&turn_context, EventMsg::ReasoningRawContentDelta(event))
                         .await;
diff --git a/codex-rs/core/tests/chat_completions_sse.rs b/codex-rs/core/tests/chat_completions_sse.rs
diff --git a/codex-rs/core/tests/common/responses.rs b/codex-rs/core/tests/common/responses.rs
diff --git a/codex-rs/protocol/src/protocol.rs b/codex-rs/protocol/src/protocol.rs

Original file line number	Diff line number	Diff line change
`@@ -477,10 +477,14 @@ async fn append_reasoning_text(`
`477`	`477`	`..`
`478`	`478`	`}) = reasoning_item`
`479`	`479`	`{`
	`480`	`+ let content_index = content.len() as i64;`
`480`	`481`	`content.push(ReasoningItemContent::ReasoningText { text: text.clone() });`
`481`	`482`
`482`	`483`	`let _ = tx_event`
`483`		`- .send(Ok(ResponseEvent::ReasoningContentDelta(text.clone())))`
	`484`	`+ .send(Ok(ResponseEvent::ReasoningContentDelta {`
	`485`	`+ delta: text.clone(),`
	`486`	`+ content_index,`
	`487`	`+ }))`
`484`	`488`	`.await;`
`485`	`489`	`}`
`486`	`490`	`}`
`@@ -898,20 +902,26 @@ where`
`898`	`902`	`continue;`
`899`	`903`	`}`
`900`	`904`	`}`
`901`		`- Poll::Ready(Some(Ok(ResponseEvent::ReasoningContentDelta(delta)))) => {`
	`905`	`+ Poll::Ready(Some(Ok(ResponseEvent::ReasoningContentDelta {`
	`906`	`+ delta,`
	`907`	`+ content_index,`
	`908`	`+ }))) => {`
`902`	`909`	`// Always accumulate reasoning deltas so we can emit a final Reasoning item at Completed.`
`903`	`910`	`this.cumulative_reasoning.push_str(&delta);`
`904`	`911`	`if matches!(this.mode, AggregateMode::Streaming) {`
`905`	`912`	`// In streaming mode, also forward the delta immediately.`
`906`		`- return Poll::Ready(Some(Ok(ResponseEvent::ReasoningContentDelta(delta))));`
	`913`	`+ return Poll::Ready(Some(Ok(ResponseEvent::ReasoningContentDelta {`
	`914`	`+ delta,`
	`915`	`+ content_index,`
	`916`	`+ })));`
`907`	`917`	`} else {`
`908`	`918`	`continue;`
`909`	`919`	`}`
`910`	`920`	`}`
`911`		`- Poll::Ready(Some(Ok(ResponseEvent::ReasoningSummaryDelta(_)))) => {`
	`921`	`+ Poll::Ready(Some(Ok(ResponseEvent::ReasoningSummaryDelta { .. }))) => {`
`912`	`922`	`continue;`
`913`	`923`	`}`
`914`		`- Poll::Ready(Some(Ok(ResponseEvent::ReasoningSummaryPartAdded))) => {`
	`924`	`+ Poll::Ready(Some(Ok(ResponseEvent::ReasoningSummaryPartAdded { .. }))) => {`
`915`	`925`	`continue;`
`916`	`926`	`}`
`917`	`927`	`Poll::Ready(Some(Ok(ResponseEvent::OutputItemAdded(item)))) => {`
Original file line number	Diff line number	Diff line change
`@@ -560,6 +560,8 @@ struct SseEvent {`
`560`	`560`	`response: Option<Value>,`
`561`	`561`	`item: Option<Value>,`
`562`	`562`	`delta: Option<String>,`
	`563`	`+ summary_index: Option<i64>,`
	`564`	`+ content_index: Option<i64>,`
`563`	`565`	`}`
`564`	`566`
`565`	`567`	`#[derive(Debug, Deserialize)]`
`@@ -819,16 +821,22 @@ async fn process_sse<S>(`
`819`	`821`	`}`
`820`	`822`	`}`
`821`	`823`	`"response.reasoning_summary_text.delta" => {`
`822`		`- if let Some(delta) = event.delta {`
`823`		`- let event = ResponseEvent::ReasoningSummaryDelta(delta);`
	`824`	`+ if let (Some(delta), Some(summary_index)) = (event.delta, event.summary_index) {`
	`825`	`+ let event = ResponseEvent::ReasoningSummaryDelta {`
	`826`	`+ delta,`
	`827`	`+ summary_index,`
	`828`	`+ };`
`824`	`829`	`if tx_event.send(Ok(event)).await.is_err() {`
`825`	`830`	`return;`
`826`	`831`	`}`
`827`	`832`	`}`
`828`	`833`	`}`
`829`	`834`	`"response.reasoning_text.delta" => {`
`830`		`- if let Some(delta) = event.delta {`
`831`		`- let event = ResponseEvent::ReasoningContentDelta(delta);`
	`835`	`+ if let (Some(delta), Some(content_index)) = (event.delta, event.content_index) {`
	`836`	`+ let event = ResponseEvent::ReasoningContentDelta {`
	`837`	`+ delta,`
	`838`	`+ content_index,`
	`839`	`+ };`
`832`	`840`	`if tx_event.send(Ok(event)).await.is_err() {`
`833`	`841`	`return;`
`834`	`842`	`}`
`@@ -905,10 +913,12 @@ async fn process_sse<S>(`
`905`	`913`	`}`
`906`	`914`	`}`
`907`	`915`	`"response.reasoning_summary_part.added" => {`
`908`		`- // Boundary between reasoning summary sections (e.g., titles).`
`909`		`- let event = ResponseEvent::ReasoningSummaryPartAdded;`
`910`		`- if tx_event.send(Ok(event)).await.is_err() {`
`911`		`- return;`
	`916`	`+ if let Some(summary_index) = event.summary_index {`
	`917`	`+ // Boundary between reasoning summary sections (e.g., titles).`
	`918`	`+ let event = ResponseEvent::ReasoningSummaryPartAdded { summary_index };`
	`919`	`+ if tx_event.send(Ok(event)).await.is_err() {`
	`920`	`+ return;`
	`921`	`+ }`
`912`	`922`	`}`
`913`	`923`	`}`
`914`	`924`	`"response.reasoning_summary_text.done" => {}`