Update app.py

app.py

@@ -1,6 +1,7 @@
 import time
 import random
 import traceback
+import uuid
 
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.middleware.cors import CORSMiddleware
@@ -15,9 +16,7 @@ from g4f.Provider import __providers__
 # =====================================================
 
 API_KEY = "sk-your-secret-key"
-
 MODEL = "gpt-4o-mini"
-
 MAX_RETRIES = 10
 TIMEOUT = 60
 
@@ -28,9 +27,7 @@ SAFE_PROVIDERS = []
 # =====================================================
 
 for provider in __providers__:
-
     try:
-
         name = provider.__name__.lower()
 
         if not getattr(provider, "working", False):
@@ -54,12 +51,10 @@ for provider in __providers__:
             continue
 
         SAFE_PROVIDERS.append(provider)
-
     except:
         pass
 
 random.shuffle(SAFE_PROVIDERS)
-
 print(f"[+] SAFE PROVIDERS: {len(SAFE_PROVIDERS)}")
 
 client = Client()
@@ -69,8 +64,8 @@ client = Client()
 # =====================================================
 
 app = FastAPI(
-    title="Smart G4F Gateway",
-    version="1.0"
+    title="Smart G4F Gateway (Claude/OpenAI Compatible)",
+    version="2.0"
 )
 
 # =====================================================
@@ -86,108 +81,81 @@ app.add_middleware(
 )
 
 # =====================================================
-# REQUEST MODEL
+# REQUEST MODELS
 # =====================================================
 
 class ChatRequest(BaseModel):
-
     prompt: str
 
 # =====================================================
-# API KEY
+# API KEY VERIFICATION
 # =====================================================
 
 def verify_api_key(request: Request):
-
-    # x-api-key
+    # x-api-key support (Used by Claude clients)
     x_api_key = request.headers.get("x-api-key")
-
     if x_api_key == API_KEY:
         return
 
-    # Authorization Bearer
+    # Authorization Bearer support (Used by OpenAI clients)
     auth = request.headers.get("Authorization")
-
     if auth and auth.startswith("Bearer "):
-
         token = auth.replace("Bearer ", "").strip()
-
         if token == API_KEY:
             return
 
     raise HTTPException(
-        status_code=403,
+        status_code=401,
         detail="Invalid API Key"
     )
 
 # =====================================================
-# SMART G4F
+# SMART G4F LOGIC
 # =====================================================
 
 class SmartG4F:
-
     def __init__(self):
-
         self.good = []
         self.bad = {}
 
     def mark_bad(self, provider, cooldown=300):
-
         self.bad[provider.__name__] = time.time() + cooldown
 
     def is_bad(self, provider):
-
         until = self.bad.get(provider.__name__)
-
         if not until:
             return False
-
         return time.time() < until
 
-    def ask(self, prompt):
-
+    def ask(self, messages, requested_model=MODEL):
         providers = SAFE_PROVIDERS.copy()
-
         random.shuffle(providers)
-
         last_error = None
 
         for provider in providers[:MAX_RETRIES]:
-
             try:
-
                 if self.is_bad(provider):
                     continue
 
                 print(f"[+] TRYING: {provider.__name__}")
 
                 response = client.chat.completions.create(
-                    model=MODEL,
+                    model=requested_model,
                     provider=provider,
-                    messages=[
-                        {
-                            "role": "user",
-                            "content": prompt
-                        }
-                    ],
+                    messages=messages,
                     timeout=TIMEOUT
                 )
 
                 text = None
-
                 try:
-
                     text = response.choices[0].message.content
-
                 except:
-
                     text = str(response)
 
                 if not text:
                     continue
 
                 self.good.append(provider.__name__)
-
                 print(f"[+] SUCCESS: {provider.__name__}")
 
                 return {
@@ -196,84 +164,138 @@ class SmartG4F:
                 }
 
             except Exception as e:
-
                 last_error = str(e)
-
                 print(f"[-] FAILED: {provider.__name__}")
                 print(traceback.format_exc())
-
                 self.mark_bad(provider)
 
         raise Exception(last_error or "All providers failed")
 
-# =====================================================
-# INSTANCE
-# =====================================================
-
 smart = SmartG4F()
 
 # =====================================================
-# ROOT
+# ENDPOINTS
 # =====================================================
 
 @app.get("/")
