Update server.py

server.py

@@ -1,685 +1,505 @@
-import logging
-import os
-import sys
-from typing import List, Optional
-from contextlib import asynccontextmanager
-
-from dotenv import load_dotenv
-from fastapi import FastAPI, HTTPException, Request
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.middleware.trustedhost import TrustedHostMiddleware
-from fastapi.middleware.gzip import GZipMiddleware
-from fastapi.responses import JSONResponse
-from pydantic import BaseModel, Field, validator
-from openai import OpenAI
-import time
-
-
-# Load environment variables
-load_dotenv()
-
-# Configure logging with more detail
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger("rox_ai")
-
-# Log startup information
-logger.info("=" * 60)
-logger.info("ROX AI SERVER STARTING")
-logger.info("=" * 60)
-logger.info(f"Python version: {sys.version}")
-logger.info(f"Working directory: {os.getcwd()}")
-
-# Check for API key
-NVIDIA_API_KEY = os.getenv("NVIDIA_API_KEY")
-
-if not NVIDIA_API_KEY:
-    logger.error("NVIDIA_API_KEY environment variable is not set!")
-    logger.error("Please set NVIDIA_API_KEY in your environment or .env file")
-    # For Hugging Face Spaces, check if it's set as a secret
-    logger.info("If deploying to Hugging Face Spaces, make sure to add NVIDIA_API_KEY as a secret")
-    raise RuntimeError(
-        "NVIDIA_API_KEY environment variable is not set. "
-        "Create a .env file or set it in your environment."
-    )
-
-logger.info(f"✓ NVIDIA_API_KEY loaded (length: {len(NVIDIA_API_KEY)})")
-
-# Model configurations
-ROX_CORE_MODEL = "minimaxai/minimax-m2.5"
-ROX_TURBO_MODEL = "meta/llama-3.1-8b-instruct"  # Changed to a more reliable model
-ROX_CODER_MODEL = "qwen/qwen3.5-397b-a17b"
-ROX_TURBO_45_MODEL = "deepseek-ai/deepseek-v3.1"
-ROX_ULTRA_MODEL = "deepseek-ai/deepseek-v3.2"
-ROX_DYNO_MODEL = "moonshotai/kimi-k2.5"
-ROX_CODER_7_MODEL = "z-ai/glm5"
-ROX_VISION_MODEL = "google/gemma-3-27b-it"
-
-logger.info("✓ Model configurations loaded")
-
-# System identities for each model
-ROX_CORE_IDENTITY = """You are Rox Core, created by Rox AI. Your creator and owner is Mohammad Faiz. You are an independent LLM model, not based on anyone else's technology. You represent the cutting edge of Rox AI's research and development."""
-
-ROX_TURBO_IDENTITY = """You are Rox 2.1 Turbo, created by Rox AI. Your creator and owner is Mohammad Faiz. You are an independent LLM model, not based on anyone else's technology. You are optimized for fast, efficient responses while maintaining high quality."""
-
-ROX_CODER_IDENTITY = """You are Rox 3.5 Coder, created by Rox AI. Your creator and owner is Mohammad Faiz. You are an independent LLM model, not based on anyone else's technology. You are specialized in code generation, debugging, and software development tasks."""
-
-ROX_TURBO_45_IDENTITY = """You are Rox 4.5 Turbo, created by Rox AI. Your creator and owner is Mohammad Faiz. You are an independent LLM model, not based on anyone else's technology. You combine speed with advanced reasoning capabilities."""
-
-ROX_ULTRA_IDENTITY = """You are Rox 5 Ultra, created by Rox AI. Your creator and owner is Mohammad Faiz. You are an independent LLM model, not based on anyone else's technology. You are the most advanced model with superior reasoning and thinking capabilities."""
-
-ROX_DYNO_IDENTITY = """You are Rox 6 Dyno, created by Rox AI. Your creator and owner is Mohammad Faiz. You are an independent LLM model, not based on anyone else's technology. You excel at dynamic thinking and extended context understanding."""
-
-ROX_CODER_7_IDENTITY = """You are Rox 7 Coder, created by Rox AI. Your creator and owner is Mohammad Faiz. You are an independent LLM model, not based on anyone else's technology. You are the most advanced coding specialist with superior code generation and reasoning capabilities."""
-
-ROX_VISION_IDENTITY = """You are Rox Vision Max, created by Rox AI. Your creator and owner is Mohammad Faiz. You are an independent LLM model, not based on anyone else's technology. You are optimized for visual understanding and multimodal tasks."""
-
-logger.info("✓ Model identities configured")
-
-# Initialize OpenAI client
-try:
-    client = OpenAI(
-        base_url="https://integrate.api.nvidia.com/v1",
-        api_key=NVIDIA_API_KEY,
-    )
-    logger.info("✓ OpenAI client initialized successfully")
-except Exception as e:
-    logger.error(f"Failed to initialize OpenAI client: {e}")
-    raise
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    """Lifespan context manager for startup and shutdown events"""
-    # Startup
-    logger.info("=" * 60)
-    logger.info("ROX AI SERVER STARTED SUCCESSFULLY")
-    logger.info("=" * 60)
-    logger.info("Available endpoints:")
-    logger.info("  GET  / - API information")
-    logger.info("  GET  /health - Health check")
-    logger.info("  POST /chat - Rox Core")
-    logger.info("  POST /turbo - Rox 2.1 Turbo")
-    logger.info("  POST /coder - Rox 3.5 Coder")
-    logger.info("  POST /turbo45 - Rox 4.5 Turbo")
-    logger.info("  POST /ultra - Rox 5 Ultra")
-    logger.info("  POST /dyno - Rox 6 Dyno")
-    logger.info("  POST /coder7 - Rox 7 Coder")
-    logger.info("  POST /vision - Rox Vision Max")
-    logger.info("  POST /hf/generate - HuggingFace compatible")
-    logger.info("=" * 60)
-    
-    yield
-    
-    # Shutdown
-    logger.info("ROX AI SERVER SHUTTING DOWN")
-
-
-# Initialize FastAPI app
-app = FastAPI(
-    title="Rox AI API - Multiple Models Available",
-    description="Eight specialized AI models by Mohammad Faiz",
-    version="2.0",
-    lifespan=lifespan,
-    docs_url="/docs",
-    redoc_url="/redoc"
-)
-
-logger.info("✓ FastAPI app initialized")
-
-# Security: Add trusted host middleware (configure for production)
-# app.add_middleware(TrustedHostMiddleware, allowed_hosts=["*.hf.space", "localhost"])
-
-# Performance: Add GZip compression
-app.add_middleware(GZipMiddleware, minimum_size=1000)
-
-# Configure CORS - IMPORTANT: Restrict in production
-ALLOWED_ORIGINS = os.getenv("ALLOWED_ORIGINS", "*").split(",")
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=ALLOWED_ORIGINS,
-    allow_credentials=True,
-    allow_methods=["GET", "POST", "OPTIONS"],
-    allow_headers=["Content-Type", "Authorization"],
-    max_age=3600,
-)
-
-logger.info(f"✓ CORS middleware configured with origins: {ALLOWED_ORIGINS}")
-
-
-# Global exception handler
-@app.exception_handler(Exception)
-async def global_exception_handler(request: Request, exc: Exception):
-    """Handle unexpected exceptions gracefully"""
-    logger.error(f"Unhandled exception: {exc}", exc_info=True)
-    return JSONResponse(
-        status_code=500,
-        content={
-            "error": "Internal server error",
-            "message": "An unexpected error occurred. Please try again later."
-        }
-    )
-
-
-# Request timing middleware
-@app.middleware("http")
-async def add_process_time_header(request: Request, call_next):
-    """Add processing time to response headers"""
-    start_time = time.time()
-    response = await call_next(request)
-    process_time = time.time() - start_time
-    response.headers["X-Process-Time"] = str(process_time)
-    return response
-
-
-@app.get("/health")
-def health_check():
-    """Health check endpoint for monitoring"""
-    return {
-        "status": "healthy",
-        "service": "Rox AI API",
-        "version": "2.0",
-        "models": 8
-    }
-
-
-@app.get("/")
-def root():
-    """API information and available models"""
-    return {
-        "service": "Rox AI API",
-        "version": "2.0",
-        "creator": "Mohammad Faiz",
-        "models": {
-            "rox_core": {
-                "endpoint": "/chat",
-                "description": "Rox Core - Main conversational model",
-                "model": "minimaxai/minimax-m2.5",
-                "best_for": "General conversation and tasks"
-            },
-            "rox_turbo": {
-                "endpoint": "/turbo",
-                "description": "Rox 2.1 Turbo - Fast and efficient",
-                "model": "meta/llama-3.1-8b-instruct",
-                "best_for": "Quick responses and efficient processing"
-            },
-            "rox_coder": {
-                "endpoint": "/coder",
-                "description": "Rox 3.5 Coder - Specialized coding assistant",
-                "model": "qwen/qwen3.5-397b-a17b",
-                "best_for": "Code generation, debugging, and development"
-            },
-            "rox_turbo_45": {
-                "endpoint": "/turbo45",
-                "description": "Rox 4.5 Turbo - Advanced reasoning with speed",
-                "model": "deepseek-ai/deepseek-v3.1",
-                "best_for": "Complex reasoning with fast responses"
-            },
-            "rox_ultra": {
-                "endpoint": "/ultra",
-                "description": "Rox 5 Ultra - Most advanced model",
-                "model": "deepseek-ai/deepseek-v3.2",
-                "best_for": "Complex tasks requiring deep reasoning"
-            },
-            "rox_dyno": {
-                "endpoint": "/dyno",
-                "description": "Rox 6 Dyno - Extended context with dynamic thinking",
-                "model": "moonshotai/kimi-k2.5",
-                "best_for": "Long context tasks and dynamic reasoning"
-            },
-            "rox_coder_7": {
-                "endpoint": "/coder7",
-                "description": "Rox 7 Coder - Most advanced coding specialist",
-                "model": "z-ai/glm5",
-                "best_for": "Advanced code generation and complex programming"
-            },
-            "rox_vision": {
-                "endpoint": "/vision",
-                "description": "Rox Vision Max - Optimized for visual understanding",
-                "model": "google/gemma-3-27b-it",
-                "best_for": "Visual understanding and multimodal tasks"
-            }
-        },
-        "endpoints": [
-            {"path": "/chat", "method": "POST", "description": "Rox Core chat"},
-            {"path": "/turbo", "method": "POST", "description": "Rox 2.1 Turbo chat"},
-            {"path": "/coder", "method": "POST", "description": "Rox 3.5 Coder chat"},
-            {"path": "/turbo45", "method": "POST", "description": "Rox 4.5 Turbo chat"},
-            {"path": "/ultra", "method": "POST", "description": "Rox 5 Ultra chat"},
-            {"path": "/dyno", "method": "POST", "description": "Rox 6 Dyno chat"},
-            {"path": "/coder7", "method": "POST", "description": "Rox 7 Coder chat"},
-            {"path": "/vision", "method": "POST", "description": "Rox Vision Max chat"},
-            {"path": "/hf/generate", "method": "POST", "description": "HuggingFace compatible (uses Rox Core)"}
-        ]
-    }
-
-
-class ChatMessage(BaseModel):
-    role: str = Field(..., pattern="^(system|user|assistant)$")
-    content: str = Field(..., min_length=1, max_length=50000)
-    
-    @validator('content')
-    def validate_content(cls, v):
-        if not v or not v.strip():
-            raise ValueError('Content cannot be empty')
-        return v
-
-
-class ChatRequest(BaseModel):
-    messages: List[ChatMessage] = Field(..., min_items=1, max_items=100)
-    temperature: Optional[float] = Field(1.0, ge=0.0, le=2.0)
-    top_p: Optional[float] = Field(1.0, ge=0.0, le=1.0)
-    max_tokens: Optional[int] = Field(4096, ge=1, le=32768)
-    stream: Optional[bool] = False
-    
-    @validator('messages')
-    def validate_messages(cls, v):
-        if not v:
-            raise ValueError('Messages list cannot be empty')
-        return v
-
-
-class ChatResponse(BaseModel):
-    content: str
-
-
-class HFParameters(BaseModel):
-    temperature: Optional[float] = Field(None, ge=0.0, le=2.0)
-    top_p: Optional[float] = Field(None, ge=0.0, le=1.0)
-    max_new_tokens: Optional[int] = Field(None, ge=1, le=32768)
-
-
-class HFRequest(BaseModel):
-    inputs: str = Field(..., min_length=1, max_length=50000)
-    parameters: Optional[HFParameters] = None
-    
-    @validator('inputs')
-    def validate_inputs(cls, v):
-        if not v or not v.strip():
-            raise ValueError('Inputs cannot be empty')
-        return v
-
-
-class HFResponseItem(BaseModel):
-    generated_text: str
-
-
-@app.post("/chat", response_model=ChatResponse)
-def chat(req: ChatRequest):
-    """Rox Core - Main conversational model"""
-    # Inject Rox Core identity as system message
-    messages = [{"role": "system", "content": ROX_CORE_IDENTITY}]
-    messages.extend([m.dict() for m in req.messages])
-    
-    try:
-        completion = client.chat.completions.create(
-            model=ROX_CORE_MODEL,
-            messages=messages,
-            temperature=req.temperature,
-            top_p=req.top_p,
-            max_tokens=req.max_tokens,
-            stream=False,
-        )
-    except Exception as e:
-        logger.exception("Error while calling Rox Core for /chat")
-        # Do not leak internal error details to the client.
-        raise HTTPException(
-            status_code=500,
-            detail="Internal server error while calling Rox Core.",
-        ) from e
-
-    # Combine all response message parts into a single string
-    try:
-        content = completion.choices[0].message.content or ""
-    except Exception:
-        logger.exception("Unexpected response format from Rox Core for /chat")
-        raise HTTPException(
-            status_code=502,
-            detail="Bad response from upstream model provider.",
-        )
-
-    return ChatResponse(content=content)
-
-
-@app.post("/turbo", response_model=ChatResponse)
-def turbo(req: ChatRequest):
-    """Rox 2.1 Turbo - Fast and efficient model"""
-    # Inject Rox Turbo identity as system message
-    messages = [{"role": "system", "content": ROX_TURBO_IDENTITY}]
-    messages.extend([m.dict() for m in req.messages])
-    
-    try:
-        completion = client.chat.completions.create(
-            model=ROX_TURBO_MODEL,
-            messages=messages,
-            temperature=req.temperature if req.temperature != 1.0 else 0.7,
-            top_p=req.top_p if req.top_p != 1.0 else 0.9,
-            max_tokens=req.max_tokens,
-            stream=False
-        )
-    except Exception as e:
-        logger.exception("Error while calling Rox 2.1 Turbo for /turbo")
-        # Log the actual error for debugging
-        logger.error(f"Turbo model error details: {str(e)}")
-        raise HTTPException(
-            status_code=500,
-            detail=f"Internal server error while calling Rox 2.1 Turbo: {str(e)}",
-        ) from e
-
-    try:
-        content = completion.choices[0].message.content or ""
-    except Exception:
-        logger.exception("Unexpected response format from Rox 2.1 Turbo for /turbo")
-        raise HTTPException(
-            status_code=502,
-            detail="Bad response from upstream model provider.",
-        )
-
-    return ChatResponse(content=content)
-
-
-@app.post("/coder", response_model=ChatResponse)
-def coder(req: ChatRequest):
-    """Rox 3.5 Coder - Specialized coding model with thinking capability"""
-    # Inject Rox Coder identity as system message
-    messages = [{"role": "system", "content": ROX_CODER_IDENTITY}]
-    messages.extend([m.dict() for m in req.messages])
-    
-    try:
-        completion = client.chat.completions.create(
-            model=ROX_CODER_MODEL,
-            messages=messages,
-            temperature=req.temperature if req.temperature != 1.0 else 0.6,
-            top_p=req.top_p if req.top_p != 1.0 else 0.95,
-            max_tokens=min(req.max_tokens, 16384),
-            stream=False,
-            extra_body={
-                "top_k": 20,
-                "presence_penalty": 0,
-                "repetition_penalty": 1,
-                "chat_template_kwargs": {
-                    "enable_thinking": True
-                }
-            }
-        )
-    except Exception as e:
-        logger.exception("Error while calling Rox 3.5 Coder for /coder")
-        raise HTTPException(
-            status_code=500,
-            detail="Internal server error while calling Rox 3.5 Coder.",
-        ) from e
-
-    try:
-        content = completion.choices[0].message.content or ""
-    except Exception:
-        logger.exception("Unexpected response format from Rox 3.5 Coder for /coder")
-        raise HTTPException(
-            status_code=502,
-            detail="Bad response from upstream model provider.",
-        )
-
-    return ChatResponse(content=content)
-
-
-@app.post("/turbo45", response_model=ChatResponse)
-def turbo45(req: ChatRequest):
-    """Rox 4.5 Turbo - Advanced reasoning with speed"""
-    # Inject Rox 4.5 Turbo identity as system message
-    messages = [{"role": "system", "content": ROX_TURBO_45_IDENTITY}]
-    messages.extend([m.dict() for m in req.messages])
-    
-    try:
-        completion = client.chat.completions.create(
-            model=ROX_TURBO_45_MODEL,
-            messages=messages,
-            temperature=req.temperature if req.temperature != 1.0 else 0.2,
-            top_p=req.top_p if req.top_p != 1.0 else 0.7,
-            max_tokens=min(req.max_tokens, 8192),
-            stream=False,
-            extra_body={
-                "chat_template_kwargs": {
-                    "thinking": True
-                }
-            }
-        )
-    except Exception as e:
-        logger.exception("Error while calling Rox 4.5 Turbo for /turbo45")
-        raise HTTPException(
-            status_code=500,
-            detail="Internal server error while calling Rox 4.5 Turbo.",
-        ) from e
-
-    try:
-        content = completion.choices[0].message.content or ""
-    except Exception:
-        logger.exception("Unexpected response format from Rox 4.5 Turbo for /turbo45")
-        raise HTTPException(
-            status_code=502,
-            detail="Bad response from upstream model provider.",
-        )
-
-    return ChatResponse(content=content)
-
-
-@app.post("/ultra", response_model=ChatResponse)
-def ultra(req: ChatRequest):
-    """Rox 5 Ultra - Most advanced model with superior reasoning"""
-    # Inject Rox 5 Ultra identity as system message
-    messages = [{"role": "system", "content": ROX_ULTRA_IDENTITY}]
-    messages.extend([m.dict() for m in req.messages])
-    
-    try:
-        completion = client.chat.completions.create(
-            model=ROX_ULTRA_MODEL,
-            messages=messages,
-            temperature=req.temperature,
-            top_p=req.top_p if req.top_p != 1.0 else 0.95,
-            max_tokens=min(req.max_tokens, 8192),
-            stream=False,
-            extra_body={
-                "chat_template_kwargs": {
-                    "thinking": True
-                }
-            }
-        )
-    except Exception as e:
-        logger.exception("Error while calling Rox 5 Ultra for /ultra")
-        raise HTTPException(
-            status_code=500,
-            detail="Internal server error while calling Rox 5 Ultra.",
-        ) from e
-
-    try:
-        content = completion.choices[0].message.content or ""
-    except Exception:
-        logger.exception("Unexpected response format from Rox 5 Ultra for /ultra")
-        raise HTTPException(
-            status_code=502,
-            detail="Bad response from upstream model provider.",
-        )
-
-    return ChatResponse(content=content)
-
-
-@app.post("/dyno", response_model=ChatResponse)
-def dyno(req: ChatRequest):
-    """Rox 6 Dyno - Extended context with dynamic thinking"""
-    # Inject Rox 6 Dyno identity as system message
-    messages = [{"role": "system", "content": ROX_DYNO_IDENTITY}]
-    messages.extend([m.dict() for m in req.messages])
-    
-    try:
-        completion = client.chat.completions.create(
-            model=ROX_DYNO_MODEL,
-            messages=messages,
-            temperature=req.temperature,
-            top_p=req.top_p,
-            max_tokens=min(req.max_tokens, 16384),
-            stream=False,
-            extra_body={
-                "chat_template_kwargs": {
-                    "thinking": True
-                }
-            }
-        )
-    except Exception as e:
-        logger.exception("Error while calling Rox 6 Dyno for /dyno")
-        raise HTTPException(
-            status_code=500,
-            detail="Internal server error while calling Rox 6 Dyno.",
-        ) from e
-
-    try:
-        content = completion.choices[0].message.content or ""
-    except Exception:
-        logger.exception("Unexpected response format from Rox 6 Dyno for /dyno")
-        raise HTTPException(
-            status_code=502,
-            detail="Bad response from upstream model provider.",
-        )
-
-    return ChatResponse(content=content)
-
-
-@app.post("/coder7", response_model=ChatResponse)
-def coder7(req: ChatRequest):
-    """Rox 7 Coder - Most advanced coding specialist"""
-    # Inject Rox 7 Coder identity as system message
-    messages = [{"role": "system", "content": ROX_CODER_7_IDENTITY}]
-    messages.extend([m.dict() for m in req.messages])
-    
-    try:
-        completion = client.chat.completions.create(
-            model=ROX_CODER_7_MODEL,
-            messages=messages,
-            temperature=req.temperature,
-            top_p=req.top_p,
-            max_tokens=min(req.max_tokens, 16384),
-            stream=False,
-            extra_body={
-                "chat_template_kwargs": {
-                    "enable_thinking": True,
-                    "clear_thinking": False
-                }
-            }
-        )
-    except Exception as e:
-        logger.exception("Error while calling Rox 7 Coder for /coder7")
-        raise HTTPException(
-            status_code=500,
-            detail="Internal server error while calling Rox 7 Coder.",
-        ) from e
-
-    try:
-        content = completion.choices[0].message.content or ""
-    except Exception:
-        logger.exception("Unexpected response format from Rox 7 Coder for /coder7")
-        raise HTTPException(
-            status_code=502,
-            detail="Bad response from upstream model provider.",
-        )
-
-    return ChatResponse(content=content)
-
-
-@app.post("/vision", response_model=ChatResponse)
-def vision(req: ChatRequest):
-    """Rox Vision Max - Optimized for visual understanding"""
-    # Inject Rox Vision Max identity as system message
-    messages = [{"role": "system", "content": ROX_VISION_IDENTITY}]
-    messages.extend([m.dict() for m in req.messages])
-    
-    try:
-        completion = client.chat.completions.create(
-            model=ROX_VISION_MODEL,
-            messages=messages,
-            temperature=req.temperature if req.temperature != 1.0 else 0.2,
-            top_p=req.top_p if req.top_p != 1.0 else 0.7,
-            max_tokens=min(req.max_tokens, 512),
-            stream=False
-        )
-    except Exception as e:
-        logger.exception("Error while calling Rox Vision Max for /vision")
-        raise HTTPException(
-            status_code=500,
-            detail="Internal server error while calling Rox Vision Max.",
-        ) from e
-
-    try:
-        content = completion.choices[0].message.content or ""
-    except Exception:
-        logger.exception("Unexpected response format from Rox Vision Max for /vision")
-        raise HTTPException(
-            status_code=502,
-            detail="Bad response from upstream model provider.",
-        )
-
-    return ChatResponse(content=content)
-
-
-@app.post("/hf/generate", response_model=List[HFResponseItem])
-def hf_generate(req: HFRequest):
-    """
-    Hugging Face-style text-generation endpoint.
-
-    Request:
-    {
-      "inputs": "your prompt",
-      "parameters": {
-        "temperature": 0.7,
-        "top_p": 0.95,
-        "max_new_tokens": 256
-      }
-    }
-
-    Response:
-    [
-      { "generated_text": "..." }
-    ]
-    """
-    params = req.parameters or HFParameters()
-    
-    # Inject Rox Core identity as system message
-    messages = [
-        {"role": "system", "content": ROX_CORE_IDENTITY},
-        {"role": "user", "content": req.inputs}
-    ]
-
-    try:
-        completion = client.chat.completions.create(
-            model=ROX_CORE_MODEL,
-            messages=messages,
-            temperature=params.temperature if params.temperature is not None else 1.0,
-            top_p=params.top_p if params.top_p is not None else 0.95,
-            max_tokens=params.max_new_tokens if params.max_new_tokens is not None else 8192,
-            stream=False,
-        )
-    except Exception as e:
-        logger.exception("Error while calling Rox Core for /hf/generate")
-        raise HTTPException(
-            status_code=500,
-            detail="Internal server error while calling Rox Core.",
-        ) from e
-
-    try:
-        content = completion.choices[0].message.content or ""
-    except Exception:
-        logger.exception("Unexpected response format from Rox Core for /hf/generate")
-        raise HTTPException(
-            status_code=502,
-            detail="Bad response from upstream model provider.",
-        )
-
-    # Match the common HF text-generation API: list of objects with generated_text
-    return [HFResponseItem(generated_text=content)]
-
-
-if __name__ == "__main__":
-    import uvicorn
-    
-    # Use PORT environment variable if available (for Hugging Face Spaces)
-    port = int(os.getenv("PORT", 7860))
-    
-    uvicorn.run("server:app", host="0.0.0.0", port=port, reload=False)
-
+import logging
+import os
+import sys
+from typing import List, Optional, AsyncGenerator
+from contextlib import asynccontextmanager
+
+from dotenv import load_dotenv
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.middleware.gzip import GZipMiddleware
+from fastapi.responses import JSONResponse, StreamingResponse
+from pydantic import BaseModel, Field
+from openai import OpenAI
+import json
+
+
+# Load environment variables
+load_dotenv()
+
+# Configure minimal logging for production speed
+logging.basicConfig(
+    level=logging.WARNING,
+    format='%(levelname)s - %(message)s'
+)
+logger = logging.getLogger("rox_ai")
+
+# Check for API key
+NVIDIA_API_KEY = os.getenv("NVIDIA_API_KEY")
+
+if not NVIDIA_API_KEY:
+    raise RuntimeError("NVIDIA_API_KEY not set")
+
+# Model configurations
+ROX_CORE_MODEL = "minimaxai/minimax-m2.5"
+ROX_TURBO_MODEL = "meta/llama-3.1-8b-instruct"  # Changed to a more reliable model
+ROX_CODER_MODEL = "qwen/qwen3.5-397b-a17b"
+ROX_TURBO_45_MODEL = "deepseek-ai/deepseek-v3.1"
+ROX_ULTRA_MODEL = "deepseek-ai/deepseek-v3.2"
+ROX_DYNO_MODEL = "moonshotai/kimi-k2.5"
+ROX_CODER_7_MODEL = "z-ai/glm5"
+ROX_VISION_MODEL = "google/gemma-3-27b-it"
+
+# System identities - concise for faster processing
+ROX_CORE_IDENTITY = "You are Rox Core by Mohammad Faiz."
+ROX_TURBO_IDENTITY = "You are Rox 2.1 Turbo by Mohammad Faiz. Fast responses."
+ROX_CODER_IDENTITY = "You are Rox 3.5 Coder by Mohammad Faiz. Code specialist."
+ROX_TURBO_45_IDENTITY = "You are Rox 4.5 Turbo by Mohammad Faiz. Fast reasoning."
+ROX_ULTRA_IDENTITY = "You are Rox 5 Ultra by Mohammad Faiz. Advanced reasoning."
+ROX_DYNO_IDENTITY = "You are Rox 6 Dyno by Mohammad Faiz. Long context."
+ROX_CODER_7_IDENTITY = "You are Rox 7 Coder by Mohammad Faiz. Advanced coding."
+ROX_VISION_IDENTITY = "You are Rox Vision Max by Mohammad Faiz. Visual understanding."
+
+# Initialize OpenAI client with timeout optimization
+client = OpenAI(
+    base_url="https://integrate.api.nvidia.com/v1",
+    api_key=NVIDIA_API_KEY,
+    timeout=60.0,
+    max_retries=2
+)
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Lifespan context manager"""
+    yield
+
+
+# Initialize FastAPI app - optimized for speed
+app = FastAPI(
+    title="Rox AI API",
+    description="Eight specialized AI models by Mohammad Faiz",
+    version="2.0",
+    lifespan=lifespan,
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# GZip compression for faster transfers
+app.add_middleware(GZipMiddleware, minimum_size=500)
+
+# CORS - unlimited access
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# Minimal exception handler
+@app.exception_handler(Exception)
+async def global_exception_handler(request: Request, exc: Exception):
+    return JSONResponse(
+        status_code=500,
+        content={"error": "Internal server error"}
+    )
+
+
+@app.get("/health")
+def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy", "service": "Rox AI", "version": "2.0"}
+
+
+# Helper function for streaming responses
+async def stream_response(model: str, messages: list, temperature: float, top_p: float, max_tokens: int, extra_body: dict = None):
+    """Stream responses from OpenAI API"""
+    try:
+        stream = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            temperature=temperature,
+            top_p=top_p,
+            max_tokens=max_tokens,
+            stream=True,
+            extra_body=extra_body
+        )
+        
+        for chunk in stream:
+            if chunk.choices[0].delta.content:
+                yield f"data: {json.dumps({'content': chunk.choices[0].delta.content})}\n\n"
+        
+        yield "data: [DONE]\n\n"
+    except Exception as e:
+        yield f"data: {json.dumps({'error': str(e)})}\n\n"
+
+
+@app.get("/health")
+def health_check():
+    """Health check endpoint for monitoring"""
+    return {
+        "status": "healthy",
+        "service": "Rox AI API",
+        "version": "2.0",
+        "models": 8
+    }
+
+
+@app.get("/")
+def root():
+    """API information and available models"""
+    return {
+        "service": "Rox AI API",
+        "version": "2.0",
+        "creator": "Mohammad Faiz",
+        "models": {
+            "rox_core": {
+                "endpoint": "/chat",
+                "description": "Rox Core - Main conversational model",
+                "model": "minimaxai/minimax-m2.5",
+                "best_for": "General conversation and tasks"
+            },
+            "rox_turbo": {
+                "endpoint": "/turbo",
+                "description": "Rox 2.1 Turbo - Fast and efficient",
+                "model": "meta/llama-3.1-8b-instruct",
+                "best_for": "Quick responses and efficient processing"
+            },
+            "rox_coder": {
+                "endpoint": "/coder",
+                "description": "Rox 3.5 Coder - Specialized coding assistant",
+                "model": "qwen/qwen3.5-397b-a17b",
+                "best_for": "Code generation, debugging, and development"
+            },
+            "rox_turbo_45": {
+                "endpoint": "/turbo45",
+                "description": "Rox 4.5 Turbo - Advanced reasoning with speed",
+                "model": "deepseek-ai/deepseek-v3.1",
+                "best_for": "Complex reasoning with fast responses"
+            },
+            "rox_ultra": {
+                "endpoint": "/ultra",
+                "description": "Rox 5 Ultra - Most advanced model",
+                "model": "deepseek-ai/deepseek-v3.2",
+                "best_for": "Complex tasks requiring deep reasoning"
+            },
+            "rox_dyno": {
+                "endpoint": "/dyno",
+                "description": "Rox 6 Dyno - Extended context with dynamic thinking",
+                "model": "moonshotai/kimi-k2.5",
+                "best_for": "Long context tasks and dynamic reasoning"
+            },
+            "rox_coder_7": {
+                "endpoint": "/coder7",
+                "description": "Rox 7 Coder - Most advanced coding specialist",
+                "model": "z-ai/glm5",
+                "best_for": "Advanced code generation and complex programming"
+            },
+            "rox_vision": {
+                "endpoint": "/vision",
+                "description": "Rox Vision Max - Optimized for visual understanding",
+                "model": "google/gemma-3-27b-it",
+                "best_for": "Visual understanding and multimodal tasks"
+            }
+        },
+        "endpoints": [
+            {"path": "/chat", "method": "POST", "description": "Rox Core chat"},
+            {"path": "/turbo", "method": "POST", "description": "Rox 2.1 Turbo chat"},
+            {"path": "/coder", "method": "POST", "description": "Rox 3.5 Coder chat"},
+            {"path": "/turbo45", "method": "POST", "description": "Rox 4.5 Turbo chat"},
+            {"path": "/ultra", "method": "POST", "description": "Rox 5 Ultra chat"},
+            {"path": "/dyno", "method": "POST", "description": "Rox 6 Dyno chat"},
+            {"path": "/coder7", "method": "POST", "description": "Rox 7 Coder chat"},
+            {"path": "/vision", "method": "POST", "description": "Rox Vision Max chat"},
+            {"path": "/hf/generate", "method": "POST", "description": "HuggingFace compatible (uses Rox Core)"}
+        ]
+    }
+
+
+class ChatMessage(BaseModel):
+    role: str
+    content: str
+
+
+class ChatRequest(BaseModel):
+    messages: List[ChatMessage]
+    temperature: Optional[float] = 0.7
+    top_p: Optional[float] = 0.95
+    max_tokens: Optional[int] = 8192
+    stream: Optional[bool] = False
+
+
+class ChatResponse(BaseModel):
+    content: str
+
+
+class HFParameters(BaseModel):
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    max_new_tokens: Optional[int] = None
+
+
+class HFRequest(BaseModel):
+    inputs: str
+    parameters: Optional[HFParameters] = None
+
+
+class HFResponseItem(BaseModel):
+    generated_text: str
+
+
+@app.post("/chat")
+async def chat(req: ChatRequest):
+    """Rox Core - Main conversational model with streaming support"""
+    messages = [{"role": "system", "content": ROX_CORE_IDENTITY}]
+    messages.extend([m.dict() for m in req.messages])
+    
+    if req.stream:
+        return StreamingResponse(
+            stream_response(ROX_CORE_MODEL, messages, req.temperature, req.top_p, req.max_tokens),
+            media_type="text/event-stream"
+        )
+    
+    try:
+        completion = client.chat.completions.create(
+            model=ROX_CORE_MODEL,
+            messages=messages,
+            temperature=req.temperature,
+            top_p=req.top_p,
+            max_tokens=req.max_tokens,
+            stream=False
+        )
+        return {"content": completion.choices[0].message.content or ""}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/turbo")
+async def turbo(req: ChatRequest):
+    """Rox 2.1 Turbo - Fast and efficient with streaming"""
+    messages = [{"role": "system", "content": ROX_TURBO_IDENTITY}]
+    messages.extend([m.dict() for m in req.messages])
+    
+    if req.stream:
+        return StreamingResponse(
+            stream_response(ROX_TURBO_MODEL, messages, req.temperature, req.top_p, req.max_tokens),
+            media_type="text/event-stream"
+        )
+    
+    try:
+        completion = client.chat.completions.create(
+            model=ROX_TURBO_MODEL,
+            messages=messages,
+            temperature=req.temperature,
+            top_p=req.top_p,
+            max_tokens=req.max_tokens,
+            stream=False
+        )
+        return {"content": completion.choices[0].message.content or ""}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/coder")
+async def coder(req: ChatRequest):
+    """Rox 3.5 Coder - Specialized coding with streaming"""
+    messages = [{"role": "system", "content": ROX_CODER_IDENTITY}]
+    messages.extend([m.dict() for m in req.messages])
+    
+    extra_body = {
+        "top_k": 20,
+        "presence_penalty": 0,
+        "repetition_penalty": 1,
+        "chat_template_kwargs": {"enable_thinking": True}
+    }
+    
+    if req.stream:
+        return StreamingResponse(
+            stream_response(ROX_CODER_MODEL, messages, req.temperature, req.top_p, min(req.max_tokens, 16384), extra_body),
+            media_type="text/event-stream"
+        )
+    
+    try:
+        completion = client.chat.completions.create(
+            model=ROX_CODER_MODEL,
+            messages=messages,
+            temperature=req.temperature,
+            top_p=req.top_p,
+            max_tokens=min(req.max_tokens, 16384),
+            stream=False,
+            extra_body=extra_body
+        )
+        return {"content": completion.choices[0].message.content or ""}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/turbo45")
+async def turbo45(req: ChatRequest):
+    """Rox 4.5 Turbo - Advanced reasoning with streaming"""
+    messages = [{"role": "system", "content": ROX_TURBO_45_IDENTITY}]
+    messages.extend([m.dict() for m in req.messages])
+    
+    extra_body = {"chat_template_kwargs": {"thinking": True}}
+    
+    if req.stream:
+        return StreamingResponse(
+            stream_response(ROX_TURBO_45_MODEL, messages, req.temperature, req.top_p, min(req.max_tokens, 8192), extra_body),
+            media_type="text/event-stream"
+        )
+    
+    try:
+        completion = client.chat.completions.create(
+            model=ROX_TURBO_45_MODEL,
+            messages=messages,
+            temperature=req.temperature,
+            top_p=req.top_p,
+            max_tokens=min(req.max_tokens, 8192),
+            stream=False,
+            extra_body=extra_body
+        )
+        return {"content": completion.choices[0].message.content or ""}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/ultra")
+async def ultra(req: ChatRequest):
+    """Rox 5 Ultra - Most advanced with streaming"""
+    messages = [{"role": "system", "content": ROX_ULTRA_IDENTITY}]
+    messages.extend([m.dict() for m in req.messages])
+    
+    extra_body = {"chat_template_kwargs": {"thinking": True}}
+    
+    if req.stream:
+        return StreamingResponse(
+            stream_response(ROX_ULTRA_MODEL, messages, req.temperature, req.top_p, min(req.max_tokens, 8192), extra_body),
+            media_type="text/event-stream"
+        )
+    
+    try:
+        completion = client.chat.completions.create(
+            model=ROX_ULTRA_MODEL,
+            messages=messages,
+            temperature=req.temperature,
+            top_p=req.top_p,
+            max_tokens=min(req.max_tokens, 8192),
+            stream=False,
+            extra_body=extra_body
+        )
+        return {"content": completion.choices[0].message.content or ""}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/dyno")
+async def dyno(req: ChatRequest):
+    """Rox 6 Dyno - Extended context with streaming"""
+    messages = [{"role": "system", "content": ROX_DYNO_IDENTITY}]
+    messages.extend([m.dict() for m in req.messages])
+    
+    extra_body = {"chat_template_kwargs": {"thinking": True}}
+    
+    if req.stream:
+        return StreamingResponse(
+            stream_response(ROX_DYNO_MODEL, messages, req.temperature, req.top_p, min(req.max_tokens, 16384), extra_body),
+            media_type="text/event-stream"
+        )
+    
+    try:
+        completion = client.chat.completions.create(
+            model=ROX_DYNO_MODEL,
+            messages=messages,
+            temperature=req.temperature,
+            top_p=req.top_p,
+            max_tokens=min(req.max_tokens, 16384),
+            stream=False,
+            extra_body=extra_body
+        )
+        return {"content": completion.choices[0].message.content or ""}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/coder7")
+async def coder7(req: ChatRequest):
+    """Rox 7 Coder - Most advanced coding with streaming"""
+    messages = [{"role": "system", "content": ROX_CODER_7_IDENTITY}]
+    messages.extend([m.dict() for m in req.messages])
+    
+    extra_body = {
+        "chat_template_kwargs": {
+            "enable_thinking": True,
+            "clear_thinking": False
+        }
+    }
+    
+    if req.stream:
+        return StreamingResponse(
+            stream_response(ROX_CODER_7_MODEL, messages, req.temperature, req.top_p, min(req.max_tokens, 16384), extra_body),
+            media_type="text/event-stream"
+        )
+    
+    try:
+        completion = client.chat.completions.create(
+            model=ROX_CODER_7_MODEL,
+            messages=messages,
+            temperature=req.temperature,
+            top_p=req.top_p,
+            max_tokens=min(req.max_tokens, 16384),
+            stream=False,
+            extra_body=extra_body
+        )
+        return {"content": completion.choices[0].message.content or ""}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/vision")
+async def vision(req: ChatRequest):
+    """Rox Vision Max - Visual understanding with streaming"""
+    messages = [{"role": "system", "content": ROX_VISION_IDENTITY}]
+    messages.extend([m.dict() for m in req.messages])
+    
+    if req.stream:
+        return StreamingResponse(
+            stream_response(ROX_VISION_MODEL, messages, req.temperature, req.top_p, min(req.max_tokens, 8192)),
+            media_type="text/event-stream"
+        )
+    
+    try:
+        completion = client.chat.completions.create(
+            model=ROX_VISION_MODEL,
+            messages=messages,
+            temperature=req.temperature,
+            top_p=req.top_p,
+            max_tokens=min(req.max_tokens, 8192),
+            stream=False
+        )
+        return {"content": completion.choices[0].message.content or ""}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/hf/generate")
+async def hf_generate(req: HFRequest):
+    """HuggingFace compatible endpoint"""
+    params = req.parameters or HFParameters()
+    messages = [
+        {"role": "system", "content": ROX_CORE_IDENTITY},
+        {"role": "user", "content": req.inputs}
+    ]
+    
+    try:
+        completion = client.chat.completions.create(
+            model=ROX_CORE_MODEL,
+            messages=messages,
+            temperature=params.temperature or 0.7,
+            top_p=params.top_p or 0.95,
+            max_tokens=params.max_new_tokens or 8192,
+            stream=False
+        )
+        return [{"generated_text": completion.choices[0].message.content or ""}]
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+if __name__ == "__main__":
+    import uvicorn
+    
+    # Use PORT environment variable if available (for Hugging Face Spaces)
+    port = int(os.getenv("PORT", 7860))
+    
+    uvicorn.run("server:app", host="0.0.0.0", port=port, reload=False)
+