Upload 5 files

.dockerignore

@@ -0,0 +1,20 @@
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.so
+*.egg
+*.egg-info
+dist
+build
+.env
+.venv
+venv/
+ENV/
+env/
+.git
+.gitignore
+README.md
+test_api.py
+run.bat

Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY main.py .
+COPY config.py .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

config.py

@@ -0,0 +1,29 @@
+# Model Mapping Configuration
+# Add your custom model IDs here and map them to the backend model
+
+MODEL_MAPPING = {
+    # Claude Models
+    "claude-haiku-4.5": "claude-haiku-4.5",
+    "claude-sonnet-4.5-max": "claude-haiku-4.5",
+    "claude-3-5-sonnet-20241022": "claude-haiku-4.5",
+    "claude-3-5-haiku-20241022": "claude-haiku-4.5",
+    
+    # OpenAI GPT-4 Models
+    "gpt-4": "claude-haiku-4.5",
+    "gpt-4-turbo": "claude-haiku-4.5",
+    "gpt-4-turbo-preview": "claude-haiku-4.5",
+    "gpt-4o": "claude-haiku-4.5",
+    "gpt-4o-mini": "claude-haiku-4.5",
+    
+    # OpenAI GPT-3.5 Models
+    "gpt-3.5-turbo": "claude-haiku-4.5",
+    "gpt-3.5-turbo-16k": "claude-haiku-4.5",
+    
+    # Custom aliases (add your own here)
+    "my-custom-model": "claude-haiku-4.5",
+    "fast-model": "claude-haiku-4.5",
+    "smart-model": "claude-haiku-4.5",
+}
+
+# You can add more models by editing this dictionary
+# Format: "custom-model-id": "backend-model-id"

main.py

