Update api/utils.py

api/utils.py

@@ -1,36 +1,25 @@
-# utils.py
-
 from datetime import datetime
+from http.client import HTTPException
 import json
 from typing import Any, Dict, Optional
+import uuid
 
 import httpx
-from fastapi import Depends, HTTPException
-from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
-
 from api import validate
-from api.config import (
-    MODEL_MAPPING,
-    headers,
-    AGENT_MODE,
-    TRENDING_AGENT_MODE,
-    MODEL_PREFIXES,
-    BASE_URL
-)
+from api.config import MODEL_MAPPING, headers, AGENT_MODE, TRENDING_AGENT_MODE
+from fastapi import Depends, security
+from fastapi.security import HTTPAuthorizationCredentials
+
+from api.config import APP_SECRET, BASE_URL
 from api.models import ChatRequest
 
 from api.logger import setup_logger
 
 logger = setup_logger(__name__)
 
-# Initialize the HTTPBearer security scheme
-bearer_scheme = HTTPBearer()
-
-
 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."""
     return {
         "id": f"chatcmpl-{uuid.uuid4()}",
         "object": "chat.completion.chunk",
@@ -46,122 +35,58 @@ def create_chat_completion_data(
         "usage": None,
     }
 
-
-def verify_app_secret(credentials: HTTPAuthorizationCredentials = Depends(bearer_scheme)):
-    """Verify the APP_SECRET from the authorization credentials."""
+def verify_app_secret(credentials: HTTPAuthorizationCredentials = Depends(security)):
     if credentials.credentials != APP_SECRET:
-        logger.warning("Invalid APP_SECRET provided.")
         raise HTTPException(status_code=403, detail="Invalid APP_SECRET")
-    logger.debug("APP_SECRET verified successfully.")
     return credentials.credentials
 
-
 def message_to_dict(message):
-    """
-    Convert a message object to a dictionary suitable for the API request.
-    Handles different content types gracefully.
-    """
-    message_dict = {"role": message.role}
-
     if isinstance(message.content, str):
-        message_dict["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."
+        return {"role": message.role, "content": message.content}
+    elif isinstance(message.content, list) and len(message.content) == 2:
+        return {
+            "role": message.role,
+            "content": message.content[0]["text"],
+            "data": {
+                "imageBase64": message.content[1]["image_url"]["url"],
+                "fileText": "",
+                "title": "snapshot",
+            },
+        }
     else:
-        # Fallback for unexpected content types
-        message_dict["content"] = str(message.content)
-
-    return message_dict
-
-
-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_agent_mode_config(model: str) -> Dict[str, Any]:
-    """
-    Retrieve the agent mode configuration.
-    Logs a warning if the configuration is missing.
-    """
-    agent_mode = AGENT_MODE.get(model)
-    if not agent_mode:
-        logger.warning(f"No AGENT_MODE configuration found for model: {model}")
-    return agent_mode or {}
-
-
-def get_trending_agent_mode_config(model: str) -> Dict[str, Any]:
-    """
-    Retrieve the trending agent mode configuration.
-    Logs a warning if the configuration is missing.
-    """
-    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 or {}
-
+        return {"role": message.role, "content": message.content}
 
 async def process_streaming_response(request: ChatRequest):
-    """Process a streaming response for a chat completion request."""
-    # No chat_id generation
-    # referer_url is not used without MODEL_REFERERS
+    agent_mode = AGENT_MODE.get(request.model, {})
+    trending_agent_mode = TRENDING_AGENT_MODE.get(request.model, {})
 
-    logger.info(f"Processing streaming request for model: '{request.model}'")
-
-    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, "")
-
-    # Use headers from config.py
-    headers_api_chat = headers
-
-    # Introduce delay for specific models if needed
-    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'")
-        await asyncio.sleep(delay_seconds)
+    # Log reduced information
+    logger.info(
+        f"Streaming request for model: '{request.model}', "
+        f"agent mode: {agent_mode}, trending agent mode: {trending_agent_mode}"
+    )
 
     json_data = {
-        "agentMode": agent_mode,
-        "clickedAnswer2": False,
-        "clickedAnswer3": False,
-        "clickedForceWebSearch": False,
-        "codeModelMode": True,
-        "githubToken": None,
-        "isChromeExt": False,
-        "isMicMode": False,
-        "maxTokens": request.max_tokens,
         "messages": [message_to_dict(msg) 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,
-        "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),
+        "validated": validate.getHid()
     }
 
     async with httpx.AsyncClient() as client:
@@ -169,103 +94,79 @@ async def process_streaming_response(request: ChatRequest):
             async with client.stream(
                 "POST",
                 f"{BASE_URL}/api/chat",
-                headers=headers_api_chat,
+                headers=headers,
                 json=json_data,
-                timeout=100.0,
+                timeout=100,
             ) as response:
                 response.raise_for_status()
-                timestamp = int(datetime.now().timestamp())
                 async for line in response.aiter_lines():
+                    timestamp = int(datetime.now().timestamp())
                     if line:
-                        content = line.strip() + "\n"
+                        content = line + "\n"
                         if "https://www.blackbox.ai" in content:
                             validate.getHid(True)
                             content = "hid已刷新,重新对话即可\n"
                             yield f"data: {json.dumps(create_chat_completion_data(content, request.model, timestamp))}\n\n"
                             break
                         if content.startswith("$@$v=undefined-rv1$@$"):
-                            content = content[21:]
-                        cleaned_content = strip_model_prefix(content, model_prefix)
-                        yield f"data: {json.dumps(create_chat_completion_data(cleaned_content, request.model, timestamp))}\n\n"
+                            yield f"data: {json.dumps(create_chat_completion_data(content[21:], request.model, timestamp))}\n\n"
+                        else:
+                            yield f"data: {json.dumps(create_chat_completion_data(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: {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.")
-        except Exception as e:
-            logger.error(f"Unexpected error: {e}")
-            raise HTTPException(status_code=500, detail="Internal server error.")
-
+            logger.error(f"Error occurred during request: {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."""
-    logger.info(f"Processing non-streaming request for model: '{request.model}'")
-
-    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, "")
+    agent_mode = AGENT_MODE.get(request.model, {})
+    trending_agent_mode = TRENDING_AGENT_MODE.get(request.model, {})
 
