mandate metadata_id and use constructor

codex-rs/protocol/src/models.rs

@@ -269,54 +269,24 @@ pub enum UserMessageType {
     PromptQueued,
 }
 
-#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq, JsonSchema, TS)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, JsonSchema, TS)]
 pub struct ResponseItemMessageMetadata {
     #[serde(default, skip_serializing_if = "Option::is_none")]
     #[ts(optional)]
     pub user_message_type: Option<UserMessageType>,
     /// Client-visible metadata ID generated by Codex for this item.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    #[ts(optional)]
-    pub metadata_id: Option<String>,
+    pub metadata_id: String,
 }
 
-impl ResponseItem {
-    /// Ensures message metadata includes a generated metadata ID.
-    pub fn with_generated_metadata_id(self) -> Self {
-        match self {
-            ResponseItem::Message {
-                id,
-                role,
-                content,
-                metadata,
-                end_turn,
-                phase,
-            } => {
-                let metadata = ensure_generated_metadata_id(metadata);
-                ResponseItem::Message {
-                    id,
-                    role,
-                    content,
-                    metadata,
-                    end_turn,
-                    phase,
-                }
-            }
-            other => other,
+impl ResponseItemMessageMetadata {
+    pub fn new(user_message_type: Option<UserMessageType>) -> Self {
+        Self {
+            user_message_type,
+            metadata_id: uuid::Uuid::new_v4().to_string(),
         }
     }
 }
 
-fn ensure_generated_metadata_id(
-    metadata: Option<ResponseItemMessageMetadata>,
-) -> Option<ResponseItemMessageMetadata> {
-    let mut metadata = metadata.unwrap_or_default();
-    if metadata.metadata_id.is_none() {
-        metadata.metadata_id = Some(uuid::Uuid::new_v4().to_string());
-    }
-    Some(metadata)
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, JsonSchema, TS)]
 #[serde(tag = "type", rename_all = "snake_case")]
 pub enum ContentItem {
@@ -3020,49 +2990,29 @@ mod tests {
     }
 
     #[test]
-    fn generates_metadata_id_for_message_items() -> Result<()> {
-        let item = ResponseItem::Message {
-            id: Some("msg_123".to_string()),
-            role: "assistant".to_string(),
-            content: vec![ContentItem::OutputText {
-                text: "hello".to_string(),
-            }],
-            metadata: Some(ResponseItemMessageMetadata {
-                user_message_type: Some(UserMessageType::Prompt),
-                metadata_id: None,
-            }),
-            end_turn: None,
-            phase: None,
-        };
-
-        let surfaced = item.with_generated_metadata_id();
-        let serialized = serde_json::to_value(&surfaced)?;
-        let metadata = serialized
-            .get("metadata")
-            .and_then(serde_json::Value::as_object)
-            .expect("metadata should be present");
+    fn response_item_message_metadata_serializes_required_metadata_id() -> Result<()> {
+        let metadata = ResponseItemMessageMetadata::new(Some(UserMessageType::Prompt));
+        let serialized = serde_json::to_value(&metadata)?;
+        let metadata = serialized.as_object().expect("metadata should be present");
         let metadata_id = metadata
             .get("metadata_id")
             .and_then(serde_json::Value::as_str)
             .expect("metadata_id should be present");
 
         uuid::Uuid::parse_str(metadata_id).expect("metadata_id should be valid");
-
-        assert_eq!(serialized.get("type"), Some(&serde_json::json!("message")));
-        assert_eq!(
-            serialized.get("role"),
-            Some(&serde_json::json!("assistant"))
-        );
-        assert_eq!(
-            serialized.get("content"),
-            Some(&serde_json::json!([{ "type": "output_text", "text": "hello" }]))
-        );
         assert_eq!(
             metadata.get("user_message_type"),
             Some(&serde_json::json!("prompt"))
         );
-        assert_ne!(metadata_id, "msg_123");
 
         Ok(())
     }
+
+    #[test]
+    fn response_item_message_metadata_new_generates_metadata_id() {
+        let metadata = ResponseItemMessageMetadata::new(Some(UserMessageType::Prompt));
+
+        assert_eq!(metadata.user_message_type, Some(UserMessageType::Prompt));
+        uuid::Uuid::parse_str(&metadata.metadata_id).expect("metadata_id should be valid");
+    }
 }