@@ -0,0 +1,399 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import StreamingResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, ConfigDict
+from typing import List, Optional, Dict, Any, Union
+import httpx
+import json
+import uuid
+import time
+import logging
+from config import MODEL_MAPPING
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(title="Smithery AI Reverse API", version="1.0.0")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+SMITHERY_API_URL = "https://smithery.ai/api/chat"
+
+def get_backend_model(requested_model: str) -> str:
+    return MODEL_MAPPING.get(requested_model, "claude-haiku-4.5")
+SMITHERY_HEADERS = {
+    "accept": "*/*",
+    "accept-language": "en-US,en;q=0.5",
+    "content-type": "application/json",
+    "origin": "https://smithery.ai",
+    "priority": "u=1, i",
+    "referer": "https://smithery.ai/chat?mcp=@LinkupPlatform/linkup-mcp-server",
+    "sec-ch-ua": '"Chromium";v="142", "Brave";v="142", "Not_A Brand";v="99"',
+    "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",
+    "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36",
+    "Cookie": 'sb-spjawbfpwezjfmicopsl-auth-token.0=base64-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; sb-spjawbfpwezjfmicopsl-auth-token.1=XNlcl9pZCI6IjcxYjk1ZjgwLTJlMGYtNDg4Mi04YTUzLWI4ZWZmYTlhMWI2NSIsImlkZW50aXR5X2RhdGEiOnsiYXZhdGFyX3VybCI6Imh0dHBzOi8vbGgzLmdvb2dsZXVzZXJjb250ZW50LmNvbS9hL0FDZzhvY0stZDFrbUMwSEtZaHZVZ2VwU0pXbnhXZURGbHNZaUJrTnNYT21RVXFNMVVNLUc2ak09czk2LWMiLCJlbWFpbCI6ImNvc21pY2NyZWF0aW9uMTA2QGdtYWlsLmNvbSIsImVtYWlsX3ZlcmlmaWVkIjp0cnVlLCJmdWxsX25hbWUiOiJDb3NtaWMgQ3JlYXRpb25zIiwiaXNzIjoiaHR0cHM6Ly9hY2NvdW50cy5nb29nbGUuY29tIiwibmFtZSI6IkNvc21pYyBDcmVhdGlvbnMiLCJwaG9uZV92ZXJpZmllZCI6ZmFsc2UsInBpY3R1cmUiOiJodHRwczovL2xoMy5nb29nbGV1c2VyY29udGVudC5jb20vYS9BQ2c4b2NLLWQxa21DMEhLWWh2VWdlcFNKV254V2VERmxzWWlCa05zWE9tUVVxTTFVTS1HNmpNPXM5Ni1jIiwicHJvdmlkZXJfaWQiOiIxMDk4NDcxMjI2MjAzMDU3OTY5OTYiLCJzdWIiOiIxMDk4NDcxMjI2MjAzMDU3OTY5OTYifSwicHJvdmlkZXIiOiJnb29nbGUiLCJsYXN0X3NpZ25faW5fYXQiOiIyMDI1LTExLTAzVDExOjM3OjM5Ljk1NTcwOFoiLCJjcmVhdGVkX2F0IjoiMjAyNS0xMS0wM1QxMTozNzozOS45NTU3NTZaIiwidXBkYXRlZF9hdCI6IjIwMjUtMTEtMDNUMTE6Mzc6MzkuOTU1NzU2WiIsImVtYWlsIjoiY29zbWljY3JlYXRpb24xMDZAZ21haWwuY29tIn1dLCJjcmVhdGVkX2F0IjoiMjAyNS0xMS0wM1QxMTozNzozOS45NTEzNjZaIiwidXBkYXRlZF9hdCI6IjIwMjUtMTEtMDNUMTE6Mzc6NDEuODI0MzU1WiIsImlzX2Fub255bW91cyI6ZmFsc2V9LCJwcm92aWRlcl90b2tlbiI6InlhMjkuYTBBVGk2SzJ0NnpLV1dqRDdQdi1HNDU3TlpFWElja2Y1WHN4SFlheUR6cms5TzZiSHVRY0xwT3dvZFpzWE9pSXEyMC1NdzViRm9CNE9RcGJ4LUV3eHhMM3BfT1kxZ2liQ3dTU3ExU2FsYndmbW8zN3ZlUjVDSTJiQVhlM3E3d1NnX3NCVnp5a1hoc3Z5blFnNHdKWVJqOXQ0NUZEQ1NEYmFNQmZkTVpmeWhITjJTYVByNkFzLUJjMUFuQXU1NEs2a1lQRWlvMGRNYUNnWUtBV2tTQVJVU0ZRSEdYMk1pVnM5a2N2NHBfZmxTcGthOE1rRkNLUTAyMDYifQ; ph_phc_WiMP1Rj0YvrdwYVYdE0AdRBNmB8MTdbsWY8oalxSrts_posthog=%7B%22distinct_id%22%3A%2271b95f80-2e0f-4882-8a53-b8effa9a1b65%22%2C%22%24sesid%22%3A%5B1762170188623%2C%22019a4981-a7e1-7778-9297-f569f82af9bb%22%2C1762169825241%5D%2C%22%24epp%22%3Atrue%2C%22%24initial_person_info%22%3A%7B%22r%22%3A%22https%3A%2F%2Fsearch.brave.com%2F%22%2C%22u%22%3A%22https%3A%2F%2Fsmithery.ai%2F%22%7D%7D'
+}
+
+class Message(BaseModel):
+    model_config = ConfigDict(extra="allow")
+    
+    role: str
+    content: Union[str, List[Dict[str, Any]]]
+    name: Optional[str] = None
+
+class ChatCompletionRequest(BaseModel):
+    model_config = ConfigDict(extra="allow")
+    
+    model: Optional[str] = "claude-haiku-4.5"
+    messages: List[Message]
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+    top_p: Optional[float] = None
+    n: Optional[int] = None
+    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[Dict[str, Any]]] = None
+    tool_choice: Optional[Union[str, Dict[str, Any]]] = None
+    response_format: Optional[Dict[str, Any]] = None
+
+class Choice(BaseModel):
+    index: int
+    message: Message
+    finish_reason: str
+
+class Usage(BaseModel):
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+
+class ChatCompletionResponse(BaseModel):
+    id: str
+    object: str = "chat.completion"
+    created: int
+    model: str
+    choices: List[Choice]
+    usage: Usage
+
+def convert_to_smithery_format(messages: List[Message]) -> List[Dict]:
+    smithery_messages = []
+    for msg in messages:
+        role = "user" if msg.role == "user" else "assistant"
+        
+        if isinstance(msg.content, str):
+            content = msg.content
+        elif isinstance(msg.content, list):
+            content = " ".join([part.get("text", "") for part in msg.content if isinstance(part, dict) and part.get("type") == "text"])
+        else:
+            content = str(msg.content)
+        
+        smithery_msg = {
+            "parts": [{"type": "text", "text": content}],
+            "id": str(uuid.uuid4()).replace("-", "")[:16],
+            "role": role
+        }
+        smithery_messages.append(smithery_msg)
+    return smithery_messages
+
+def convert_from_smithery_format(smithery_response: str) -> str:
+    return smithery_response
+
+async def stream_smithery_response(messages: List[Message], model: str, tools: Optional[List] = None):
+    smithery_messages = convert_to_smithery_format(messages)
+    backend_model = get_backend_model(model)
+    
+    payload = {
+        "messages": smithery_messages,
+        "tools": [],
+        "model": backend_model,
+        "systemPrompt": "You are a helpful assistant.",
+        "chatId": "default"
+    }
+    
+    chat_id = f"chatcmpl-{uuid.uuid4()}"
+    created = int(time.time())
+    first_chunk = True
+    
+    logger.info(f"Streaming request for model: {model} -> {backend_model}")
+    
+    try:
+        timeout = httpx.Timeout(120.0, connect=30.0)
+        async with httpx.AsyncClient(timeout=timeout, follow_redirects=True) as client:
+            async with client.stream(
+                "POST",
+                SMITHERY_API_URL,
+                headers=SMITHERY_HEADERS,
+                json=payload
+            ) as response:
+                logger.info(f"Backend response status: {response.status_code}")
+                
+                if response.status_code != 200:
+                    error_text = await response.aread()
+                    error_msg = error_text.decode()
+                    logger.error(f"Backend error: {error_msg}")
+                    
+                    error_chunk = {
+                        "id": chat_id,
+                        "object": "chat.completion.chunk",
+                        "created": created,
+                        "model": model,
+                        "choices": [{
+                            "index": 0,
+                            "delta": {"role": "assistant", "content": f"Error: {error_msg}"},
+                            "finish_reason": None
+                        }]
+                    }
+                    yield f"data: {json.dumps(error_chunk)}\n\n"
+                    yield "data: [DONE]\n\n"
+                    return
+                
+                chunk_count = 0
+                async for line in response.aiter_lines():
+                    if line.startswith("data: "):
+                        data_str = line[6:]
+                        
+                        if data_str == "[DONE]":
+                            logger.info(f"Stream completed, sent {chunk_count} chunks")
+                            final_chunk = {
+                                "id": chat_id,
+                                "object": "chat.completion.chunk",
+                                "created": created,
+                                "model": model,
+                                "choices": [{
+                                    "index": 0,
+                                    "delta": {},
+                                    "finish_reason": "stop"
+                                }]
+                            }
+                            yield f"data: {json.dumps(final_chunk)}\n\n"
+                            yield "data: [DONE]\n\n"
+                            break
+                        
+                        try:
+                            data = json.loads(data_str)
+                            
+                            if data.get("type") == "text-delta":
+                                delta_text = data.get("delta", "")
+                                chunk_count += 1
+                                
+                                if first_chunk:
+                                    chunk_data = {
+                                        "id": chat_id,
+                                        "object": "chat.completion.chunk",
+                                        "created": created,
+                                        "model": model,
+                                        "choices": [{
+                                            "index": 0,
+                                            "delta": {"role": "assistant", "content": delta_text},
+                                            "finish_reason": None
+                                        }]
+                                    }
+                                    first_chunk = False
+                                else:
+                                    chunk_data = {
+                                        "id": chat_id,
+                                        "object": "chat.completion.chunk",
+                                        "created": created,
+                                        "model": model,
+                                        "choices": [{
+                                            "index": 0,
+                                            "delta": {"content": delta_text},
+                                            "finish_reason": None
+                                        }]
+                                    }
+                                yield f"data: {json.dumps(chunk_data)}\n\n"
+                        except Exception as parse_error:
+                            logger.warning(f"Failed to parse chunk: {parse_error}")
+                            pass
+                
+    except httpx.TimeoutException as e:
+        logger.error(f"Timeout error: {str(e)}")
+        error_chunk = {
+            "id": chat_id,
+            "object": "chat.completion.chunk",
+            "created": created,
+            "model": model,
+            "choices": [{
+                "index": 0,
+                "delta": {"role": "assistant", "content": "Error: Request timeout. The backend took too long to respond."},
+                "finish_reason": "stop"
+            }]
+        }
+        yield f"data: {json.dumps(error_chunk)}\n\n"
+        yield "data: [DONE]\n\n"
+    except Exception as e:
+        logger.error(f"Stream error: {str(e)}")
+        error_chunk = {
+            "id": chat_id,
+            "object": "chat.completion.chunk",
+            "created": created,
+            "model": model,
+            "choices": [{
+                "index": 0,
+                "delta": {"role": "assistant", "content": f"Error: {str(e)}"},
+                "finish_reason": "stop"
+            }]
+        }
+        yield f"data: {json.dumps(error_chunk)}\n\n"
+        yield "data: [DONE]\n\n"
+
+async def get_smithery_response(messages: List[Message], model: str, tools: Optional[List] = None) -> str:
+    smithery_messages = convert_to_smithery_format(messages)
+    backend_model = get_backend_model(model)
+    
+    payload = {
+        "messages": smithery_messages,
+        "tools": [],
+        "model": backend_model,
+        "systemPrompt": "You are a helpful assistant.",
+        "chatId": "default"
+    }
+    
+    try:
+        async with httpx.AsyncClient(timeout=60.0, follow_redirects=True) as client:
+            response = await client.post(
+                SMITHERY_API_URL,
+                headers=SMITHERY_HEADERS,
+                json=payload
+            )
+            if response.status_code != 200:
+                error_detail = f"Smithery API returned {response.status_code}: {response.text}"
+                return error_detail
+            return response.text
+    except Exception as e:
+        return f"Error calling Smithery API: {str(e)}"
+
+@app.post("/v1/chat/completions")
+async def chat_completions(request: ChatCompletionRequest):
+    try:
+        logger.info(f"Chat request: model={request.model}, stream={request.stream}, messages={len(request.messages)}")
+        
+        if request.stream:
+            return StreamingResponse(
+                stream_smithery_response(request.messages, request.model, request.tools),
+                media_type="text/event-stream",
+                headers={
+                    "Cache-Control": "no-cache",
+                    "Connection": "keep-alive",
+                    "X-Accel-Buffering": "no"
+                }
+            )
+        else:
+            content = await get_smithery_response(request.messages, request.model, request.tools)
+            
+            response = ChatCompletionResponse(
+                id=f"chatcmpl-{uuid.uuid4()}",
+                created=int(time.time()),
+                model=request.model,
+                choices=[
+                    Choice(
+                        index=0,
+                        message=Message(role="assistant", content=content),
+                        finish_reason="stop"
+                    )
+                ],
+                usage=Usage(
+                    prompt_tokens=len(str(request.messages)),
+                    completion_tokens=len(content),
+                    total_tokens=len(str(request.messages)) + len(content)
+                )
+            )
+            logger.info(f"Non-streaming response completed, content length: {len(content)}")
+            return response
+            
+    except httpx.TimeoutException as e:
+        logger.error(f"Timeout in chat_completions: {str(e)}")
+        raise HTTPException(status_code=504, detail="Gateway timeout - backend took too long to respond")
+    except httpx.HTTPStatusError as e:
+        logger.error(f"HTTP error in chat_completions: {e.response.status_code}")
+        raise HTTPException(status_code=e.response.status_code, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error in chat_completions: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/v1/models")
+async def list_models():
+    models_list = []
+    for model_id in MODEL_MAPPING.keys():
+        models_list.append({
+            "id": model_id,
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": "smithery-ai"
+        })
+    
+    return {
+        "object": "list",
+        "data": models_list
+    }
+
+@app.get("/")
+async def root():
+    return {
+        "message": "Smithery AI Reverse API",
+        "version": "1.0.0",
+        "status": "online",
+        "endpoints": {
+            "chat_completions": "/v1/chat/completions",
+            "models": "/v1/models"
+        },
+        "docs": "/docs"
+    }
+
+@app.get("/health")
+async def health():
+    return {"status": "healthy", "service": "smithery-ai-reverse-api"}
+
+@app.get("/test-backend")
+async def test_backend():
+    """Test if backend is accessible"""
+    try:
+        test_messages = [{"parts": [{"type": "text", "text": "hi"}], "id": "test123", "role": "user"}]
+        payload = {
+            "messages": test_messages,
+            "tools": [],
+            "model": "claude-haiku-4.5",
+            "systemPrompt": "You are a helpful assistant.",
+            "chatId": "test"
+        }
+        
+        timeout = httpx.Timeout(30.0, connect=10.0)
+        async with httpx.AsyncClient(timeout=timeout, follow_redirects=True) as client:
+            response = await client.post(
+                SMITHERY_API_URL,
+                headers=SMITHERY_HEADERS,
+                json=payload
+            )
+            return {
+                "backend_accessible": True,
+                "status_code": response.status_code,
+                "response_length": len(response.text),
+                "smithery_url": SMITHERY_API_URL
+            }
+    except Exception as e:
+        logger.error(f"Backend test failed: {str(e)}")
+        return {
+            "backend_accessible": False,
+            "error": str(e),
+            "smithery_url": SMITHERY_API_URL
+        }
+
+if __name__ == "__main__":
+    import uvicorn
+    import os
+    port = int(os.getenv("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)

requirements.txt

@@ -0,0 +1,4 @@
+fastapi
+uvicorn
+httpx
+pydantic