:gem: [Feature] New API with stream reponse via POST request

apis/chat_api.py

@@ -1,7 +1,8 @@
+import json
 import uvicorn
 
-from fastapi import FastAPI, APIRouter, WebSocket, WebSocketDisconnect
-from fastapi.routing import APIRoute
+from fastapi import FastAPI
+from fastapi.responses import StreamingResponse
 from pydantic import BaseModel, Field
 from conversations import (
     ConversationConnector,
@@ -9,6 +10,8 @@ from conversations import (
     ConversationSession,
 )
 
+from networks import StreamResponseConstructor
+
 
 class ChatAPIApp:
     def __init__(self):
@@ -59,9 +62,9 @@ class ChatAPIApp:
         creator.create()
         return {
             "model": item.model,
-            "conversation_id": creator.conversation_id,
-            "client_id": creator.client_id,
             "sec_access_token": creator.sec_access_token,
+            "client_id": creator.client_id,
+            "conversation_id": creator.conversation_id,
         }
 
     class ChatPostItem(BaseModel):
@@ -105,6 +108,51 @@ class ChatAPIApp:
         with session:
             session.chat(prompt=item.prompt)
 
+    class ChatCompletionsPostItem(BaseModel):
+        model: str = Field(
+            default="precise",
+            description="(str) `precise`, `balanced`, `creative`, `precise-offline`, `balanced-offline`, `creative-offline`",
+        )
+        messages: list = Field(
+            default=[{"role": "user", "content": "Hello, who are you?"}],
+            description="(list) Messages",
+        )
+        sec_access_token: str = Field(
+            default="",
+            description="(str) Sec Access Token",
+        )
+        client_id: str = Field(
+            default="",
+            description="(str) Client ID",
+        )
+        conversation_id: str = Field(
+            default="",
+            description="(str) Conversation ID",
+        )
+        invocation_id: int = Field(
+            default=0,
+            description="(int) Invocation ID",
+        )
+
+    async def chat_completions(self, item: ChatCompletionsPostItem):
+        connector = ConversationConnector(
+            conversation_style=item.model,
+            sec_access_token=item.sec_access_token,
+            client_id=item.client_id,
+            conversation_id=item.conversation_id,
+            invocation_id=item.invocation_id,
+        )
+
+        if item.invocation_id == 0:
+            # TODO: History Messages Merger
+            prompt = item.messages[-1]["content"]
+        else:
+            prompt = item.messages[-1]["content"]
+
+        return StreamingResponse(
+            connector.stream_chat(prompt=prompt, yield_output=True)
+        )
+
     def setup_routes(self):
         self.app.get(
             "/models",
@@ -121,6 +169,11 @@ class ChatAPIApp:
             summary="Chat in conversation session",
         )(self.chat)
 
+        self.app.post(
+            "/chat/completions",
+            summary="Chat completions in conversation session",
+        )(self.chat_completions)
+
 
 app = ChatAPIApp().app
 

conversations/conversation_connector.py

@@ -8,7 +8,7 @@ from networks import (
     ChathubRequestPayloadConstructor,
     ConversationRequestHeadersConstructor,
 )
-from networks import MessageParser, IdleOutputer
+from networks import MessageParser, IdleOutputer, ContentJSONOutputer
 from utils.logger import logger
 
 http_proxy = "http://localhost:11111"  # Replace with yours
@@ -77,10 +77,10 @@ class ConversationConnector:
         self.connect_request_payload = payload_constructor.request_payload
         await self.wss_send(self.connect_request_payload)
 
-    async def stream_chat(self, prompt=""):
+    async def stream_chat(self, prompt="", yield_output=False):
         await self.connect()
         await self.send_chathub_request(prompt)
-        message_parser = MessageParser(outputer=IdleOutputer())
+        message_parser = MessageParser(outputer=ContentJSONOutputer())
         while not self.wss.closed:
             response_lines_str = await self.wss.receive_str()
             if isinstance(response_lines_str, str):
@@ -93,7 +93,10 @@ class ConversationConnector:
                 data = json.loads(line)
                 # Stream: Meaningful Messages
                 if data.get("type") == 1:
-                    message_parser.parse(data)
+                    if yield_output:
+                        yield message_parser.parse(data, return_output=True)
+                    else:
+                        message_parser.parse(data)
                 # Stream: List of all messages in the whole conversation
                 elif data.get("type") == 2:
                     if data.get("item"):
@@ -102,10 +105,21 @@ class ConversationConnector:
                         pass
                 # Stream: End of Conversation
                 elif data.get("type") == 3:
-                    logger.success("\n[Finished]")
+                    finished_str = "\n[Finished]"
+                    logger.success(finished_str)
                     self.invocation_id += 1
                     await self.wss.close()
                     await self.aiohttp_session.close()
+                    if yield_output:
+                        yield (
+                            json.dumps(
+                                {
+                                    "content": finished_str,
+                                    "content_type": "Finished",
+                                }
+                            )
+                            + "\n"
+                        ).encode("utf-8")
                     break
                 # Stream: Heartbeat Signal
                 elif data.get("type") == 6:

networks/__init__.py

@@ -3,5 +3,6 @@ from .cookies_constructor import CookiesConstructor
 from .conversation_request_headers_constructor import (
     ConversationRequestHeadersConstructor,
 )
-from .message_outputer import IdleOutputer
+from .message_outputer import IdleOutputer, ContentJSONOutputer
 from .message_parser import MessageParser
+from .stream_response_constructor import StreamResponseConstructor

networks/message_outputer.py

@@ -1,3 +1,19 @@
+import json
+
+
 class IdleOutputer:
-    def output(self, message_content=None, message_type=None):
-        pass
+    def output(self, content=None, content_type=None):
+        return json.dumps({}).encode("utf-8")
+
+
+class ContentJSONOutputer:
+    def output(self, content=None, content_type=None):
+        return (
+            json.dumps(
+                {
+                    "content": content,
+                    "content_type": content_type,
+                }
+            )
+            + "\n"
+        ).encode("utf-8")

networks/message_parser.py

@@ -1,13 +1,15 @@
+import json
+
 from utils.logger import logger
-from networks import IdleOutputer
+from networks import IdleOutputer, ContentJSONOutputer
 
 
 class MessageParser:
-    def __init__(self, outputer=IdleOutputer()):
+    def __init__(self, outputer=ContentJSONOutputer()):
         self.delta_content_pointer = 0
         self.outputer = outputer
 
-    def parse(self, data):
+    def parse(self, data, return_output=False):
         arguments = data["arguments"][0]
         if arguments.get("throttling"):
             throttling = arguments.get("throttling")
@@ -20,7 +22,6 @@ class MessageParser:
                     content = message["adaptiveCards"][0]["body"][0]["text"]
                     delta_content = content[self.delta_content_pointer :]
                     logger.line(delta_content, end="")
-                    self.outputer.output(delta_content, message_type="Completions")
                     self.delta_content_pointer = len(content)
                     # Message: Suggested Questions
                     if message.get("suggestedResponses"):
@@ -28,20 +29,34 @@ class MessageParser:
                         for suggestion in message.get("suggestedResponses"):
                             suggestion_text = suggestion.get("text")
                             logger.file(f"- {suggestion_text}")
-                        self.outputer.output(
-                            message.get("suggestedResponses"),
-                            message_type="Suggestions",
+                    if return_output:
+                        output_bytes = self.outputer.output(
+                            delta_content, content_type="Completions"
                         )
+                        if message.get("suggestedResponses"):
+                            output_bytes += self.outputer.output(
+                                message.get("suggestedResponses"),
+                                content_type="SuggestedResponses",
+                            )
+                        return output_bytes
+
                 # Message: Search Query
                 elif message_type in ["InternalSearchQuery"]:
                     message_hidden_text = message["hiddenText"]
-                    logger.note(f"\n[Searching: [{message_hidden_text}]]")
-                    self.outputer.output(
-                        message_hidden_text, message_type="InternalSearchQuery"
-                    )
+                    search_str = f"\n[Searching: [{message_hidden_text}]]"
+                    logger.note(search_str)
+                    if return_output:
+                        return self.outputer.output(
+                            search_str, content_type="InternalSearchQuery"
+                        )
                 # Message: Internal Search Results
                 elif message_type in ["InternalSearchResult"]:
-                    logger.note("[Analyzing search results ...]")
+                    analysis_str = f"\n[Analyzing search results ...]"
+                    logger.note(analysis_str)
+                    if return_output:
+                        return self.outputer.output(
+                            analysis_str, content_type="InternalSearchResult"
+                        )
                 # Message: Loader status, such as "Generating Answers"
                 elif message_type in ["InternalLoaderMessage"]:
                     # logger.note("[Generating answers ...]\n")
@@ -62,3 +77,15 @@ class MessageParser:
                     raise NotImplementedError(
                         f"Not Supported Message Type: {message_type}"
                     )
+
+        return (
+            (
+                json.dumps(
+                    {
+                        "content": "",
+                        "content_type": "NotImplemented",
+                    }
+                )
+            )
+            + "\n"
+        ).encode("utf-8")