-
 async def root():
-
     return {
         "status": "online",
         "providers": len(SAFE_PROVIDERS),
-        "api_key": True
+        "api_key_required": True,
+        "endpoints": ["/v1/messages (Claude)", "/v1/chat/completions (OpenAI)", "/chat (Legacy)"]
     }
 
-# =====================================================
-# CHAT
-# =====================================================
-
-@app.post("/chat")
+# 1. Claude API Format (Used by Claude Co-work)
+@app.post("/v1/messages")
+async def claude_messages(request: Request):
+    verify_api_key(request)
+    body = await request.json()
+    
+    messages = body.get("messages", [])
+    system_prompt = body.get("system", "")
+    req_model = body.get("model", MODEL)
+
+    # Convert Anthropic format to standard messages list
+    g4f_messages = []
+    if system_prompt:
+        g4f_messages.append({"role": "system", "content": system_prompt})
+        
+    for msg in messages:
+        content = msg.get("content", "")
+        # Handle complex content blocks if sent by Claude clients
+        if isinstance(content, list):
+            text_content = " ".join([c.get("text", "") for c in content if c.get("type") == "text"])
+        else:
+            text_content = content
+            
+        g4f_messages.append({
+            "role": msg.get("role", "user"),
+            "content": text_content
+        })
 
-async def chat(request: Request, body: ChatRequest):
+    try:
+        result = smart.ask(g4f_messages, req_model)
+        
+        # Return exact Anthropic API structure
+        return {
+            "id": f"msg_{uuid.uuid4().hex}",
+            "type": "message",
+            "role": "assistant",
+            "model": req_model,
+            "content": [
+                {
+                    "type": "text",
+                    "text": result["response"]
+                }
+            ],
+            "stop_reason": "end_turn",
+            "stop_sequence": None,
+            "usage": {"input_tokens": 0, "output_tokens": 0}
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
 
+# 2. OpenAI API Format (Alternative standard)
+@app.post("/v1/chat/completions")
+async def openai_chat(request: Request):
     verify_api_key(request)
+    body = await request.json()
+    
+    messages = body.get("messages", [])
+    req_model = body.get("model", MODEL)
 
     try:
+        result = smart.ask(messages, req_model)
+        
+        return {
+            "id": f"chatcmpl-{uuid.uuid4().hex}",
+            "object": "chat.completion",
+            "created": int(time.time()),
+            "model": req_model,
+            "choices": [{
+                "index": 0,
+                "message": {
+                    "role": "assistant",
+                    "content": result["response"]
+                },
+                "finish_reason": "stop"
+            }]
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
 
-        result = smart.ask(body.prompt)
-
+# 3. Legacy Custom Format (Your original endpoint)
+@app.post("/chat")
+async def chat(request: Request, body: ChatRequest):
+    verify_api_key(request)
+    try:
+        messages = [{"role": "user", "content": body.prompt}]
+        result = smart.ask(messages)
         return {
             "success": True,
             "provider": result["provider"],
             "response": result["response"]
         }
-
     except Exception as e:
-
-        raise HTTPException(
-            status_code=500,
-            detail=str(e)
-        )
+        raise HTTPException(status_code=500, detail=str(e))
 
 # =====================================================
 # RUN
 # =====================================================
 
 if __name__ == "__main__":
-
     print("""
-
-╔══════════════════════════════╗
-║     SMART G4F GATEWAY       ║
-╠══════════════════════════════╣
-║  API KEY ENABLED            ║
-║  x-api-key supported        ║
-║  Bearer supported           ║
-║  /chat                      ║
-╚══════════════════════════════╝
-
+╔════════════════════════════════════════╗
+║     SMART G4F GATEWAY (COMPATIBLE)     ║
+╠════════════════════════════════════════╣
+║  API KEY ENABLED                       ║
+║  x-api-key supported                   ║
+║  Bearer supported                      ║
+║  Endpoints:                            ║
+║  - /v1/messages (Claude Co-work)       ║
+║  - /v1/chat/completions (OpenAI)       ║
+║  - /chat (Legacy)                      ║
+╚════════════════════════════════════════╝
 """)
-
-    uvicorn.run(
-        app,
-        host="0.0.0.0",
-        port=7860
-    )
+    uvicorn.run(app, host="0.0.0.0", port=7860)