Update api/utils.py

api/utils.py

@@ -11,7 +11,6 @@ from fastapi import HTTPException
 from api.config import (
     MODEL_MAPPING,
     get_headers_api_chat,
-    get_headers_chat,
     BASE_URL,
     AGENT_MODE,
     TRENDING_AGENT_MODE,
@@ -27,12 +26,6 @@ from api import validate
 logger = setup_logger(__name__)
 
 
-# Helper function to create a random alphanumeric chat ID
-def generate_chat_id(length: int = 7) -> str:
-    characters = string.ascii_letters + string.digits
-    return ''.join(random.choices(characters, k=length))
-
-
 # Helper function to create chat completion data
 def create_chat_completion_data(
     content: str,
@@ -48,7 +41,7 @@ def create_chat_completion_data(
         "choices": [
             {
                 "index": 0,
-                "delta": {"content": content, "role": "assistant"},
+                "delta": {"content": content},
                 "finish_reason": finish_reason,
             }
         ],
@@ -93,19 +86,18 @@ def strip_model_prefix(content: str, model_prefix: Optional[str] = None) -> str:
 
 
 # Function to get the correct referer URL for logging
-def get_referer_url(chat_id: str, model: str) -> str:
+def get_referer_url(model: str) -> str:
     """Generate the referer URL based on specific models listed in MODEL_REFERERS."""
     if model in MODEL_REFERERS:
-        return f"{BASE_URL}/chat/{chat_id}?model={model}"
+        return f"{BASE_URL}/chat?model={model}"
     return BASE_URL
 
 
 # Process streaming response with headers from config.py
 async def process_streaming_response(request: ChatRequest):
-    chat_id = generate_chat_id()
-    referer_url = get_referer_url(chat_id, request.model)
+    referer_url = get_referer_url(request.model)
     logger.info(
-        f"Generated Chat ID: {chat_id} - Model: {request.model} - URL: {referer_url}"
+        f"Model: {request.model} - URL: {referer_url}"
     )
 
     agent_mode = AGENT_MODE.get(request.model, {})
@@ -117,35 +109,33 @@ async def process_streaming_response(request: ChatRequest):
     if request.model == 'o1-preview':
         delay_seconds = random.randint(1, 60)
         logger.info(
-            f"Introducing a delay of {delay_seconds} seconds for model 'o1-preview' (Chat ID: {chat_id})"
+            f"Introducing a delay of {delay_seconds} seconds for model 'o1-preview'"
         )
         await asyncio.sleep(delay_seconds)
 
     json_data = {
-        "agentMode": agent_mode,
-        "clickedAnswer2": False,
-        "clickedAnswer3": False,
-        "clickedForceWebSearch": False,
-        "codeModelMode": True,
-        "githubToken": None,
-        "id": chat_id,
-        "isChromeExt": False,
-        "isMicMode": False,
-        "maxTokens": request.max_tokens,
         "messages": [
             message_to_dict(msg, model_prefix=model_prefix) for msg in request.messages
         ],
-        "mobileClient": False,
-        "playgroundTemperature": request.temperature,
-        "playgroundTopP": request.top_p,
         "previewToken": None,
-        "trendingAgentMode": trending_agent_mode,
         "userId": None,
-        "userSelectedModel": MODEL_MAPPING.get(request.model, request.model),
+        "codeModelMode": True,
+        "agentMode": agent_mode,
+        "trendingAgentMode": trending_agent_mode,
+        "isMicMode": False,
         "userSystemPrompt": None,
-        # Use validate.getHid() for the 'validated' field
-        "validated": validate.getHid(),
+        "maxTokens": request.max_tokens,
+        "playgroundTopP": request.top_p,
+        "playgroundTemperature": request.temperature,
+        "isChromeExt": False,
+        "githubToken": None,
+        "clickedAnswer2": False,
+        "clickedAnswer3": False,
+        "clickedForceWebSearch": False,
         "visitFromDelta": False,
+        "mobileClient": False,
+        "userSelectedModel": MODEL_MAPPING.get(request.model, request.model),
+        "validated": validate.getHid(),
     }
 
     async with httpx.AsyncClient() as client:
@@ -159,42 +149,42 @@ async def process_streaming_response(request: ChatRequest):
             ) as response:
                 response.raise_for_status()
                 async for line in response.aiter_lines():
-                    timestamp = int(datetime.now().timestamp())
                     if line:
-                        content = line + "\n"
-                        if "https://www.blackbox.ai" in content:
+                        # Process the line as per the Blackbox API response format
+                        if "https://www.blackbox.ai" in line:
                             # Refresh hid and inform the user
                             validate.getHid(True)
-                            content = "The HID has been refreshed; please try again.\n"
+                            content = "The HID has been refreshed; please try again."
                             yield (
-                                f"data: {json.dumps(create_chat_completion_data(content, request.model, timestamp))}\n\n"
+                                f"data: {json.dumps(create_chat_completion_data(content, request.model, int(datetime.now().timestamp())))}\n\n"
                             )
                             break
-                        if content.startswith("$@$v=undefined-rv1$@$"):
-                            content = content[21:]
-                        cleaned_content = strip_model_prefix(content, model_prefix)
+                        if line.startswith("$@$v=undefined-rv1$@$"):
+                            line = line[21:]
+                        cleaned_content = strip_model_prefix(line, model_prefix)
+                        # Yield the data in the format expected by the client
                         yield (
-                            f"data: {json.dumps(create_chat_completion_data(cleaned_content, request.model, timestamp))}\n\n"
+                            f"data: {json.dumps(create_chat_completion_data(cleaned_content, request.model, int(datetime.now().timestamp())))}\n\n"
                         )
 
+                # Signal that the response is complete
                 yield (
-                    f"data: {json.dumps(create_chat_completion_data('', request.model, timestamp, 'stop'))}\n\n"
+                    f"data: {json.dumps(create_chat_completion_data('', request.model, int(datetime.now().timestamp()), 'stop'))}\n\n"
                 )
                 yield "data: [DONE]\n\n"
         except httpx.HTTPStatusError as e:
-            logger.error(f"HTTP error occurred for Chat ID {chat_id}: {e}")
+            logger.error(f"HTTP error occurred: {e}")
             raise HTTPException(status_code=e.response.status_code, detail=str(e))
         except httpx.RequestError as e:
-            logger.error(f"Error occurred during request for Chat ID {chat_id}: {e}")
+            logger.error(f"Error occurred during request: {e}")
             raise HTTPException(status_code=500, detail=str(e))
 
 
 # Process non-streaming response with headers from config.py
 async def process_non_streaming_response(request: ChatRequest):
-    chat_id = generate_chat_id()
-    referer_url = get_referer_url(chat_id, request.model)
+    referer_url = get_referer_url(request.model)
     logger.info(
-        f"Generated Chat ID: {chat_id} - Model: {request.model} - URL: {referer_url}"
+        f"Model: {request.model} - URL: {referer_url}"
     )
 
     agent_mode = AGENT_MODE.get(request.model, {})
@@ -202,63 +192,54 @@ async def process_non_streaming_response(request: ChatRequest):
     model_prefix = MODEL_PREFIXES.get(request.model, "")
 
     headers_api_chat = get_headers_api_chat(referer_url)
-    headers_chat = get_headers_chat(
-        referer_url,
-        next_action=str(uuid.uuid4()),
-        next_router_state_tree=json.dumps([""]),
-    )
 
     if request.model == 'o1-preview':
         delay_seconds = random.randint(20, 60)
         logger.info(
-            f"Introducing a delay of {delay_seconds} seconds for model 'o1-preview' (Chat ID: {chat_id})"
+            f"Introducing a delay of {delay_seconds} seconds for model 'o1-preview'"
         )
         await asyncio.sleep(delay_seconds)
 
     json_data = {
-        "agentMode": agent_mode,
-        "clickedAnswer2": False,
-        "clickedAnswer3": False,
-        "clickedForceWebSearch": False,
-        "codeModelMode": True,
-        "githubToken": None,
-        "id": chat_id,
-        "isChromeExt": False,
-        "isMicMode": False,
-        "maxTokens": request.max_tokens,
         "messages": [
             message_to_dict(msg, model_prefix=model_prefix) for msg in request.messages
         ],
-        "mobileClient": False,
-        "playgroundTemperature": request.temperature,
-        "playgroundTopP": request.top_p,
         "previewToken": None,
-        "trendingAgentMode": trending_agent_mode,
         "userId": None,
-        "userSelectedModel": MODEL_MAPPING.get(request.model, request.model),
+        "codeModelMode": True,
+        "agentMode": agent_mode,
+        "trendingAgentMode": trending_agent_mode,
+        "isMicMode": False,
         "userSystemPrompt": None,
-        # Use validate.getHid() for the 'validated' field
-        "validated": validate.getHid(),
+        "maxTokens": request.max_tokens,
+        "playgroundTopP": request.top_p,
+        "playgroundTemperature": request.temperature,
+        "isChromeExt": False,
+        "githubToken": None,
+        "clickedAnswer2": False,
+        "clickedAnswer3": False,
+        "clickedForceWebSearch": False,
         "visitFromDelta": False,
+        "mobileClient": False,
+        "userSelectedModel": MODEL_MAPPING.get(request.model, request.model),
+        "validated": validate.getHid(),
     }
 
     full_response = ""
     async with httpx.AsyncClient() as client:
         try:
-            async with client.stream(
-                method="POST",
+            response = await client.post(
                 url=f"{BASE_URL}/api/chat",
                 headers=headers_api_chat,
                 json=json_data,
-            ) as response:
-                response.raise_for_status()
-                async for chunk in response.aiter_text():
-                    full_response += chunk
+            )
+            response.raise_for_status()
+            full_response = response.text
         except httpx.HTTPStatusError as e:
-            logger.error(f"HTTP error occurred for Chat ID {chat_id}: {e}")
+            logger.error(f"HTTP error occurred: {e}")
             raise HTTPException(status_code=e.response.status_code, detail=str(e))
         except httpx.RequestError as e:
-            logger.error(f"Error occurred during request for Chat ID {chat_id}: {e}")
+            logger.error(f"Error occurred during request: {e}")
             raise HTTPException(status_code=500, detail=str(e))
 
     if "https://www.blackbox.ai" in full_response: