main.py

# main.py
import os
import re
import random
import string
import uuid
import json
import logging
import asyncio
import time
import contextvars
from collections import defaultdict
from typing import List, Dict, Any, Optional, AsyncGenerator, Union
from datetime import datetime

from slowapi import Limiter, _rate_limit_exceeded_handler
from slowapi.util import get_remote_address
from slowapi.errors import RateLimitExceeded
from slowapi.middleware import SlowAPIMiddleware
from fastapi import FastAPI, HTTPException, Request, Depends, Header
from fastapi.responses import StreamingResponse, JSONResponse, RedirectResponse
from pydantic import BaseModel

from sqlalchemy.orm import Session

from aiohttp import ClientSession, ClientTimeout, ClientError

from database import SessionLocal, engine, get_db
from models import Base, Image, Log

from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()

# Create all tables
Base.metadata.create_all(bind=engine)

# Define a context variable for client_ip
client_ip_var = contextvars.ContextVar("client_ip", default="N/A")

# Custom logging filter to inject client_ip from context variable
class ContextFilter(logging.Filter):
    def filter(self, record):
        record.client_ip = client_ip_var.get()
        return True

# Custom logging formatter to handle missing client_ip
class SafeFormatter(logging.Formatter):
    def format(self, record):
        if not hasattr(record, 'client_ip'):
            record.client_ip = 'N/A'
        return super().format(record)

# Configure logging
logger = logging.getLogger("main")  # Use a specific logger name if needed
logger.setLevel(logging.INFO)

# Create handlers
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)

# Create and set the custom formatter
formatter = SafeFormatter(
    fmt="%(asctime)s [%(levelname)s] %(name)s [IP: %(client_ip)s]: %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S"
)
console_handler.setFormatter(formatter)

# Add the custom filter to the console handler
console_handler.addFilter(ContextFilter())

# Add handlers to the logger
logger.addHandler(console_handler)

# Initialize the limiter with slowapi
limiter = Limiter(key_func=get_remote_address, default_limits=["60/minute"])
app = FastAPI()

# Register the rate limit exceeded handler
app.state.limiter = limiter
app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)

# Add SlowAPI middleware
app.add_middleware(SlowAPIMiddleware)

from logging import Handler

class DBLogHandler(Handler):
    def __init__(self, db: Session):
        super().__init__()
        self.db = db

    def emit(self, record):
        log_entry = Log(
            level=record.levelname,
            message=record.getMessage(),
            client_ip=getattr(record, 'client_ip', None)
        )
        try:
            self.db.add(log_entry)
            self.db.commit()
        except Exception as e:
            # Handle exceptions (e.g., rollback)
            self.db.rollback()
            print(f"Failed to log to database: {e}")

# Dependency to add DBLogHandler
async def get_db_log_handler(request: Request):
    db = next(get_db())
    db_log_handler = DBLogHandler(db)
    logger.addHandler(db_log_handler)
    try:
        yield
    finally:
        logger.removeHandler(db_log_handler)
        db.close()

@app.middleware("http")
async def security_middleware(request: Request, call_next):
    client_ip = request.client.host
    # Set the client_ip in the context variable
    client_ip_var.set(client_ip)
    
    # Enforce that POST requests to sensitive endpoints must have a valid Content-Type
    if request.method == "POST" and request.url.path == "/v1/chat/completions":
        content_type = request.headers.get("Content-Type")
        if content_type != "application/json":
            logger.warning("Invalid Content-Type for /v1/chat/completions")
            return JSONResponse(
                status_code=400,
                content={
                    "error": {
                        "message": "Content-Type must be application/json",
                        "type": "invalid_request_error",
                        "param": None,
                        "code": None
                    }
                },
            )
    
    # Log the incoming request
    logger.info(f"Incoming request: {request.method} {request.url.path}")
    
    response = await call_next(request)
    
    # Log the response status
    logger.info(f"Response status: {response.status_code}")
    
    return response

class Message(BaseModel):
    role: str
    content: str

class ChatRequest(BaseModel):
    model: str
    messages: List[Message]
    temperature: Optional[float] = 1.0
    top_p: Optional[float] = 1.0
    n: Optional[int] = 1
    stream: Optional[bool] = False
    stop: Optional[Union[str, List[str]]] = None
    max_tokens: Optional[int] = None
    presence_penalty: Optional[float] = 0.0
    frequency_penalty: Optional[float] = 0.0
    logit_bias: Optional[Dict[str, float]] = None
    user: Optional[str] = None
    webSearchMode: Optional[bool] = False  # Custom parameter

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

class ImageResponse:
    def __init__(self, url: str, alt: str):
        self.url = url
        self.alt = alt

def to_data_uri(image: Any) -> str:
    return "data:image/png;base64,..."  # Replace with actual base64 data

class Blackbox:
    url = "https://www.blackbox.ai"
    api_endpoint = "https://www.blackbox.ai/api/chat"
    working = True
    supports_stream = True
    supports_system_message = True
    supports_message_history = True

    default_model = 'blackboxai'
    image_models = ['ImageGeneration']
    models = [
        default_model,
        'blackboxai-pro',
        "llama-3.1-8b",
        'llama-3.1-70b',
        'llama-3.1-405b',
        'gpt-4o',
        'gemini-pro',
        'gemini-1.5-flash',
        'claude-sonnet-3.5',
        'PythonAgent',
        'JavaAgent',
        'JavaScriptAgent',
        'HTMLAgent',
        'GoogleCloudAgent',
        'AndroidDeveloper',
        'SwiftDeveloper',
        'Next.jsAgent',
        'MongoDBAgent',
        'PyTorchAgent',
        'ReactAgent',
        'XcodeAgent',
        'AngularJSAgent',
        *image_models,
        'Niansuh',
    ]

    # Filter models based on AVAILABLE_MODELS
    AVAILABLE_MODELS = os.getenv("AVAILABLE_MODELS", "")
    if AVAILABLE_MODELS:
        AVAILABLE_MODELS = [model.strip() for model in AVAILABLE_MODELS.split(',') if model.strip()]
        models = [model for model in models if model in AVAILABLE_MODELS]

    agentMode = {
        'ImageGeneration': {'mode': True, 'id': "ImageGenerationLV45LJp", 'name': "Image Generation"},
        'Niansuh': {'mode': True, 'id': "NiansuhAIk1HgESy", 'name': "Niansuh"},
    }
    trendingAgentMode = {
        "blackboxai": {},
        "gemini-1.5-flash": {'mode': True, 'id': 'Gemini'},
        "llama-3.1-8b": {'mode': True, 'id': "llama-3.1-8b"},
        'llama-3.1-70b': {'mode': True, 'id': "llama-3.1-70b"},
        'llama-3.1-405b': {'mode': True, 'id': "llama-3.1-405b"},
        'blackboxai-pro': {'mode': True, 'id': "BLACKBOXAI-PRO"},
        'PythonAgent': {'mode': True, 'id': "Python Agent"},
        'JavaAgent': {'mode': True, 'id': "Java Agent"},
        'JavaScriptAgent': {'mode': True, 'id': "JavaScript Agent"},
        'HTMLAgent': {'mode': True, 'id': "HTML Agent"},
        'GoogleCloudAgent': {'mode': True, 'id': "Google Cloud Agent"},
        'AndroidDeveloper': {'mode': True, 'id': "Android Developer"},
        'SwiftDeveloper': {'mode': True, 'id': "Swift Developer"},
        'Next.jsAgent': {'mode': True, 'id': "Next.js Agent"},
        'MongoDBAgent': {'mode': True, 'id': "MongoDB Agent"},
        'PyTorchAgent': {'mode': True, 'id': "PyTorch Agent"},
        'ReactAgent': {'mode': True, 'id': "React Agent"},
        'XcodeAgent': {'mode': True, 'id': "Xcode Agent"},
        'AngularJSAgent': {'mode': True, 'id': "AngularJS Agent"},
    }

    userSelectedModel = {
        "gpt-4o": "gpt-4o",
        "gemini-pro": "gemini-pro",
        'claude-sonnet-3.5': "claude-sonnet-3.5",
    }

    model_prefixes = {
        'gpt-4o': '@GPT-4o',
        'gemini-pro': '@Gemini-PRO',
        'claude-sonnet-3.5': '@Claude-Sonnet-3.5',
        'PythonAgent': '@Python Agent',
        'JavaAgent': '@Java Agent',
        'JavaScriptAgent': '@JavaScript Agent',
        'HTMLAgent': '@HTML Agent',
        'GoogleCloudAgent': '@Google Cloud Agent',
        'AndroidDeveloper': '@Android Developer',
        'SwiftDeveloper': '@Swift Developer',
        'Next.jsAgent': '@Next.js Agent',
        'MongoDBAgent': '@MongoDB Agent',
        'PyTorchAgent': '@PyTorch Agent',
        'ReactAgent': '@React Agent',
        'XcodeAgent': '@Xcode Agent',
        'AngularJSAgent': '@AngularJS Agent',
        'blackboxai-pro': '@BLACKBOXAI-PRO',
        'ImageGeneration': '@Image Generation',
        'Niansuh': '@Niansuh',
    }

    model_referers = {
        "blackboxai": f"{url}/?model=blackboxai",
        "gpt-4o": f"{url}/?model=gpt-4o",
        "gemini-pro": f"{url}/?model=gemini-pro",
        "claude-sonnet-3.5": f"{url}/?model=claude-sonnet-3.5"
    }

    model_aliases = {
        "gemini-flash": "gemini-1.5-flash",
        "claude-3.5-sonnet": "claude-sonnet-3.5",
        "flux": "ImageGeneration",
        "niansuh": "Niansuh",
    }

    @classmethod
    def get_model(cls, model: str) -> Optional[str]:
        if model in cls.models:
            return model
        elif model in cls.userSelectedModel and cls.userSelectedModel[model] in cls.models:
            return model
        elif model in cls.model_aliases and cls.model_aliases[model] in cls.models:
            return cls.model_aliases[model]
        else:
            return cls.default_model if cls.default_model in cls.models else None

    @classmethod
    async def create_async_generator(
        cls,
        model: str,
        messages: List[Dict[str, str]],
        proxy: Optional[str] = None,
        image: Any = None,
        image_name: Optional[str] = None,
        webSearchMode: bool = False,
        **kwargs
    ) -> AsyncGenerator[Any, None]:
        model = cls.get_model(model)
        if model is None:
            logger.error(f"Model {model} is not available. | NiansuhAI")
            raise ModelNotWorkingException(model)

        logger.info(f"Selected model: {model}")

        if not cls.working or model not in cls.models:
            logger.error(f"Model {model} is not working or not supported. | NiansuhAI")
            raise ModelNotWorkingException(model)
        
        headers = {
            "accept": "*/*",
            "accept-language": "en-US,en;q=0.9",
            "cache-control": "no-cache",
            "content-type": "application/json",
            "origin": cls.url,
            "pragma": "no-cache",
            "priority": "u=1, i",
            "referer": cls.model_referers.get(model, cls.url),
            "sec-ch-ua": '"Chromium";v="130", "Not=A?Brand";v="99"',
            "sec-ch-ua-mobile": "?0",
            "sec-ch-ua-platform": '"Linux"',
            "sec-fetch-dest": "empty",
            "sec-fetch-mode": "cors",
            "sec-fetch-site": "same-origin",
            "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36",
        }

        if model in cls.model_prefixes:
            prefix = cls.model_prefixes[model]
            if not messages[0]['content'].startswith(prefix):
                logger.debug(f"Adding prefix '{prefix}' to the first message.")
                messages[0]['content'] = f"{prefix} {messages[0]['content']}"
        
        random_id = ''.join(random.choices(string.ascii_letters + string.digits, k=7))
        messages[-1]['id'] = random_id
        messages[-1]['role'] = 'user'

        # Don't log the full message content for privacy
        logger.debug(f"Generated message ID: {random_id} for model: {model}")

        if image is not None:
            messages[-1]['data'] = {
                'fileText': '',
                'imageBase64': to_data_uri(image),
                'title': image_name
            }
            messages[-1]['content'] = 'FILE:BB\n$#$\n\n$#$\n' + messages[-1]['content']
            logger.debug("Image data added to the message.")
        
        data = {
            "messages": messages,
            "id": random_id,
            "previewToken": None,
            "userId": None,
            "codeModelMode": True,
            "agentMode": {},
            "trendingAgentMode": {},
            "isMicMode": False,
            "userSystemPrompt": None,
            "maxTokens": 99999999,
            "playgroundTopP": 0.9,
            "playgroundTemperature": 0.5,
            "isChromeExt": False,
            "githubToken": None,
            "clickedAnswer2": False,
            "clickedAnswer3": False,
            "clickedForceWebSearch": False,
            "visitFromDelta": False,
            "mobileClient": False,
            "userSelectedModel": None,
            "webSearchMode": webSearchMode,
        }

        if model in cls.agentMode:
            data["agentMode"] = cls.agentMode[model]
        elif model in cls.trendingAgentMode:
            data["trendingAgentMode"] = cls.trendingAgentMode[model]
        elif model in cls.userSelectedModel:
            data["userSelectedModel"] = cls.userSelectedModel[model]
        logger.info(f"Sending request to {cls.api_endpoint} with data (excluding messages).")

        timeout = ClientTimeout(total=60)  # Set an appropriate timeout
        retry_attempts = 10  # Set the number of retry attempts

        for attempt in range(retry_attempts):
            try:
                async with ClientSession(headers=headers, timeout=timeout) as session:
                    async with session.post(cls.api_endpoint, json=data, proxy=proxy) as response:
                        response.raise_for_status()
                        logger.info(f"Received response with status {response.status}")
                        if model == 'ImageGeneration':
                            response_text = await response.text()
                            url_match = re.search(r'https://storage\.googleapis\.com/[^\s\)]+', response_text)
                            if url_match:
                                image_url = url_match.group(0)
                                logger.info(f"Image URL found.")
                                yield ImageResponse(image_url, alt=messages[-1]['content'])
                            else:
                                logger.error("Image URL not found in the response.")
                                raise Exception("Image URL not found in the response | NiansuhAI")
                        else:
                            full_response = ""
                            search_results_json = ""
                            try:
                                async for chunk, _ in response.content.iter_chunks():
                                    if chunk:
                                        decoded_chunk = chunk.decode(errors='ignore')
                                        decoded_chunk = re.sub(r'\$@\$v=[^$]+\$@\$', '', decoded_chunk)
                                        if decoded_chunk.strip():
                                            if '$~~~$' in decoded_chunk:
                                                search_results_json += decoded_chunk
                                            else:
                                                full_response += decoded_chunk
                                                yield decoded_chunk
                                logger.info("Finished streaming response chunks.")
                            except Exception as e:
                                logger.exception("Error while iterating over response chunks.")
                                raise e
                            if data["webSearchMode"] and search_results_json:
                                match = re.search(r'\$~~~\$(.*?)\$~~~\$', search_results_json, re.DOTALL)
                                if match:
                                    try:
                                        search_results = json.loads(match.group(1))
                                        formatted_results = "\n\n**Sources:**\n"
                                        for i, result in enumerate(search_results[:5], 1):
                                            formatted_results += f"{i}. [{result['title']}]({result['link']})\n"
                                        logger.info("Formatted search results.")
                                        yield formatted_results
                                    except json.JSONDecodeError as je:
                                        logger.error("Failed to parse search results JSON.")
                                        raise je
                break  # Exit the retry loop if successful
            except ClientError as ce:
                logger.error(f"Client error occurred: {ce}. Retrying attempt {attempt + 1}/{retry_attempts}")
                if attempt == retry_attempts - 1:
                    raise HTTPException(status_code=502, detail="Error communicating with the external API. | NiansuhAI")
            except asyncio.TimeoutError:
                logger.error(f"Request timed out. Retrying attempt {attempt + 1}/{retry_attempts}")
                if attempt == retry_attempts - 1:
                    raise HTTPException(status_code=504, detail="External API request timed out. | NiansuhAI")
            except Exception as e:
                logger.error(f"Unexpected error: {e}. Retrying attempt {attempt + 1}/{retry_attempts}")
                if attempt == retry_attempts - 1:
                    raise HTTPException(status_code=500, detail=str(e))

@app.post("/v1/chat/completions", dependencies=[Depends(limiter.limit("60/minute")), Depends(get_db_log_handler)])
async def chat_completions(request: ChatRequest, req: Request, api_key: str = Depends(get_api_key), db: Session = Depends(get_db)):
    # Redact user messages only for logging purposes
    redacted_messages = [{"role": msg.role, "content": "[redacted]"} for msg in request.messages]

    logger.info(f"Received chat completions request from API key: {api_key} | Model: {request.model} | Messages: {redacted_messages}")

    try:
        # Validate that the requested model is available
        if request.model not in Blackbox.models and request.model not in Blackbox.model_aliases:
            logger.warning(f"Attempt to use unavailable model: {request.model}")
            raise HTTPException(status_code=400, detail="Requested model is not available. | NiansuhAI")

        # Process the request with actual message content, but don't log it
        async_generator = Blackbox.create_async_generator(
            model=request.model,
            messages=[{"role": msg.role, "content": msg.content} for msg in request.messages],  # Actual message content used here
            image=None,
            image_name=None,
            webSearchMode=request.webSearchMode
        )

        if request.stream:
            async def generate():
                try:
                    async for chunk in async_generator:
                        if isinstance(chunk, ImageResponse):
                            image_markdown = f"![image]({chunk.url})"
                            response_chunk = create_response(image_markdown, request.model)
                            
                            # Store image in the database
                            image_entry = Image(
                                image_url=chunk.url,
                                description=request.messages[-1].get('content', '')
                            )
                            db.add(image_entry)
                            db.commit()
                        else:
                            response_chunk = create_response(chunk, request.model)
                        
                        yield f"data: {json.dumps(response_chunk)}\n\n"
                    
                    yield "data: [DONE]\n\n"
                except HTTPException as he:
                    error_response = {"error": he.detail}
                    yield f"data: {json.dumps(error_response)}\n\n"
                except Exception as e:
                    logger.exception("Error during streaming response generation.")
                    error_response = {"error": str(e)}
                    yield f"data: {json.dumps(error_response)}\n\n"

            return StreamingResponse(generate(), media_type="text/event-stream")
        else:
            response_content = ""
            async for chunk in async_generator:
                if isinstance(chunk, ImageResponse):
                    response_content += f"![image]({chunk.url})\n"
                    
                    # Store image in the database
                    image_entry = Image(
                        image_url=chunk.url,
                        description=request.messages[-1].get('content', '')
                    )
                    db.add(image_entry)
                    db.commit()
                else:
                    response_content += chunk

            logger.info(f"Completed non-streaming response generation for API key: {api_key} | Model: {request.model}")
            return {
                "id": f"chatcmpl-{uuid.uuid4()}",
                "object": "chat.completion",
                "created": int(datetime.now().timestamp()),
                "model": request.model,
                "choices": [
                    {
                        "message": {
                            "role": "assistant",
                            "content": response_content
                        },
                        "finish_reason": "stop",
                        "index": 0
                    }
                ],
                "usage": {
                    "prompt_tokens": sum(len(msg.content.split()) for msg in request.messages),
                    "completion_tokens": len(response_content.split()),
                    "total_tokens": sum(len(msg.content.split()) for msg in request.messages) + len(response_content.split())
                },
            }
    except ModelNotWorkingException as e:
        logger.warning(f"Model not working: {e}")
        raise HTTPException(status_code=503, detail=str(e))
    except HTTPException as he:
        logger.warning(f"HTTPException: {he.detail}")
        raise he
    except Exception as e:
        logger.exception("An unexpected error occurred while processing the chat completions request.")
        raise HTTPException(status_code=500, detail=str(e))

