api/utils.py

from datetime import datetime
import json
import uuid
import asyncio
import random
import string
import os
from typing import Any, Dict, Optional

import httpx
from fastapi import HTTPException
from api.config import (
    MODEL_MAPPING,
    get_headers_api_chat,
    get_headers_chat,
    BASE_URL,
    AGENT_MODE,
    TRENDING_AGENT_MODE,
    MODEL_PREFIXES,
    MODEL_REFERERS
)
from api.models import ChatRequest
from api.logger import setup_logger
from api.validate import getHid  # Import the asynchronous getHid function

logger = setup_logger(__name__)

# Define the blocked message
BLOCKED_MESSAGE = "Generated by BLACKBOX.AI, try unlimited chat https://www.blackbox.ai"

# Fetch the advertisement text from environment variable
ADVERTISEMENT_TEXT = os.getenv("ADVERTISEMENT_TEXT", "")

# Helper function to create chat completion data
def create_chat_completion_data(
    content: str, model: str, timestamp: int, finish_reason: Optional[str] = None
) -> Dict[str, Any]:
    return {
        "id": f"chatcmpl-{uuid.uuid4()}",
        "object": "chat.completion.chunk",
        "created": timestamp,
        "model": model,
        "choices": [
            {
                "index": 0,
                "delta": {"content": content, "role": "assistant"},
                "finish_reason": finish_reason,
            }
        ],
        "usage": None,
    }

# Function to convert message to dictionary format, ensuring base64 data and optional model prefix
def message_to_dict(message, model_prefix: Optional[str] = None):
    content = message.content if isinstance(message.content, str) else message.content[0]["text"]
    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]:
        # Ensure base64 images are always included for all models
        image_base64 = message.content[1]["image_url"]["url"]
        return {
            "role": message.role,
            "content": content,
            "data": {
                "imageBase64": image_base64,
                "fileText": "",
                "title": "snapshot",
                # Added imagesData field here
                "imagesData": [
                    {
                        "filePath": f"MultipleFiles/{uuid.uuid4().hex}.jpg",
                        "contents": image_base64
                    }
                ],
            },
        }
    return {"role": message.role, "content": content}

# Function to strip model prefix from content if present
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

# Process streaming response with headers from config.py
async def process_streaming_response(request: ChatRequest):
    # Generate a unique ID for this request
    request_id = f"chatcmpl-{uuid.uuid4()}"
    logger.info(f"Processing request with ID: {request_id} - Model: {request.model}")

    agent_mode = AGENT_MODE.get(request.model, {})
    trending_agent_mode = TRENDING_AGENT_MODE.get(request.model, {})
    model_prefix = MODEL_PREFIXES.get(request.model, "")

    # Adjust headers_api_chat since referer_url is removed
    headers_api_chat = get_headers_api_chat(BASE_URL)

    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' "
            f"(Request ID: {request_id})"
        )
        await asyncio.sleep(delay_seconds)

    # Fetch the h-value for the 'validated' field
    h_value = await getHid()
    if not h_value:
        logger.error("Failed to retrieve h-value for validation.")
        raise HTTPException(
            status_code=500, detail="Validation failed due to missing h-value."
        )

    json_data = {
        "agentMode": agent_mode,
        "clickedAnswer2": False,
        "clickedAnswer3": False,
        "clickedForceWebSearch": False,
        "codeModelMode": True,
        "githubToken": None,
        "id": None,  # Using request_id instead of 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),
        "userSystemPrompt": None,
        "validated": h_value,  # Dynamically set the validated field
        "visitFromDelta": False,
        "webSearchModePrompt": False,
        "imageGenerationMode": False,  # Added this line
    }

    async with httpx.AsyncClient() as client:
        try:
            async with client.stream(
                "POST",
                f"{BASE_URL}/api/chat",
                headers=headers_api_chat,
                json=json_data,
                timeout=100,
            ) as response:
                response.raise_for_status()

                # Start processing the chunks and yield them one by one
                timestamp = int(datetime.now().timestamp())
                response_content = ""  # Collect response content

                async for chunk in response.aiter_text():
                    if chunk:
                        content = chunk
                        if content.startswith("$@$v=undefined-rv1$@$"):
                            content = content[21:]  # Remove unwanted prefix

                        # Remove blocked message if present
                        if BLOCKED_MESSAGE in content:
                            logger.info(f"Blocked message detected in response for Request ID {request_id}.")
                            content = content.replace(BLOCKED_MESSAGE, '').strip()

                        if not content:
                            continue  # Skip if content is empty after removal

                        # Clean up the content
                        cleaned_content = strip_model_prefix(content, model_prefix)

                        # Yield each chunk as soon as it's ready
                        yield f"data: {json.dumps(create_chat_completion_data(cleaned_content, request.model, timestamp))}\n\n"
                        response_content += cleaned_content  # Collect the full response content

                # After all chunks are processed, add the advertisement text at the end
                if ADVERTISEMENT_TEXT:
                    response_content += "\n\n" + ADVERTISEMENT_TEXT
                    yield f"data: {json.dumps(create_chat_completion_data(response_content, request.model, timestamp, 'stop'))}\n\n"

                # Add the final "done" marker
                yield "data: [DONE]\n\n"

        except httpx.HTTPStatusError as e:
            logger.error(f"HTTP error occurred for Request ID {request_id}: {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 Request ID {request_id}: {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):
    # Generate a unique ID for this request
    request_id = f"chatcmpl-{uuid.uuid4()}"
    logger.info(f"Processing request with ID: {request_id} - Model: {request.model}")

    agent_mode = AGENT_MODE.get(request.model, {})
    trending_agent_mode = TRENDING_AGENT_MODE.get(request.model, {})
    model_prefix = MODEL_PREFIXES.get(request.model, "")

    # Adjust headers_api_chat and headers_chat since referer_url is removed
    headers_api_chat = get_headers_api_chat(BASE_URL)
    headers_chat = get_headers_chat(
        BASE_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' "
            f"(Request ID: {request_id})"
        )
        await asyncio.sleep(delay_seconds)

    # Fetch the h-value for the 'validated' field
    h_value = await getHid()
    if not h_value:
        logger.error("Failed to retrieve h-value for validation.")
        raise HTTPException(
            status_code=500, detail="Validation failed due to missing h-value."
        )

    json_data = {
        "agentMode": agent_mode,
        "clickedAnswer2": False,
        "clickedAnswer3": False,
        "clickedForceWebSearch": False,
        "codeModelMode": True,
        "githubToken": None,
        "id": None,  # Using request_id instead of 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),
        "userSystemPrompt": None,
        "validated": h_value,  # Dynamically set the validated field
        "visitFromDelta": False,
        "webSearchModePrompt": False,
        "imageGenerationMode": False,  # Added this line
    }

    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 Request ID {request_id}: {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 Request ID {request_id}: {e}"
            )
            raise HTTPException(status_code=500, detail=str(e))

    if full_response.startswith("$@$v=undefined-rv1$@$"):
        full_response = full_response[21:]

    # Remove the blocked message if present
    if BLOCKED_MESSAGE in full_response:
        logger.info(
            f"Blocked message detected in response for Request ID {request_id}."
        )
        full_response = full_response.replace(BLOCKED_MESSAGE, '').strip()
        if not full_response:
            raise HTTPException(
                status_code=500, detail="Blocked message detected in response."
            )

    cleaned_full_response = strip_model_prefix(full_response, model_prefix)

    # Append the advertisement text only once at the end
    if ADVERTISEMENT_TEXT:
        cleaned_full_response += "\n\n" + ADVERTISEMENT_TEXT

    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,
    }