Update app.py

app.py

@@ -1,92 +1,136 @@
-import os
-import uuid
-from datetime import datetime
-from typing import List
-
-from dotenv import load_dotenv
 from fastapi import FastAPI, HTTPException, Depends, Security
 from fastapi.security import APIKeyHeader
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel
-import uvicorn
-from huggingface_hub import InferenceClient
+import requests
+import uuid
+import os
+from datetime import datetime
+from fastapi.middleware.cors import CORSMiddleware
+from dotenv import load_dotenv
 
 # Load environment variables
 load_dotenv()
 
-app = FastAPI()
+# Initialize FastAPI app
+app = FastAPI(title="MultiChatAI to OpenAI API Wrapper")
 
 # Configuration
 API_KEY_NAME = "X-API-KEY"
-API_KEYS = os.getenv("API_KEYS", "").split(",")
-HF_MODEL = os.getenv("HF_MODEL_NAME", "deepseek-ai/deepseek-llm-7b")
-HF_TOKEN = os.getenv("HF_API_TOKEN")
+API_KEYS = os.getenv("API_KEYS", "").split(",")  # Comma-separated list from .env
 
-# Initialize Hugging Face client
-client = InferenceClient(token=HF_TOKEN)
+# Configure CORS - adjust these based on your needs
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
-# Security
+# Security setup
 api_key_header = APIKeyHeader(name=API_KEY_NAME, auto_error=False)
 
 async def get_api_key(api_key: str = Security(api_key_header)):
     if not api_key:
-        raise HTTPException(status_code=401, detail="API key is missing")
+        raise HTTPException(
+            status_code=401, 
+            detail="API key is missing"
+        )
     if api_key not in API_KEYS:
-        raise HTTPException(status_code=401, detail="Invalid API key")
+        raise HTTPException(
+            status_code=401, 
+            detail="Invalid API key"
+        )
     return api_key
 
-class Message(BaseModel):
+# Request models
+class ChatMessage(BaseModel):
     role: str
     content: str
 
-class ChatRequest(BaseModel):
-    messages: List[Message]
-    model: str = HF_MODEL
+class ChatCompletionRequest(BaseModel):
+    model: str = "deepseek-ai/DeepSeek-V3"
+    messages: list[ChatMessage]
     temperature: float = 0.7
-    max_tokens: int = 200
+    max_tokens: int = None
 
+# Health check endpoint
 @app.get("/")
 async def health_check():
-    return {"status": "running", "timestamp": datetime.now().isoformat()}
+    return {"status": "OK", "service": "MultiChatAI Proxy", "timestamp": datetime.now().isoformat()}
 
+# Main API endpoint
 @app.post("/v1/chat/completions")
 async def chat_completion(
-    request: ChatRequest,
+    request: ChatCompletionRequest,
     api_key: str = Depends(get_api_key)
 ):
     try:
-        # Format messages for HF inference
-        prompt = "\n".join(
-            f"{msg.role}: {msg.content}" 
-            for msg in request.messages
-        )
+        # Prepare request for MultiChatAI
+        multi_chat_body = {
+            "chatSettings": {
+                "model": request.model,
+                "prompt": "You are a helpful AI assistant.",
+                "temperature": request.temperature,
+                "contextLength": 32000,
+                "includeProfileContext": True,
+                "includeWorkspaceInstructions": True,
+                "embeddingsProvider": "openai"
+            },
+            "messages": [
+                {"role": "system", "content": f"Today is {datetime.now().strftime('%m/%d/%Y')}.\nYou are a helpful AI assistant."},
+                *[{"role": msg.role, "content": msg.content} for msg in request.messages]
+            ],
+            "customModelId": ""
+        }
         
-        # Call Hugging Face model
-        response = client.text_generation(
-            prompt=prompt,
-            model=request.model,
-            temperature=request.temperature,
-            max_new_tokens=request.max_tokens
+        headers = {
+            "accept": "application/json",
+            "content-type": "application/json",
+        }
+        
+        # Call MultiChatAI API
+        response = requests.post(
+            "https://www.multichatai.com/api/chat/deepinfra",
+            headers=headers,
+            json=multi_chat_body,
+            timeout=30
         )
         
+        if not response.ok:
+            raise HTTPException(
+                status_code=response.status_code,
+                detail=f"MultiChatAI API error: {response.text}"
+            )
+        
+        # Format response in OpenAI style
         return JSONResponse({
-            "id": str(uuid.uuid4()),
+            "id": f"chatcmpl-{uuid.uuid4()}",
             "object": "chat.completion",
             "created": int(datetime.now().timestamp()),
             "model": request.model,
             "choices": [{
+                "index": 0,
                 "message": {
                     "role": "assistant",
-                    "content": response.strip()
-                }
-            }]
+                    "content": response.text.strip()
+                },
+                "finish_reason": "stop"
+            }],
+            "usage": {
+                "prompt_tokens": 0,
+                "completion_tokens": 0,
+                "total_tokens": 0
+            }
         })
+        
+    except requests.Timeout:
+        raise HTTPException(status_code=504, detail="Upstream service timeout")
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
-if __name__ == "__main__":
-    uvicorn.run(
-        app,
-        host="0.0.0.0",
-        port=int(os.getenv("PORT", 7860))
-    )
+# Add this if you need to support OPTIONS requests
+@app.options("/v1/chat/completions")
+async def options_handler():
+    return JSONResponse(content={}, status_code=200)