feat: mem v2 - PR6 (consolidation) (#11374)

codex-rs/codex-api/src/endpoint/memories.rs

@@ -67,11 +67,22 @@ struct SummarizeResponse {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::common::RawMemory;
+    use crate::common::RawMemoryMetadata;
+    use crate::provider::RetryConfig;
     use async_trait::async_trait;
     use codex_client::Request;
     use codex_client::Response;
     use codex_client::StreamResponse;
     use codex_client::TransportError;
+    use http::HeaderMap;
+    use http::Method;
+    use http::StatusCode;
+    use pretty_assertions::assert_eq;
+    use serde_json::json;
+    use std::sync::Arc;
+    use std::sync::Mutex;
+    use std::time::Duration;
 
     #[derive(Clone, Default)]
     struct DummyTransport;
@@ -96,6 +107,54 @@ mod tests {
         }
     }
 
+    #[derive(Clone)]
+    struct CapturingTransport {
+        last_request: Arc<Mutex<Option<Request>>>,
+        response_body: Arc<Vec<u8>>,
+    }
+
+    impl CapturingTransport {
+        fn new(response_body: Vec<u8>) -> Self {
+            Self {
+                last_request: Arc::new(Mutex::new(None)),
+                response_body: Arc::new(response_body),
+            }
+        }
+    }
+
+    #[async_trait]
+    impl HttpTransport for CapturingTransport {
+        async fn execute(&self, req: Request) -> Result<Response, TransportError> {
+            *self.last_request.lock().expect("lock request store") = Some(req);
+            Ok(Response {
+                status: StatusCode::OK,
+                headers: HeaderMap::new(),
+                body: self.response_body.as_ref().clone().into(),
+            })
+        }
+
+        async fn stream(&self, _req: Request) -> Result<StreamResponse, TransportError> {
+            Err(TransportError::Build("stream should not run".to_string()))
+        }
+    }
+
+    fn provider(base_url: &str) -> Provider {
+        Provider {
+            name: "test".to_string(),
+            base_url: base_url.to_string(),
+            query_params: None,
+            headers: HeaderMap::new(),
+            retry: RetryConfig {
+                max_attempts: 1,
+                base_delay: Duration::from_millis(1),
+                retry_429: false,
+                retry_5xx: true,
+                retry_transport: true,
+            },
+            stream_idle_timeout: Duration::from_secs(1),
+        }
+    }
+
     #[test]
     fn path_is_memories_trace_summarize_for_wire_compatibility() {
         assert_eq!(
@@ -103,4 +162,63 @@ mod tests {
             "memories/trace_summarize"
         );
     }
+
+    #[tokio::test]
+    async fn summarize_input_posts_expected_payload_and_parses_output() {
+        let transport = CapturingTransport::new(
+            serde_json::to_vec(&json!({
+                "output": [
+                    {
+                        "trace_summary": "raw summary",
+                        "memory_summary": "memory summary"
+                    }
+                ]
+            }))
+            .expect("serialize response"),
+        );
+        let client = MemoriesClient::new(
+            transport.clone(),
+            provider("https://example.com/api/codex"),
+            DummyAuth,
+        );
+
+        let input = MemorySummarizeInput {
+            model: "gpt-test".to_string(),
+            raw_memories: vec![RawMemory {
+                id: "trace-1".to_string(),
+                metadata: RawMemoryMetadata {
+                    source_path: "/tmp/trace.json".to_string(),
+                },
+                items: vec![json!({"type": "message", "role": "user", "content": []})],
+            }],
+            reasoning: None,
+        };
+
+        let output = client
+            .summarize_input(&input, HeaderMap::new())
+            .await
+            .expect("summarize input request should succeed");
+        assert_eq!(output.len(), 1);
+        assert_eq!(output[0].raw_memory, "raw summary");
+        assert_eq!(output[0].memory_summary, "memory summary");
+
+        let request = transport
+            .last_request
+            .lock()
+            .expect("lock request store")
+            .clone()
+            .expect("request should be captured");
+        assert_eq!(request.method, Method::POST);
+        assert_eq!(
+            request.url,
+            "https://example.com/api/codex/memories/trace_summarize"
+        );
+        let body = request.body.expect("request body should be present");
+        assert_eq!(body["model"], "gpt-test");
+        assert_eq!(body["traces"][0]["id"], "trace-1");
+        assert_eq!(
+            body["traces"][0]["metadata"]["source_path"],
+            "/tmp/trace.json"
+        );
+    }
 }