Update api/utils.py

api/utils.py

@@ -1,7 +1,12 @@
+# utils.py
+
 from datetime import datetime
 import json
-from typing import Any, Dict, Optional
 import uuid
+import asyncio
+import random
+import string
+from typing import Any, Dict, Optional
 
 import httpx
 from fastapi import Depends, HTTPException
@@ -13,8 +18,9 @@ from api.config import (
     headers,
     AGENT_MODE,
     TRENDING_AGENT_MODE,
-    APP_SECRET,
-    BASE_URL,
+    MODEL_PREFIXES,
+    MODEL_REFERERS,
+    BASE_URL
 )
 from api.models import ChatRequest
 
@@ -26,12 +32,16 @@ logger = setup_logger(__name__)
 bearer_scheme = HTTPBearer()
 
 
+def generate_chat_id(length: int = 7) -> str:
+    """Generate a random alphanumeric chat ID."""
+    characters = string.ascii_letters + string.digits
+    return ''.join(random.choices(characters, k=length))
+
+
 def create_chat_completion_data(
     content: str, model: str, timestamp: int, finish_reason: Optional[str] = None
 ) -> Dict[str, Any]:
-    """
-    Create a dictionary representing a chat completion chunk.
-    """
+    """Create a dictionary representing a chat completion chunk."""
     return {
         "id": f"chatcmpl-{uuid.uuid4()}",
         "object": "chat.completion.chunk",
@@ -49,9 +59,7 @@ def create_chat_completion_data(
 
 
 def verify_app_secret(credentials: HTTPAuthorizationCredentials = Depends(bearer_scheme)):
-    """
-    Verify the APP_SECRET from the authorization credentials.
-    """
+    """Verify the APP_SECRET from the authorization credentials."""
     if credentials.credentials != APP_SECRET:
         logger.warning("Invalid APP_SECRET provided.")
         raise HTTPException(status_code=403, detail="Invalid APP_SECRET")
@@ -59,97 +67,111 @@ def verify_app_secret(credentials: HTTPAuthorizationCredentials = Depends(bearer
     return credentials.credentials
 
 
-def message_to_dict(message):
+def message_to_dict(message, model_prefix: Optional[str] = None):
     """
     Convert a message object to a dictionary suitable for the API request.
-    Handles different content types gracefully.
+    Ensures base64 data and optional model prefix are handled.
     """
-    message_dict = {"role": message.role}
-
     if isinstance(message.content, str):
-        message_dict["content"] = message.content
+        content = message.content
     elif isinstance(message.content, list):
-        # Handle list content more robustly
-        try:
-            if len(message.content) >= 2:
-                # Assuming the first element has 'text' and the second has 'image_url'
-                text_content = message.content[0].get("text", "")
-                image_url = message.content[1].get("image_url", {}).get("url", "")
-                message_dict["content"] = text_content
-                message_dict["data"] = {
-                    "imageBase64": image_url,
-                    "fileText": "",
-                    "title": "snapshot",
-                }
-            else:
-                # Fallback if the list doesn't have expected structure
-                message_dict["content"] = json.dumps(message.content)
-        except (AttributeError, KeyError, TypeError) as e:
-            logger.error(f"Error parsing message content: {e}")
-            message_dict["content"] = "Invalid message format."
+        content = message.content[0].get("text", "")
     else:
-        # Fallback for unexpected content types
-        message_dict["content"] = str(message.content)
+        content = str(message.content)
 
-    return message_dict
+    if model_prefix:
+        content = f"{model_prefix} {content}"
 
+    if isinstance(message.content, list) and len(message.content) == 2 and "image_url" in message.content[1]:
+        return {
+            "role": message.role,
+            "content": content,
+            "data": {
+                "imageBase64": message.content[1]["image_url"]["url"],
+                "fileText": "",
+                "title": "snapshot",
+            },
+        }
 
-def get_agent_mode(model: str) -> Dict[str, Any]:
+    return {"role": message.role, "content": content}
+
+
+def strip_model_prefix(content: str, model_prefix: Optional[str] = None) -> str:
+    """Remove the model prefix from the response content if present."""
+    if model_prefix and content.startswith(model_prefix):
+        logger.debug(f"Stripping prefix '{model_prefix}' from content.")
+        return content[len(model_prefix):].strip()
+    return content
+
+
+def get_referer_url(chat_id: str, 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 BASE_URL
+
+
+def get_agent_mode_config(model: str) -> Dict[str, Any]:
     """
-    Retrieves the agent mode configuration.
-    Falls back to an empty dictionary if not found.
+    Retrieve the agent mode configuration.
+    Logs a warning if the configuration is missing.
     """
-    agent_mode = AGENT_MODE.get(model, {})
+    agent_mode = AGENT_MODE.get(model)
     if not agent_mode:
         logger.warning(f"No AGENT_MODE configuration found for model: {model}")
-    return agent_mode
+    return agent_mode or {}
 
 
-def get_trending_agent_mode(model: str) -> Dict[str, Any]:
+def get_trending_agent_mode_config(model: str) -> Dict[str, Any]:
     """
-    Retrieves the trending agent mode configuration.
-    Falls back to an empty dictionary if not found.
+    Retrieve the trending agent mode configuration.
+    Logs a warning if the configuration is missing.
     """
-    trending_agent_mode = TRENDING_AGENT_MODE.get(model, {})
+    trending_agent_mode = TRENDING_AGENT_MODE.get(model)
     if not trending_agent_mode:
         logger.warning(f"No TRENDING_AGENT_MODE configuration found for model: {model}")
-    return trending_agent_mode
+    return trending_agent_mode or {}
 
 
 async def process_streaming_response(request: ChatRequest):
-    """
-    Process a streaming response for a chat completion request.
-    """
-    agent_mode = get_agent_mode(request.model)
-    trending_agent_mode = get_trending_agent_mode(request.model)
+    """Process a streaming response for a chat completion request."""
+    chat_id = generate_chat_id()
+    referer_url = get_referer_url(chat_id, request.model)
+    logger.info(f"Generated Chat ID: {chat_id} - Model: {request.model} - URL: {referer_url}")
+
+    agent_mode = get_agent_mode_config(request.model)
+    trending_agent_mode = get_trending_agent_mode_config(request.model)
+    model_prefix = MODEL_PREFIXES.get(request.model, "")
 
-    # Log reduced information
-    logger.info(
-        f"Streaming request for model: '{request.model}', "
-        f"agent mode: {agent_mode}, trending agent mode: {trending_agent_mode}"
-    )
+    headers_api_chat = headers  # Assuming 'headers' from config.py is suitable
+
+    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})")
+        await asyncio.sleep(delay_seconds)
 
     json_data = {
-        "messages": [message_to_dict(msg) for msg in request.messages],
-        "previewToken": None,
-        "userId": None,
-        "codeModelMode": True,
         "agentMode": agent_mode,
-        "trendingAgentMode": trending_agent_mode,
-        "isMicMode": False,
-        "userSystemPrompt": None,
-        "maxTokens": request.max_tokens,
-        "playgroundTopP": request.top_p,
-        "playgroundTemperature": request.temperature,
-        "isChromeExt": False,
-        "githubToken": None,
         "clickedAnswer2": False,
         "clickedAnswer3": False,
         "clickedForceWebSearch": False,
-        "visitFromDelta": 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,
-        "userSelectedModel": MODEL_MAPPING.get(request.model),
+        "playgroundTemperature": request.temperature,
+        "playgroundTopP": request.top_p,
+        "previewToken": None,
+        "trendingAgentMode": trending_agent_mode,
+        "userId": None,
+        "userSelectedModel": MODEL_MAPPING.get(request.model, request.model),
+        "userSystemPrompt": None,
         "validated": validate.getHid(),
+        "visitFromDelta": False,
     }
 
     async with httpx.AsyncClient() as client:
@@ -157,9 +179,9 @@ async def process_streaming_response(request: ChatRequest):
             async with client.stream(
                 "POST",
                 f"{BASE_URL}/api/chat",
-                headers=headers,
+                headers=headers_api_chat,
                 json=json_data,
-                timeout=httpx.Timeout(100.0),
+                timeout=100.0,
             ) as response:
                 response.raise_for_status()
                 timestamp = int(datetime.now().timestamp())
@@ -173,96 +195,96 @@ async def process_streaming_response(request: ChatRequest):
                             break
                         if content.startswith("$@$v=undefined-rv1$@$"):
                             content = content[21:]
-                        yield f"data: {json.dumps(create_chat_completion_data(content, request.model, timestamp))}\n\n"
+                        cleaned_content = strip_model_prefix(content, model_prefix)
+                        yield f"data: {json.dumps(create_chat_completion_data(cleaned_content, request.model, timestamp))}\n\n"
 
                 # Indicate the end of the stream
                 yield f"data: {json.dumps(create_chat_completion_data('', request.model, timestamp, 'stop'))}\n\n"
                 yield "data: [DONE]\n\n"
         except httpx.HTTPStatusError as e:
-            logger.error(f"HTTP error occurred: {e.response.status_code} - {e.response.text}")
-            raise HTTPException(status_code=e.response.status_code, detail="Error from upstream service.")
+            logger.error(f"HTTP error occurred for Chat ID {chat_id}: {e}")
+            raise HTTPException(status_code=e.response.status_code, detail=str(e))
         except httpx.RequestError as e:
-            logger.error(f"Request error occurred: {e}")
-            raise HTTPException(status_code=500, detail="Internal server error.")
+            logger.error(f"Request error occurred for Chat ID {chat_id}: {e}")
+            raise HTTPException(status_code=500, detail=str(e))
         except Exception as e:
-            logger.error(f"Unexpected error: {e}")
-            raise HTTPException(status_code=500, detail="Internal server error.")
+            logger.error(f"Unexpected error for Chat ID {chat_id}: {e}")
+            raise HTTPException(status_code=500, detail=str(e))
 
 
 async def process_non_streaming_response(request: ChatRequest):
-    """
-    Process a non-streaming response for a chat completion request.
-    """
-    agent_mode = get_agent_mode(request.model)
-    trending_agent_mode = get_trending_agent_mode(request.model)
+    """Process a non-streaming response for a chat completion request."""
+    chat_id = generate_chat_id()
+    referer_url = get_referer_url(chat_id, request.model)
+    logger.info(f"Generated Chat ID: {chat_id} - Model: {request.model} - URL: {referer_url}")
 
-    # Log reduced information
-    logger.info(
-        f"Non-streaming request for model: '{request.model}', "
-        f"agent mode: {agent_mode}, trending agent mode: {trending_agent_mode}"
-    )
+    agent_mode = get_agent_mode_config(request.model)
+    trending_agent_mode = get_trending_agent_mode_config(request.model)
+    model_prefix = MODEL_PREFIXES.get(request.model, "")
+
+    headers_api_chat = headers  # Assuming 'headers' from config.py is suitable
+
+    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})")
+        await asyncio.sleep(delay_seconds)
 
     json_data = {
-        "messages": [message_to_dict(msg) for msg in request.messages],
-        "previewToken": None,
-        "userId": None,
-        "codeModelMode": True,
         "agentMode": agent_mode,
-        "trendingAgentMode": trending_agent_mode,
-        "isMicMode": False,
-        "userSystemPrompt": None,
-        "maxTokens": request.max_tokens,
-        "playgroundTopP": request.top_p,
-        "playgroundTemperature": request.temperature,
-        "isChromeExt": False,
-        "githubToken": None,
         "clickedAnswer2": False,
         "clickedAnswer3": False,
         "clickedForceWebSearch": False,
-        "visitFromDelta": 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,
-        "userSelectedModel": MODEL_MAPPING.get(request.model),
+        "playgroundTemperature": request.temperature,
+        "playgroundTopP": request.top_p,
+        "previewToken": None,
+        "trendingAgentMode": trending_agent_mode,
+        "userId": None,
+        "userSelectedModel": MODEL_MAPPING.get(request.model, request.model),
+        "userSystemPrompt": None,
         "validated": validate.getHid(),
+        "visitFromDelta": False,
     }
 
-    try:
-        async with httpx.AsyncClient() as client:
-            response = await client.post(
-                f"{BASE_URL}/api/chat",
-                headers=headers,
-                json=json_data,
-                timeout=httpx.Timeout(100.0),
-            )
-            response.raise_for_status()
-            full_response = response.text
-
-        # Process the full response
-        if "https://www.blackbox.ai" in full_response:
-            validate.getHid(True)
-            full_response = "hid已刷新，重新对话即可"
-        if full_response.startswith("$@$v=undefined-rv1$@$"):
-            full_response = full_response[21:]
+    full_response = ""
+    async with httpx.AsyncClient() as client:
+        try:
+            async with client.stream(
+                method="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
+        except httpx.HTTPStatusError as e:
+            logger.error(f"HTTP error occurred for Chat ID {chat_id}: {e}")
+            raise HTTPException(status_code=e.response.status_code, detail=str(e))
+        except httpx.RequestError as e:
+            logger.error(f"Request error occurred for Chat ID {chat_id}: {e}")
+            raise HTTPException(status_code=500, detail=str(e))
 
-        return {
-            "id": f"chatcmpl-{uuid.uuid4()}",
-            "object": "chat.completion",
-            "created": int(datetime.now().timestamp()),
-            "model": request.model,
-            "choices": [
-                {
-                    "index": 0,
-                    "message": {"role": "assistant", "content": full_response},
-                    "finish_reason": "stop",
-                }
-            ],
-            "usage": None,
-        }
-    except httpx.HTTPStatusError as e:
-        logger.error(f"HTTP error occurred: {e.response.status_code} - {e.response.text}")
-        raise HTTPException(status_code=e.response.status_code, detail="Error from upstream service.")
-    except httpx.RequestError as e:
-        logger.error(f"Request error occurred: {e}")
-        raise HTTPException(status_code=500, detail="Internal server error.")
-    except Exception as e:
-        logger.error(f"Unexpected error: {e}")
-        raise HTTPException(status_code=500, detail="Internal server error.")
+    if full_response.startswith("$@$v=undefined-rv1$@$"):
+        full_response = full_response[21:]
+
+    cleaned_full_response = strip_model_prefix(full_response, model_prefix)
+
+    return {
+        "id": f"chatcmpl-{uuid.uuid4()}",
+        "object": "chat.completion",
+        "created": int(datetime.now().timestamp()),
+        "model": request.model,
+        "choices": [
+            {
+                "index": 0,
+                "message": {"role": "assistant", "content": cleaned_full_response},
+                "finish_reason": "stop",
+            }
+        ],
+        "usage": None,
+    }