Upload 5 files

Dockerfile

@@ -0,0 +1,28 @@
+# Use Python 3.11 slim
+FROM python:3.11-slim
+
+WORKDIR /app
+
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1
+
+# System deps for building wheels if needed
+RUN apt-get update && apt-get install -y \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python deps
+COPY requirements.txt ./
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy app
+COPY . .
+
+# Hugging Face Spaces expects port 7860
+EXPOSE 7860
+
+# Start server
+CMD ["uvicorn", "blackbox_server:app", "--host", "0.0.0.0", "--port", "7860"]
+
+

blackbox_server.py

@@ -0,0 +1,487 @@
+#!/usr/bin/env python3
+"""
+Blackbox.ai Reverse OpenAI-Compatible API Server
+
+This server accepts OpenAI-compatible Chat Completions requests and forwards them
+to Blackbox.ai's chat endpoint using the exact required payload structure and headers.
+It streams responses back as OpenAI-style SSE chunks or returns a non-streaming
+OpenAI-compatible response.
+"""
+import json
+import time
+import uuid
+import logging
+import requests
+from typing import List, Dict, Any, Optional, Union, AsyncGenerator
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse, JSONResponse
+from pydantic import BaseModel, Field
+
+try:
+    from .config import (
+        BLACKBOX_HEADERS,
+        BLACKBOX_COOKIES_STRING,
+        MODEL_MAPPING,
+        SERVER_CONFIG,
+        BLACKBOX_VALIDATED,
+        BLACKBOX_STATIC_SESSION,
+        BLACKBOX_STATIC_SUBSCRIPTION,
+        BLACKBOX_STATIC_BASE_FIELDS,
+    )
+except ImportError:
+    # Allow running as a module or from root
+    try:
+        from config import (
+            BLACKBOX_HEADERS,
+            BLACKBOX_COOKIES_STRING,
+            MODEL_MAPPING,
+            SERVER_CONFIG,
+            BLACKBOX_VALIDATED,
+            BLACKBOX_STATIC_SESSION,
+            BLACKBOX_STATIC_SUBSCRIPTION,
+            BLACKBOX_STATIC_BASE_FIELDS,
+        )
+    except ImportError:
+        raise
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+BLACKBOX_CHAT_URL = "https://www.blackbox.ai/api/chat"
+REQUEST_TIMEOUT = 120
+
+
+# ===== OpenAI-compatible Pydantic models =====
+class OpenAIMessage(BaseModel):
+    role: str = Field(description="Role: system, user, assistant, function, or tool")
+    content: Optional[Union[str, List[Dict[str, Any]]]] = Field(None, description="Message content")
+    name: Optional[str] = None
+    function_call: Optional[Dict[str, Any]] = None
+    tool_calls: Optional[List[Dict[str, Any]]] = None
+    tool_call_id: Optional[str] = None
+
+    def get_text(self) -> str:
+        if isinstance(self.content, str):
+            return self.content
+        if isinstance(self.content, list):
+            text_parts: List[str] = []
+            for item in self.content:
+                if isinstance(item, dict):
+                    if item.get("type") == "text":
+                        text_parts.append(item.get("text", ""))
+                    elif item.get("type") == "image_url":
+                        text_parts.append("[Image]")
+            return "".join(text_parts)
+        return str(self.content) if self.content is not None else ""
+
+    class Config:
+        extra = "allow"
+
+
+class OpenAIFunction(BaseModel):
+    name: str
+    description: Optional[str] = None
+    parameters: Optional[Dict[str, Any]] = None
+
+    class Config:
+        extra = "allow"
+
+
+class OpenAITool(BaseModel):
+    type: str = Field(default="function")
+    function: Optional[OpenAIFunction] = None
+
+    class Config:
+        extra = "allow"
+
+
+class OpenAIChatRequest(BaseModel):
+    model: str = Field(..., description="OpenAI model name")
+    messages: List[OpenAIMessage]
+    max_tokens: Optional[int] = None
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    n: Optional[int] = 1
+    stream: Optional[bool] = False
+    stop: Optional[Union[str, List[str]]] = None
+    presence_penalty: Optional[float] = None
+    frequency_penalty: Optional[float] = None
+    logit_bias: Optional[Dict[str, float]] = None
+    user: Optional[str] = None
+    tools: Optional[List[OpenAITool]] = None
+    tool_choice: Optional[Union[str, Dict[str, Any]]] = None
+    functions: Optional[List[OpenAIFunction]] = None
+    function_call: Optional[Union[str, Dict[str, Any]]] = None
+
+    class Config:
+        extra = "allow"
+
+
+class OpenAIChoice(BaseModel):
+    index: int = 0
+    message: Dict[str, Any]
+    finish_reason: Optional[str] = None
+
+
+class OpenAIChatResponse(BaseModel):
+    id: str
+    object: str = "chat.completion"
+    created: int
+    model: str
+    choices: List[OpenAIChoice]
+    usage: Optional[Dict[str, int]] = None
+
+
+class OpenAIStreamChoice(BaseModel):
+    index: int = 0
+    delta: Dict[str, Any]
+    finish_reason: Optional[str] = None
+
+
+class OpenAIStreamChunk(BaseModel):
+    id: str
+    object: str = "chat.completion.chunk"
+    created: int
+    model: str
+    choices: List[OpenAIStreamChoice]
+
+
+def _parse_cookie_string(cookie_string: str) -> Dict[str, str]:
+    cookies: Dict[str, str] = {}
+    if not cookie_string:
+        return cookies
+    parts = [p.strip() for p in cookie_string.split(";") if p.strip()]
+    for part in parts:
+        if "=" in part:
+            name, value = part.split("=", 1)
+            cookies[name.strip()] = value.strip()
+    return cookies
+
+
+def _blackbox_headers() -> Dict[str, str]:
+    # Return a copy so we can safely mutate per-request if needed
+    return dict(BLACKBOX_HEADERS)
+
+
+def _build_blackbox_payload(openai_req: OpenAIChatRequest) -> Dict[str, Any]:
+    """
+    Build the exact Blackbox payload including all fields from the provided curl.
+    We only map OpenAI messages/model into the appropriate fields and keep all other
+    fields present so the upstream accepts the request.
+    """
+    # Generate short ids
+    def short_id() -> str:
+        return uuid.uuid4().hex[:7]
+
+    # Use user-provided top-level id if supplied as an extra field
+    extra_top = getattr(openai_req, "model_extra", {}) or {}
+    req_id = str(extra_top.get("id")) if extra_top.get("id") else short_id()
+
+    # Map OpenAI messages to Blackbox format (id, content, role)
+    bb_messages: List[Dict[str, Any]] = []
+    first = True
+    for msg in openai_req.messages:
+        msg_role = str(getattr(msg, "role", "")).strip() or "user"
+        # Coerce unknown roles to 'user' to avoid upstream rejection
+        if msg_role not in {"system", "user", "assistant"}:
+            msg_role = "user"
+        msg_content = msg.get_text()
+        # Ensure minimally valid defaults to avoid 501 from upstream on malformed content
+        if not msg_content:
+            msg_content = ""
+        # Reuse provided message.id if present in extras; ensure first message id matches top-level id
+        msg_extra = getattr(msg, "model_extra", {}) or {}
+        msg_id = str(msg_extra.get("id")) if msg_extra.get("id") else (req_id if first else short_id())
+        bb_messages.append({
+            "id": msg_id,
+            "content": msg_content,
+            "role": msg_role,
+        })
+        first = False
+
+    # Determine Blackbox agent from model mapping
+    agent = MODEL_MAPPING.get(openai_req.model, MODEL_MAPPING.get("default"))
+
+    payload: Dict[str, Any] = {
+        "messages": bb_messages,
+        "agentMode": {
+            "name": agent["name"],
+            "id": agent["id"],
+            "mode": True,
+        },
+        "id": req_id,
+        # Include all base fields exactly
+        **BLACKBOX_STATIC_BASE_FIELDS,
+        # Ensure these fields reflect user-provided values
+        "maxTokens": (openai_req.max_tokens if (openai_req.max_tokens is not None and openai_req.max_tokens > 0) else 1024),
+        "userSelectedModel": agent["name"],
+        "userSelectedAgent": "VscodeAgent",
+        # Use validated token as provided
+        "validated": BLACKBOX_VALIDATED,
+        # Session/subscription from provided curl
+        "session": BLACKBOX_STATIC_SESSION,
+        "subscriptionCache": {
+            **BLACKBOX_STATIC_SUBSCRIPTION
+        },
+        # Blackbox expects streaming
+        "stream": True,
+    }
+
+    return payload
+
+
+def _extract_blackbox_text(line: str) -> Optional[str]:
+    """Try to extract textual delta from a Blackbox SSE line."""
+    # Lines may be plain or prefixed with 'data: '
+    if line.startswith("data: "):
+        data_part = line[6:].strip()
+    elif line.startswith("data:"):
+        data_part = line[5:].strip()
+    else:
+        data_part = line.strip()
+
+    if not data_part or data_part == "[DONE]":
+        return None
+
+    # Try JSON
+    try:
+        obj = json.loads(data_part)
+        # Common patterns: {"type": "response"|"delta"|..., "data"|"text"|"delta": "..."}
+        for key in ("data", "text", "delta", "output"):
+            val = obj.get(key)
+            if isinstance(val, str) and val:
+                return val
+        # Some responses nest under obj["message"]["content"] etc.
+        message = obj.get("message")
+        if isinstance(message, dict):
+            content = message.get("content")
+            if isinstance(content, str) and content:
+                return content
+    except Exception:
+        # Not JSON - possibly plain text token
+        if data_part:
+            return data_part
+    return None
+
+
+async def _stream_openai_chunks(openai_req: OpenAIChatRequest, request_id: str) -> AsyncGenerator[str, None]:
+    """Forward to Blackbox with streaming, convert to OpenAI SSE chunks."""
+    headers = _blackbox_headers()
+    cookies = _parse_cookie_string(BLACKBOX_COOKIES_STRING)
+    payload = _build_blackbox_payload(openai_req)
+
+    with requests.Session() as sess:
+        try:
+            resp = sess.post(
+                BLACKBOX_CHAT_URL,
+                headers=headers,
+                cookies=cookies,
+                json=payload,
+                stream=True,
+                timeout=REQUEST_TIMEOUT
+            )
+        except requests.RequestException as e:
+            raise HTTPException(status_code=502, detail=f"Upstream connection error: {e}")
+
+        if resp.status_code != 200:
+            detail = resp.text[:500]
+            raise HTTPException(status_code=502, detail=f"Upstream error {resp.status_code}: {detail}")
+
+        created = int(time.time())
+
+        # Initial role chunk
+        initial = OpenAIStreamChunk(
+            id=request_id,
+            created=created,
+            model=openai_req.model,
+            choices=[OpenAIStreamChoice(index=0, delta={"role": "assistant"}, finish_reason=None)]
+        )
+        yield f"data: {initial.model_dump_json()}\n\n"
+
+        for raw_line in resp.iter_lines():
+            if not raw_line:
+                continue
+            try:
+                line = raw_line.decode("utf-8", errors="ignore")
+            except Exception:
+                continue
+
+            text = _extract_blackbox_text(line)
+            if text is None:
+                continue
+
+            chunk = OpenAIStreamChunk(
+                id=request_id,
+                created=created,
+                model=openai_req.model,
+                choices=[OpenAIStreamChoice(index=0, delta={"content": text}, finish_reason=None)]
+            )
+            yield f"data: {chunk.model_dump_json()}\n\n"
+
+        # Final chunk
+        final = OpenAIStreamChunk(
+            id=request_id,
+            created=created,
+            model=openai_req.model,
+            choices=[OpenAIStreamChoice(index=0, delta={}, finish_reason="stop")]
+        )
+        yield f"data: {final.model_dump_json()}\n\n"
+        yield "data: [DONE]\n\n"
+
+
+def _complete_non_streaming(openai_req: OpenAIChatRequest) -> str:
+    """Forward to Blackbox, collect all streamed text, and return a single string."""
+    headers = _blackbox_headers()
+    cookies = _parse_cookie_string(BLACKBOX_COOKIES_STRING)
+    payload = _build_blackbox_payload(openai_req)
+    # Force stream true upstream; we will aggregate locally
+    payload["stream"] = True
+
+    with requests.Session() as sess:
+        try:
+            resp = sess.post(
+                BLACKBOX_CHAT_URL,
+                headers=headers,
+                cookies=cookies,
+                json=payload,
+                stream=True,
+                timeout=REQUEST_TIMEOUT
+            )
+        except requests.RequestException as e:
+            raise HTTPException(status_code=502, detail=f"Upstream connection error: {e}")
+
+        if resp.status_code != 200:
+            detail = resp.text[:500]
+            raise HTTPException(status_code=502, detail=f"Upstream error {resp.status_code}: {detail}")
+
+        full = []
+        for raw_line in resp.iter_lines():
+            if not raw_line:
+                continue
+            try:
+                line = raw_line.decode("utf-8", errors="ignore")
+            except Exception:
+                continue
+            text = _extract_blackbox_text(line)
+            if text:
+                full.append(text)
+        return "".join(full)
+
+
+# ===== FastAPI App =====
+app = FastAPI(
+    title="Blackbox.ai Reverse OpenAI API",
+    version="1.0.0",
+    description="OpenAI-compatible API that proxies to Blackbox.ai chat"
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/")
+async def root():
+    return {
+        "message": "Blackbox.ai Reverse OpenAI API",
+        "version": "1.0.0",
+        "status": "running",
+        "endpoints": ["/v1/chat/completions", "/v1/models", "/health"],
+    }
+
+
+@app.get("/health")
+async def health():
+    return {
+        "status": "healthy",
+        "timestamp": int(time.time()),
+        "upstream": "blackbox.ai",
+    }
+
+
+@app.get("/v1/models")
+async def list_models():
+    created = int(time.time())
+    data = []
+    # Expose mapped models (keys of MODEL_MAPPING excluding 'default')
+    for model_name in [k for k in MODEL_MAPPING.keys() if k != "default"]:
+        data.append({
+            "id": model_name,
+            "object": "model",
+            "created": created,
+            "owned_by": "blackbox",
+        })
+    if not data:
+        data.append({
+            "id": "gpt-5",
+            "object": "model",
+            "created": created,
+            "owned_by": "blackbox",
+        })
+    return {"object": "list", "data": data}
+
+
+@app.post("/v1/chat/completions")
+async def chat_completions(request: OpenAIChatRequest):
+    request_id = f"chatcmpl-{uuid.uuid4().hex[:12]}"
+    logger.info(f"[{request_id}] Chat request: model={request.model}, stream={request.stream}")
+
+    # Streamed
+    if bool(request.stream):
+        return StreamingResponse(
+            _stream_openai_chunks(request, request_id),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "X-Accel-Buffering": "no",
+                "Access-Control-Allow-Origin": "*",
+                "Access-Control-Allow-Headers": "*",
+            },
+        )
+
+    # Non-streaming
+    content = _complete_non_streaming(request)
+    created = int(time.time())
+    response = OpenAIChatResponse(
+        id=request_id,
+        created=created,
+        model=request.model,
+        choices=[OpenAIChoice(index=0, message={"role": "assistant", "content": content}, finish_reason="stop")],
+        usage={
+            "prompt_tokens": len(" ".join([m.get_text() for m in request.messages]).split()),
+            "completion_tokens": len(content.split()),
+            "total_tokens": len(" ".join([m.get_text() for m in request.messages]).split()) + len(content.split()),
+        },
+    )
+    return response
+
+
+@app.post("/v1/chat/completions/raw")
+async def raw_validator(req: Request):
+    body = await req.body()
+    try:
+        obj = json.loads(body)
+        _ = OpenAIChatRequest(**obj)
+        return {"valid": True}
+    except Exception as e:
+        return JSONResponse(status_code=422, content={"valid": False, "error": str(e)})
+
+
+if __name__ == "__main__":
+    try:
+        import uvicorn
+        host = SERVER_CONFIG.get("host", "0.0.0.0")
+        port = int(SERVER_CONFIG.get("port", 8090))
+        logger.info(f"Starting Blackbox Reverse API on {host}:{port}")
+        uvicorn.run(app, host=host, port=port, log_level="info")
+    except Exception as e:
+        logger.error(f"Failed to start server: {e}")
+
+

