:gem: [Feature] Support openai streaming response format

apis/chat_api.py

@@ -150,7 +150,8 @@ class ChatAPIApp:
             prompt = item.messages[-1]["content"]
 
         return StreamingResponse(
-            connector.stream_chat(prompt=prompt, yield_output=True)
+            connector.stream_chat(prompt=prompt, yield_output=True),
+            media_type="text/plain",
         )
 
     def setup_routes(self):

conversations/conversation_connector.py

@@ -81,6 +81,10 @@ class ConversationConnector:
         await self.connect()
         await self.send_chathub_request(prompt)
         message_parser = MessageParser(outputer=OpenaiStreamOutputer())
+        has_output_role_message = False
+        if yield_output and not has_output_role_message:
+            has_output_role_message = True
+            yield message_parser.outputer.output(content="", content_type="Role")
         while not self.wss.closed:
             response_lines_str = await self.wss.receive_str()
             if isinstance(response_lines_str, str):

networks/message_outputer.py

@@ -2,13 +2,62 @@ import json
 
 
 class OpenaiStreamOutputer:
+    """
+    Create chat completion - OpenAI API Documentation
+    * https://platform.openai.com/docs/api-reference/chat/create
+    """
+
+    def data_to_string(self, data, content_type=""):
+        # return (json.dumps(data) + "\n").encode("utf-8")
+        data_str = f"data: {json.dumps(data)}\n"
+        if content_type == "Finished":
+            data_str += "data: [DONE]\n"
+        return data_str
+
     def output(self, content=None, content_type=None) -> bytes:
-        return (
-            json.dumps(
+        data = {
+            "created": 1677825464,
+            "id": "chatcmpl-bing",
+            "object": "chat.completion.chunk",
+            # "content_type": content_type,
+            "model": "bing",
+            "choices": [],
+        }
+        if content_type == "Role":
+            data["choices"] = [
+                {
+                    "index": 0,
+                    "delta": {"role": "assistant"},
+                    "finish_reason": None,
+                }
+            ]
+        elif content_type in [
+            "Completions",
+            "InternalSearchQuery",
+            "InternalSearchResult",
+            "SuggestedResponses",
+        ]:
+            data["choices"] = [
+                {
+                    "index": 0,
+                    "delta": {"content": content},
+                    "finish_reason": None,
+                }
+            ]
+        elif content_type == "Finished":
+            data["choices"] = [
+                {
+                    "index": 0,
+                    "delta": {},
+                    "finish_reason": "stop",
+                }
+            ]
+        else:
+            data["choices"] = [
                 {
-                    "content": content,
-                    "content_type": content_type,
+                    "index": 0,
+                    "delta": {"content": ""},
+                    "finish_reason": None,
                 }
-            )
-            + "\n"
-        ).encode("utf-8")
+            ]
+        return self.data_to_string(data, content_type)

networks/message_parser.py

@@ -37,8 +37,12 @@ class MessageParser:
                             delta_content, content_type="Completions"
                         )
                         if message.get("suggestedResponses"):
+                            suggestion_texts_str = "\nSuggested Questions:\n"
+                            suggestion_texts_str += "\n".join(
+                                f"- {item}" for item in suggestion_texts
+                            )
                             output_bytes += self.outputer.output(
-                                suggestion_texts,
+                                suggestion_texts_str,
                                 content_type="SuggestedResponses",
                             )
                         return output_bytes
@@ -46,7 +50,7 @@ class MessageParser:
                 # Message: Search Query
                 elif message_type in ["InternalSearchQuery"]:
                     message_hidden_text = message["hiddenText"]
-                    search_str = f"\n[Searching: [{message_hidden_text}]]"
+                    search_str = f"\n[Searching: [{message_hidden_text}]]\n"
                     logger.note(search_str)
                     if return_output:
                         return self.outputer.output(
@@ -54,7 +58,7 @@ class MessageParser:
                         )
                 # Message: Internal Search Results
                 elif message_type in ["InternalSearchResult"]:
-                    analysis_str = f"\n[Analyzing search results ...]"
+                    analysis_str = f"\n[Analyzing search results ...]\n"
                     logger.note(analysis_str)
                     if return_output:
                         return self.outputer.output(