[router] support Openai router conversation API CRUD

sgl-router/src/data_connector/conversation_memory_store.rs

@@ -0,0 +1,57 @@
+use async_trait::async_trait;
+use parking_lot::RwLock;
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use super::conversations::{
+    Conversation, ConversationId, ConversationMetadata, ConversationStorage, NewConversation,
+    Result,
+};
+
+/// In-memory conversation storage used for development and tests
+#[derive(Default, Clone)]
+pub struct MemoryConversationStorage {
+    inner: Arc<RwLock<HashMap<ConversationId, Conversation>>>,
+}
+
+impl MemoryConversationStorage {
+    pub fn new() -> Self {
+        Self {
+            inner: Arc::new(RwLock::new(HashMap::new())),
+        }
+    }
+}
+
+#[async_trait]
+impl ConversationStorage for MemoryConversationStorage {
+    async fn create_conversation(&self, input: NewConversation) -> Result<Conversation> {
+        let conversation = Conversation::new(input);
+        self.inner
+            .write()
+            .insert(conversation.id.clone(), conversation.clone());
+        Ok(conversation)
+    }
+
+    async fn get_conversation(&self, id: &ConversationId) -> Result<Option<Conversation>> {
+        Ok(self.inner.read().get(id).cloned())
+    }
+
+    async fn update_conversation(
+        &self,
+        id: &ConversationId,
+        metadata: Option<ConversationMetadata>,
+    ) -> Result<Option<Conversation>> {
+        let mut store = self.inner.write();
+        if let Some(entry) = store.get_mut(id) {
+            entry.metadata = metadata;
+            return Ok(Some(entry.clone()));
+        }
+
+        Ok(None)
+    }
+
+    async fn delete_conversation(&self, id: &ConversationId) -> Result<bool> {
+        let removed = self.inner.write().remove(id).is_some();
+        Ok(removed)
+    }
+}

sgl-router/src/data_connector/conversation_noop_store.rs

@@ -0,0 +1,41 @@
+use async_trait::async_trait;
+
+use super::conversations::{
+    Conversation, ConversationId, ConversationMetadata, ConversationStorage, Result,
+};
+
+/// No-op implementation that synthesizes conversation responses without persistence
+#[derive(Default, Debug, Clone)]
+pub struct NoOpConversationStorage;
+
+impl NoOpConversationStorage {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+#[async_trait]
+impl ConversationStorage for NoOpConversationStorage {
+    async fn create_conversation(
+        &self,
+        input: super::conversations::NewConversation,
+    ) -> Result<Conversation> {
+        Ok(Conversation::new(input))
+    }
+
+    async fn get_conversation(&self, _id: &ConversationId) -> Result<Option<Conversation>> {
+        Ok(None)
+    }
+
+    async fn update_conversation(
+        &self,
+        _id: &ConversationId,
+        _metadata: Option<ConversationMetadata>,
+    ) -> Result<Option<Conversation>> {
+        Ok(None)
+    }
+
+    async fn delete_conversation(&self, _id: &ConversationId) -> Result<bool> {
+        Ok(false)
+    }
+}