config.py

@@ -0,0 +1,126 @@
+# Configuration for Blackbox.ai Reverse API
+
+# Exact headers from the provided curl (values may be environment-specific; update as needed)
+BLACKBOX_HEADERS = {
+    "accept": "text/event-stream",
+    "accept-language": "en-US,en;q=0.8",
+    "accept-encoding": "gzip, deflate, br",
+    "content-type": "application/json",
+    "cache-control": "no-cache",
+    "x-requested-with": "XMLHttpRequest",
+    "origin": "https://www.blackbox.ai",
+    "priority": "u=1, i",
+    "referer": "https://www.blackbox.ai/",
+    "sec-ch-ua": '"Not;A=Brand";v="99", "Brave";v="139", "Chromium";v="139"',
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-platform": '"Windows"',
+    "sec-fetch-dest": "empty",
+    "sec-fetch-mode": "cors",
+    "sec-fetch-site": "same-origin",
+    "sec-gpc": "1",
+    "connection": "keep-alive",
+    "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36",
+}
+
+# Cookies string copied from the curl (keep exact; rotate as needed)
+# NOTE: For security, consider sourcing from environment variables.
+BLACKBOX_COOKIES_STRING = (
+    "sessionId=b64ccc84-522a-44b9-8377-90ffd899011b; intercom-id-x55eda6t=34e51fb9-a65a-4335-9c36-4c672b803c2e; "
+    "intercom-device-id-x55eda6t=99577693-78bb-4280-9ea3-180d18ec6ca7; __Host-authjs.csrf-token=e29b4390dee01e7490dabe14bae60a8e477c8739d20ba067ebb25f5e79ab61ff%7C2813747e5b5cdfd657d57b13c73f9cf2d1016fd6308f6da7bbfb7f2e3efad13b; "
+    "__Secure-authjs.callback-url=https%3A%2F%2Fwww.blackbox.ai; render_app_version_affinity=dep-d2fa0m3uibrs739mupe0; "
+    "intercom-session-x55eda6t=cjI3dFduQ2NUOEk3eEtBM3JrN2VveW9pRGdUTGFXZGphTWxIaEp0bURxZEdGcmNvQzBGdjJCRDJsOFRaSzBRVFo4VE16M3k2ZlBQNnFlbUtLZHl4NXF0Wlh0Tm5ybHJBNnNDNXoxTzR1d0U9LS1Wc0ZoL3ZIRjU1bmtNTDhMczNNR3ZnPT0=--fbbd01990ae2a547e64a92fd1abb2609ab813626; "
+    "__Secure-authjs.session-token=eyJhbGciOiJkaXIiLCJlbmMiOiJBMjU2R0NNIn0..BgcqZx4gcRJdUsPN.prubG8glk1Wvcij_gljlKT29lrn60kRF4siLxXJZ7mgBHb4F0ml-tUh-OeL1dbIyTytfSFPhky4-yOkMbrir29ieYbUwKzmFO1pvpYDb_BkD3Oe9tz02d7A1qB7ZQnXPambEMKSDSU833UbNVMye3YBX-_lGesaIMkZCrnY_zvfD76Jp51t7EX7vJWQexNGmj8rKUtLDCCMQ9UK-OmYOBU-HgVoBpY3fUHt1E31EFRWm6TYrTBmVkmp9QZ2a8REQCddF6TJH_SHtB-Cl_ZRFmlAR18tQ4D7VM24nh_C7QXj9QfPL51JKkhavx-n8cftQTOVOwYH7qFICb-hYHq-o8BwPnfZH4bwdQNsBWO6oq4WWcLJroCvocwJvLrzY7RH8s1FkGwXVRL_ZxKF2ei3RdN0W_Isw92zcmjsS2NHBwA9_KlGnOTPhkg1mfkWTF5D5Ns11EVpfcktRHMr30x_Q1AgoB0fxEnh0KWL2LroaAzK6CNbAKVBJx9lDy5NOC-83RCAItY9WAgEMFFpmbProB8UmdcRMiRUiM7f-l-gU-jqKAfZqV9xLCw.W2qJTuS_QKIDmIbTLGDIyw"
+)
+
+# Map OpenAI model names to Blackbox agent tuples {name, id}
+MODEL_MAPPING = {
+    # OpenAI GPT-5
+    "gpt-5": {"name": "openai/gpt-5-chat", "id": "GPT-5"},
+    # Anthropic Claude Opus
+    "anthropic/claude-opus-4.1": {"name": "anthropic/claude-opus-4.1", "id": "Claude Opus 4.1"},
+    "claude-opus-4.1": {"name": "anthropic/claude-opus-4.1", "id": "Claude Opus 4.1"},
+    # Fallback
+    "default": {"name": "openai/gpt-5-chat", "id": "GPT-5"},
+}
+
+# Exact validated token from the provided curl
+BLACKBOX_VALIDATED = "a38f5889-8fef-46d4-8ede-bf4668b6a9bb"
+
+# Session block from the provided curl
+BLACKBOX_STATIC_SESSION = {
+    "user": {
+        "name": "Scgaming",
+        "email": "scgaming69106@gmail.com",
+        "image": "https://lh3.googleusercontent.com/a/ACg8ocKRmB3MEWHP-MSiFqW4ci8BlhSBtijO1Bm5n_LZKQ1obC4lnA=s96-c",
+        "id": "117887095473341798642",
+    },
+    "expires": "2025-09-14T09:45:11.827Z",
+    "isNewUser": True,
+}
+
+BLACKBOX_STATIC_SUBSCRIPTION = {
+    "status": "PREMIUM",
+    "customerId": "cus_SrjMSDi5fRfu9d",
+    "expiryTimestamp": 1757840511,
+    "lastChecked": 1755248526265,
+    "isTrialSubscription": True,
+    "hasPaymentVerificationFailure": False,
+    "verificationFailureTimestamp": None,
+    "plan": "ultimate",
+    "billing": "monthly",
+}
+
+BLACKBOX_STATIC_BASE_FIELDS = {
+    "previewToken": None,
+    "userId": None,
+    "codeModelMode": True,
+    "trendingAgentMode": {},
+    "isMicMode": False,
+    "userSystemPrompt": None,
+    "playgroundTopP": None,
+    "playgroundTemperature": None,
+    "isChromeExt": False,
+    "githubToken": "",
+    "clickedAnswer2": False,
+    "clickedAnswer3": False,
+    "clickedForceWebSearch": False,
+    "visitFromDelta": False,
+    "isMemoryEnabled": False,
+    "mobileClient": False,
+    "imageGenerationMode": False,
+    "imageGenMode": "autoMode",
+    "webSearchModePrompt": False,
+    "deepSearchMode": False,
+    "domains": None,
+    "vscodeClient": False,
+    "codeInterpreterMode": False,
+    "customProfile": {
+        "name": "",
+        "occupation": "",
+        "traits": [],
+        "additionalInfo": "",
+        "enableNewChats": False,
+    },
+    "webSearchModeOption": {
+        "autoMode": True,
+        "webMode": False,
+        "offlineMode": False,
+    },
+    "isPremium": True,
+    "beastMode": False,
+    "reasoningMode": False,
+    "designerMode": False,
+    "workspaceId": "",
+    "asyncMode": False,
+    "integrations": {},
+    "isTaskPersistent": False,
+    "selectedElement": None,
+}
+
+# Server host/port
+SERVER_CONFIG = {
+    "host": "0.0.0.0",
+    "port": 8090,
+}
+
+

requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+pydantic==2.5.0
+requests==2.31.0
+orjson==3.10.7
+

start_server.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+import os
+import socket
+import uvicorn
+from blackbox_server import app
+
+try:
+    from config import SERVER_CONFIG
+except Exception:
+    SERVER_CONFIG = {"host": "0.0.0.0", "port": 8090}
+
+
+def find_free_port(start_port: int, max_tries: int = 50) -> int:
+    """Find an available TCP port starting from start_port."""
+    for port in range(start_port, start_port + max_tries):
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            try:
+                s.bind(("0.0.0.0", port))
+                return port
+            except OSError:
+                continue
+    return start_port
+
+if __name__ == "__main__":
+    host = SERVER_CONFIG.get("host", "0.0.0.0")
+    base_port = int(os.getenv("PORT") or SERVER_CONFIG.get("port", 8090))
+    port = find_free_port(base_port)
+    if port != base_port:
+        print(f"⚠️  Port {base_port} in use. Switching to free port {port}.")
+    print(f"🚀 Starting Blackbox Reverse OpenAI API Server on {host}:{port} ...")
+    uvicorn.run(app, host=host, port=port, reload=False, log_level="info")
+
+