Add conversation history handling to WebRTC and WebSocket services

src/services/_conversation_service.py

@@ -35,6 +35,26 @@ class ConversationService:
             return False
         return True
 
+    async def get_conversation_history(self, conversation_id, find_all=False, limit=20):
+        conversation_object: Conversation = (
+            await self.conversation_repository.get_by_id(conversation_id)
+        )
+        messages: list[Message] = (
+            await self.message_repository.get_messages_by_conversation(
+                conversation_object
+            )
+        )
+        if len(messages) == 0:
+            return {"conversation_history": ""}
+
+        if not find_all:
+            messages = messages[-limit:]
+
+        conversation_history = "\n".join(
+            [f"{message.role}: {message.content}" for message in messages]
+        )
+        return {"conversation_history": conversation_history}
+
     async def create_conversation(self, user_id, modality):
         user_object = await self.user_repository.get_by_id(user_id)
         conversation_object = await self.conversation_repository.insert_one(
@@ -71,15 +91,25 @@ class ConversationService:
             await websocket.close(code=1008, reason="Unsupported modality")
             raise Exception("Unsupported modality")
 
+        conversation_history = await self.get_conversation_history(
+            conversation_id, find_all=False, limit=20
+        )
+
         if modality == "voice":
             async with self.web_rtc_service() as rtc_service:
                 await rtc_service.handle_voice_conversion(
-                    websocket=websocket, conversation_id=conversation_id, user_id=user_id
+                    websocket=websocket,
+                    conversation_id=conversation_id,
+                    conversation_history=conversation_history,
+                    user_id=user_id,
                 )
         else:
             async with self.websocket_service() as ws_service:
                 await ws_service.handle_text_conversation_with_openai_websockets(
-                    client_websocket=websocket, conversation_id=conversation_id, user_id=user_id
+                    client_websocket=websocket,
+                    conversation_id=conversation_id,
+                    conversation_history=conversation_history,
+                    user_id=user_id,
                 )
 
     async def create_conversation_summary(self, user_id, conversation_id):
@@ -89,21 +119,23 @@ class ConversationService:
         conversation_object: Conversation = (
             await self.conversation_repository.get_by_id(conversation_id)
         )
-        messages: list[Message] = (
-            await self.message_repository.get_messages_by_conversation(
-                conversation_object
-            )
+        conversation_history = await self.get_conversation_history(
+            conversation_id, find_all=True
         )
 
-        conversation_history = "\n".join(
-            [f"{message.role}: {message.content}" for message in messages]
-        )
+        if conversation_history["conversation_history"] == "":
+            conversation_object.summary = ""
+            updated_converation: Conversation = (
+                await self.conversation_repository.update(
+                    conversation_object.id, conversation_object
+                )
+            )
+            return {"conversation_summary": updated_converation.summary}
 
         async with self.openai_client() as client:
             conversation_summary = await client.text_generation(
                 query=f"Generate Conversation Summary\n\n {conversation_history}"
             )
-
         conversation_object.summary = conversation_summary
         updated_converation: Conversation = await self.conversation_repository.update(
             conversation_object.id, conversation_object

src/services/_web_rtc_service.py

@@ -17,12 +17,15 @@ class WebRTCService:
     async def __aexit__(self, *args):
         pass
 
-    async def handle_voice_conversion(self, websocket, conversation_id, user_id):
+    async def handle_voice_conversion(
+        self, websocket, conversation_id, user_id, conversation_history
+    ):
         while True:
             data = await websocket.receive_text()
             message = json.loads(data)
 
             openai_server_events = {
+                "session_created": message["type"] == "session.created",
                 "function_call": (
                     message["type"] == "response.function_call_arguments.done"
                 ),
@@ -37,6 +40,24 @@ class WebRTCService:
                 ),
             }
 
+            if openai_server_events["session_created"]:
+                create_conversation_event = {
+                    "type": "conversation.item.create",
+                    "previous_item_id": None,
+                    "item": {
+                        "type": "message",
+                        "role": "user",
+                        "content": [
+                            {
+                                "type": "input_text",
+                                "text": f"Conversation History: {conversation_history}\n\n",
+                            }
+                        ],
+                    },
+                }
+                await websocket.send_text(json.dumps(create_conversation_event))
+                await websocket.send_text(json.dumps({"type": "response.create"}))
+
             if openai_server_events["function_call"]:
                 response = await self.bot_action_service.handle_ai_function_call(
                     data=message, user_id=user_id

src/services/_websocket_service.py

@@ -21,7 +21,7 @@ class WebSocketService:
         pass
 
     async def handle_text_conversation_with_openai_websockets(
-        self, client_websocket, conversation_id, user_id
+        self, client_websocket, conversation_id, user_id, conversation_history
     ):
         openai_websocket = None
         async with websockets.connect(
@@ -112,11 +112,18 @@ class WebSocketService:
 
             receiver_task = asyncio.create_task(openai_receiver())
 
+            conversation_history_sent = False
             while True:
                 user_message = await client_websocket.receive_text()
                 user_message = json.loads(user_message)["user_message"]
+
                 await self.bot_action_service.handle_user_message(
                     message_content=user_message,
                     conversation_id=conversation_id,
                 )
+
+                if not conversation_history_sent:
+                    user_message = f"{conversation_history}\n{user_message}"
+                    conversation_history_sent = True
+
                 await openai_sender(user_message)