# Removed the /v1/completions endpoint as per user request

# Return 'about:blank' when accessing the endpoint via GET
@app.get("/v1/chat/completions")
async def chat_completions_get():
    logger.info("GET request made to /v1/chat/completions, redirecting to 'about:blank'")
    return RedirectResponse(url='about:blank')

@app.get("/v1/models")
async def get_models(req: Request):
    logger.info(f"Fetching available models")
    return {"data": [{"id": model, "object": "model"} for model in Blackbox.models]}

# Additional endpoints for better functionality
@app.get("/v1/health")
async def health_check(req: Request):
    logger.info(f"Health check requested")
    return {"status": "ok"}

@app.get("/v1/models/{model}/status")
async def model_status(model: str, req: Request):
    logger.info(f"Model status requested for '{model}'")
    if model in Blackbox.models:
        return {"model": model, "status": "available"}
    elif model in Blackbox.model_aliases and Blackbox.model_aliases[model] in Blackbox.models:
        actual_model = Blackbox.model_aliases[model]
        return {"model": actual_model, "status": "available via alias"}
    else:
        logger.warning(f"Model not found: {model}")
        raise HTTPException(status_code=404, detail="Model not found")

# Custom exception handler to match OpenAI's error format
@app.exception_handler(HTTPException)
async def http_exception_handler(request: Request, exc: HTTPException):
    logger.error(f"HTTPException: {exc.detail}")
    return JSONResponse(
        status_code=exc.status_code,
        content={
            "error": {
                "message": exc.detail,
                "type": "invalid_request_error",
                "param": None,
                "code": None
            }
        },
    )

# New endpoint: /v1/tokenizer to calculate token counts
class TokenizerRequest(BaseModel):
    text: str

@app.post("/v1/tokenizer")
async def tokenizer(request: TokenizerRequest, req: Request):
    text = request.text
    token_count = len(text.split())
    logger.info(f"Tokenizer called | Tokens: {token_count}")
    return {"text": text, "tokens": token_count}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)