feat: initial conversation api implementation

app/api/chat_api.py

@@ -9,7 +9,7 @@ from app.schema.chat_schema import (
     MessageResponse,
     PlotResponse,
 )
-from app.schema.conversation import (
+from app.schema.conversation_schema import (
     ConversationResponse,
     ConversationItemResponse,
 )
@@ -57,7 +57,7 @@ async def create_chat_completion(
 
 
 # get all chat completions
-@router.get("/chat/completions", response_model=List[ChatCompletionResponse])
+@router.get("/chat/completions", response_model=List[ChatCompletionResponse], deprecated=True)
 async def list_chat_completions(
     request: Request,
     username: str = Depends(auth_service.verify_credentials),
@@ -80,10 +80,7 @@ async def list_chat_completions(
 
 
 # get a chat completion by id
-@router.get(
-    "/chat/completions/{completion_id}",
-    response_model=ChatCompletionResponse,
-)
+@router.get("/chat/completions/{completion_id}", response_model=ChatCompletionResponse)
 @api_response()
 async def retrieve_chat_completion(
     completion_id: str,
@@ -101,10 +98,7 @@ async def retrieve_chat_completion(
 
 
 # get all messages for a chat completion
-@router.get(
-    "/chat/completions/{completion_id}/messages",
-    response_model=List[MessageResponse],
-)
+@router.get("/chat/completions/{completion_id}/messages", response_model=List[MessageResponse], deprecated=True)
 @api_response()
 async def list_messages(
     completion_id: str,
@@ -125,10 +119,7 @@ async def list_messages(
 # plot api list
 ################
 # get a plot for a message
-@router.get(
-    "/chat/completions/{completion_id}/messages/{message_id}/plot",
-    response_model=PlotResponse,
-)
+@router.get("/chat/completions/{completion_id}/messages/{message_id}/plot", response_model=PlotResponse)
 @api_response()
 async def retrieve_plot(
     completion_id: str,
@@ -154,8 +145,7 @@ async def retrieve_plot(
 
 
 # get all conversations
-@router.get("/conversations", response_model=ConversationResponse)
-@api_response()
+@router.get("/conversations", response_model=ConversationResponse, response_model_exclude_none=True) 
 async def list_conversations(
     request: Request,
     username: str = Depends(auth_service.verify_credentials),
@@ -165,8 +155,7 @@ async def list_conversations(
     """
     logger.debug(f"Listing conversations for username: {username}")
     try:
-        # return await service.find_all_conversations(username)
-        return {"items": [], "total": 0, "limit": 10, "offset": 0}
+        return await service.find_all_conversations(username) 
     except Exception as e:
         logger.error(f"Error in list_conversations: {str(e)}")
         raise HTTPException(status_code=500, detail=str(e))
@@ -175,11 +164,7 @@ async def list_conversations(
 # get a conversation by id
 
 
-@router.get(
-    "/conversations/{completion_id}",
-    response_model=ConversationItemResponse,
-)
-@api_response()
+@router.get("/conversations/{completion_id}", response_model=ConversationItemResponse, response_model_exclude_none=True)
 async def retrieve_conversation(
     completion_id: str,
     request: Request,

app/mapper/conversation_mapper.py

@@ -0,0 +1,33 @@
+# ChatCompletion to ConversationItem
+
+from app.mapper.base_mapper import BaseMapper
+from app.model.chat_model import ChatCompletion
+from app.schema.conversation_schema import ConversationItemResponse
+
+
+class ConversationMapper(BaseMapper[ChatCompletion, ConversationItemResponse]):
+    """Mapper for converting between ChatCompletion model and ConversationItem schema."""
+
+    def to_schema(self, model: ChatCompletion) -> ConversationItemResponse:
+        """Convert ChatCompletion model to ConversationItem schema."""
+        # Convert datetime to Unix timestamp
+        created_timestamp = int(model.created_date.timestamp()) if model.created_date else None
+        last_updated_timestamp = int(model.last_updated_date.timestamp()) if model.last_updated_date else None
+
+        # Get the first message content as title if title is not set
+        title = model.title
+        if not title and model.messages:
+            first_message = model.messages[0]
+            title = first_message.content[:20] + "..." if len(first_message.content) > 20 else first_message.content
+
+        return ConversationItemResponse(
+            completion_id=model.completion_id,
+            title=title,
+            create_time=created_timestamp,
+            update_time=last_updated_timestamp,
+            is_archived=model.is_archived,
+            is_starred=model.is_starred,
+        )
+
+    def to_model(self, schema: ConversationItemResponse) -> ChatCompletion:
+        raise NotImplementedError("ConversationMapper.to_model is not implemented")

app/schema/{conversation.py → conversation_schema.py}

@@ -37,7 +37,10 @@ class ConversationItemResponse(BaseModel):
         default=None,
         description="Indicates whether the conversation is excluded from memory or history, if set.",
     )
-    memory_scope: str = Field(description="Scope of the conversation's memory, e.g., 'global_enabled' for global memory access.")
+    memory_scope: Optional[str] = Field(
+        default=None,
+        description="Scope of the conversation's memory, e.g., 'global_enabled' for global memory access.",
+    )
     workspace_id: Optional[str] = Field(
         default=None,
         description="Identifier for the workspace the conversation belongs to, if applicable.",
@@ -46,8 +49,14 @@ class ConversationItemResponse(BaseModel):
         default=None,
         description="Status of any asynchronous operations related to the conversation, if applicable.",
     )
-    safe_urls: List[str] = Field(description="List of URLs deemed safe for the conversation context.")
-    blocked_urls: List[str] = Field(description="List of URLs blocked for the conversation context.")
+    safe_urls: Optional[List[str]] = Field(
+        default=None,
+        description="List of URLs deemed safe for the conversation context.",
+    )
+    blocked_urls: Optional[List[str]] = Field(
+        default=None,
+        description="List of URLs blocked for the conversation context.",
+    )
     conversation_origin: Optional[str] = Field(
         default=None,
         description="Origin or source of the conversation, if specified.",

app/service/chat_service.py

@@ -9,19 +9,21 @@ from app.schema.chat_schema import (
 )
 from app.model.chat_model import ChatCompletion, ChatMessage
 from app.mapper.chat_mapper import ChatMapper
+from app.mapper.conversation_mapper import ConversationMapper
 import uuid
 from loguru import logger
-from app.schema.conversation import ConversationResponse
+from app.schema.conversation_schema import ConversationResponse
 
 
 class ChatService:
     def __init__(self):
         self.chat_repository = ChatRepository()
         self.chat_mapper = ChatMapper()
+        self.conversation_mapper = ConversationMapper()
 
     async def handle_chat_completion(self, request: ChatCompletionRequest) -> ChatCompletionResponse:
         last_user_message = request.messages[-1].content
-        response_content = f"TODO implement ai-agent response for this message: {last_user_message}"
+        logger.debug(f"TODO implement ai-agent response for this message: {last_user_message}")
         username = "admin"
 
         # Convert request to model
@@ -55,7 +57,18 @@ class ChatService:
 
     # conversation service
     async def find_all_conversations(self, username: str) -> List[ConversationResponse]:
-        raise NotImplementedError("Not implemented")
+        """Find all conversations for a given username."""
+        query = {"created_by": username}
+        sort = {"last_updated_date": -1}  # Sort by last updated date in descending order
+
+        entities = await self.chat_repository.find(query, page=1, limit=100, sort=sort)
+        result = self.conversation_mapper.to_schema_list(entities)
+        return ConversationResponse(items=result, total=len(result), limit=100, offset=0)
+
+
 
     async def find_conversation_by_id(self, completion_id: str) -> ConversationResponse:
-        raise NotImplementedError("Not implemented")
+        """Find a conversation by its completion ID."""
+        entity = await self.chat_repository.find_by_id(completion_id)
+        result = self.conversation_mapper.to_schema(entity) if entity else None
+        return ConversationResponse(items=[result], total=1, limit=1, offset=0)