feat: new op type for sub-agents communication (#15556)

Add `InterAgentCommunication` for v2 agent communication

codex-rs/core/src/agent/control.rs

@@ -1,6 +1,4 @@
 use crate::agent::AgentStatus;
-use crate::agent::inter_agent_instruction::InterAgentDelivery;
-use crate::agent::inter_agent_instruction::InterAgentInstruction;
 use crate::agent::registry::AgentMetadata;
 use crate::agent::registry::AgentRegistry;
 use crate::agent::role::DEFAULT_ROLE_NAME;
@@ -23,6 +21,7 @@ use codex_protocol::ThreadId;
 use codex_protocol::models::FunctionCallOutputPayload;
 use codex_protocol::models::ResponseItem;
 use codex_protocol::protocol::InitialHistory;
+use codex_protocol::protocol::InterAgentCommunication;
 use codex_protocol::protocol::Op;
 use codex_protocol::protocol::RolloutItem;
 use codex_protocol::protocol::SessionSource;
@@ -488,18 +487,17 @@ impl AgentControl {
         .await
     }
 
-    pub(crate) async fn deliver_inter_agent_instruction(
+    pub(crate) async fn send_inter_agent_communication(
         &self,
         agent_id: ThreadId,
-        instruction: InterAgentInstruction,
-        delivery: InterAgentDelivery,
+        communication: InterAgentCommunication,
     ) -> CodexResult<String> {
         let state = self.upgrade()?;
         self.handle_thread_request_result(
             agent_id,
             &state,
             state
-                .deliver_inter_agent_instruction(agent_id, instruction, delivery)
+                .send_op(agent_id, Op::InterAgentCommunication { communication })
                 .await,
         )
         .await

codex-rs/core/src/agent/inter_agent_instruction.rs

@@ -1,74 +0,0 @@
-use codex_protocol::AgentPath;
-use codex_protocol::models::ContentItem;
-use codex_protocol::models::ResponseItem;
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub(crate) enum InterAgentDelivery {
-    CurrentTurn,
-    NextTurn,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub(crate) struct InterAgentInstruction {
-    author: AgentPath,
-    recipient: AgentPath,
-    other_recipients: Vec<AgentPath>,
-    content: String,
-}
-
-impl InterAgentInstruction {
-    pub(crate) fn new(
-        author: AgentPath,
-        recipient: AgentPath,
-        other_recipients: Vec<AgentPath>,
-        content: String,
-    ) -> Self {
-        Self {
-            author,
-            recipient,
-            other_recipients,
-            content,
-        }
-    }
-
-    pub(crate) fn to_response_item(&self) -> ResponseItem {
-        ResponseItem::Message {
-            id: None,
-            role: "assistant".to_string(),
-            content: vec![ContentItem::OutputText {
-                text: self.as_text(),
-            }],
-            end_turn: None,
-            phase: None,
-        }
-    }
-
-    pub(crate) fn is_message_content(content: &[ContentItem]) -> bool {
-        content.iter().any(|content_item| match content_item {
-            ContentItem::InputText { text } | ContentItem::OutputText { text } => {
-                Self::is_instruction_text(text)
-            }
-            _ => false,
-        })
-    }
-
-    fn as_text(&self) -> String {
-        let other_recipients = self
-            .other_recipients
-            .iter()
-            .map(std::string::ToString::to_string)
-            .collect::<Vec<_>>()
-            .join(", ");
-        format!(
-            "author: {}\nrecipient: {}\nother_recipients: [{other_recipients}]\nContent: {}",
-            self.author, self.recipient, self.content
-        )
-    }
-
-    fn is_instruction_text(text: &str) -> bool {
-        text.starts_with("author: ")
-            && text.contains("\nrecipient: ")
-            && text.contains("\nother_recipients: [")
-            && text.contains("]\nContent: ")
-    }
-}

codex-rs/core/src/agent/mod.rs

@@ -1,6 +1,5 @@
 pub(crate) mod agent_resolver;
 pub(crate) mod control;
-pub(crate) mod inter_agent_instruction;
 mod registry;
 pub(crate) mod role;
 pub(crate) mod status;