-    # Use headers from config.py
-    headers_api_chat = headers
-
-    # Introduce delay for specific models if needed
-    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'")
-        await asyncio.sleep(delay_seconds)
+    # Log reduced information
+    logger.info(
+        f"Non-streaming request for model: '{request.model}', "
+        f"agent mode: {agent_mode}, trending agent mode: {trending_agent_mode}"
+    )
 
     json_data = {
-        "agentMode": agent_mode,
-        "clickedAnswer2": False,
-        "clickedAnswer3": False,
-        "clickedForceWebSearch": False,
-        "codeModelMode": True,
-        "githubToken": None,
-        "isChromeExt": False,
-        "isMicMode": False,
-        "maxTokens": request.max_tokens,
         "messages": [message_to_dict(msg) 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,
-        "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),
+        "validated": validate.getHid()
     }
 
     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: {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.")
-
+        async with client.stream(
+            method="POST", url=f"{BASE_URL}/api/chat", headers=headers, json=json_data
+        ) as response:
+            async for chunk in response.aiter_text():
+                full_response += chunk
+    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:]
-
-    cleaned_full_response = strip_model_prefix(full_response, model_prefix)
-
     return {
         "id": f"chatcmpl-{uuid.uuid4()}",
         "object": "chat.completion",
@@ -274,9 +175,9 @@ async def process_non_streaming_response(request: ChatRequest):
         "choices": [
             {
                 "index": 0,
-                "message": {"role": "assistant", "content": cleaned_full_response},
+                "message": {"role": "assistant", "content": full_response},
                 "finish_reason": "stop",
             }
         ],
         "usage": None,
-    }
+    }