Update app.py

app.py

@@ -1,135 +1,158 @@
 from fastapi import FastAPI, HTTPException, Depends, Header, Request
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
-from typing import List
-from g4f import ChatCompletion
-from g4f.typing import Messages, AsyncResult
-import g4f.Provider
-from g4f.Provider import BackendApi
+from typing import List, Optional, Literal
+import json
+import g4f
+from g4f.Provider import OpenaiAccount, RetryProvider
+from g4f.models import ModelUtils
 
 app = FastAPI()
 
-# List of available models
+# Complete list of available models from G4F
 models = [
-    "gpt-4o", "gpt-4o-mini", "gpt-4",
-    "gpt-4-turbo", "gpt-3.5-turbo",
-    "claude-3.7-sonnet", "o3-mini", "o1", "grok-3", "gemini-2.5-pro-exp-03-25", "claude-3.5", 
-    "llama-3.1-405b"
+    # OpenAI models
+    "gpt-4", "gpt-4-turbo", "gpt-4o", "gpt-3.5-turbo",
+    
+    # Anthropic models
+    "claude-3-opus", "claude-3-sonnet", "claude-3-haiku", "claude-2.1",
+    
+    # Google models
+    "gemini-pro", "gemini-1.5-pro", "gemini-1.5-flash",
+    
+    # Meta models
+    "llama-2-70b", "llama-2-13b", "llama-2-7b", "llama-3-70b", "llama-3-8b",
+    
+    # Other providers
+    "mistral-7b", "mixtral-8x7b", "command-r-plus", "cohere-command-r",
+    "deepseek-chat", "deepseek-coder", "code-llama-34b", "code-llama-70b",
+    
+    # Specialized models
+    "grok-1", "grok-1.5", "grok-2", "o1", "o3-mini", "flux", "flux-pro"
 ]
 
-url = "https://ahe.hopto.org"
-headers = {"Authorization": "Basic Z2dnOmc0Zl8="}
-
-BackendApi.working = True
-BackendApi.ssl = False
-BackendApi.url = url
-BackendApi.headers = headers
-
-class BackendApi(BackendApi):
+# Configure G4F backend
+class CustomBackend(g4f.Provider.BackendApi):
     working = True
     ssl = False
-    url = url
-    headers = headers
-    image_models = ["flux", "flux-pro"]
-    models = ["deepseek-r1", *g4f.Provider.OpenaiAccount.get_models(), "flux", "flux-pro"]
-
+    url = "https://ahe.hopto.org"
+    headers = {"Authorization": "Basic Z2dnOmc0Zl8="}
+    
     @classmethod
     async def create_async_generator(
         cls,
         model: str,
-        messages: Messages,
+        messages: g4f.typing.Messages,
         **kwargs
-    ) -> AsyncResult:
-        if model in g4f.Provider.OpenaiAccount.get_models():
-            kwargs["provider"] = "OpenaiAccount"
+    ) -> g4f.typing.AsyncResult:
+        if model in OpenaiAccount.get_models():
+            kwargs["provider"] = OpenaiAccount
         async for chunk in super().create_async_generator(model, messages, **kwargs):
             yield chunk
 
-# Request model
+# Pydantic models
 class Message(BaseModel):
-    role: str
+    role: Literal["system", "user", "assistant"]
     content: str
 
 class ChatRequest(BaseModel):
     model: str
     messages: List[Message]
+    temperature: Optional[float] = 0.7
+    max_tokens: Optional[int] = None
+    top_p: Optional[float] = 0.9
     streaming: bool = True
 
 class ChatResponse(BaseModel):
-    role: str
+    role: str = "assistant"
     content: str
+    model: Optional[str] = None
 
-# Dependency to check API key
+class ModelListResponse(BaseModel):
+    models: List[str]
+
+# API Key Verification
 async def verify_api_key(x_api_key: str = Header(...)):
     if x_api_key != "fb207532285886a5568298b4b4e61124":
         raise HTTPException(status_code=403, detail="Invalid API key")
 
-@app.get("/v1/models", tags=["Models"])
+@app.get("/v1/models", response_model=ModelListResponse, tags=["Models"])
 async def get_models():
-    """Endpoint to get the list of available models."""
-    return {"models": models}
+    """Get list of all available models"""
+    return ModelListResponse(models=models)
 
-@app.post("/v1/chat/completions", tags=["Chat Completion"])
+@app.post("/v1/chat/completions", response_model=Optional[ChatResponse], tags=["Chat"])
 async def chat_completion(
-    chat_request: ChatRequest,
+    request: ChatRequest,
     api_key: str = Depends(verify_api_key)
 ):
     """
-    Handle chat completion requests with optional streaming.
-    Removed rate limiting for unrestricted access.
+    Handle chat completion requests with streaming support.
+    
+    Args:
+        request: ChatRequest containing model, messages and parameters
+        api_key: Verified API key
+        
+    Returns:
+        Either a StreamingResponse or direct ChatResponse
     """
     # Validate model
-    if chat_request.model not in models:
-        raise HTTPException(status_code=400, detail="Invalid model selected.")
-
-    # Check if messages are provided
-    if not chat_request.messages:
-        raise HTTPException(status_code=400, detail="Messages cannot be empty.")
-
-    # Convert messages to the format expected by ChatCompletion
-    formatted_messages = [{"role": msg.role, "content": msg.content} for msg in chat_request.messages]
-
+    if request.model not in models:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Invalid model. Available models: {', '.join(models)}"
+        )
+
+    # Prepare messages
+    messages = [{"role": msg.role, "content": msg.content} for msg in request.messages]
+    
     try:
-        if chat_request.streaming:
-            # Stream the response
-            def event_stream():
-                response = ChatCompletion.create(
-                    model=chat_request.model,
-                    messages=formatted_messages,
-                    stream=True
+        if request.streaming:
+            async def stream_generator():
+                response = await g4f.ChatCompletion.create_async(
+                    model=request.model,
+                    messages=messages,
+                    temperature=request.temperature,
+                    top_p=request.top_p,
+                    max_tokens=request.max_tokens,
+                    provider=RetryProvider([CustomBackend])
                 )
                 
-                for chunk in response:
-                    if isinstance(chunk, dict) and 'choices' in chunk:
-                        for choice in chunk['choices']:
-                            if 'delta' in choice and 'content' in choice['delta']:
-                                yield f"data: {json.dumps({'content': choice['delta']['content']})}\n\n"
-                            elif 'message' in choice:
-                                yield f"data: {json.dumps({'content': choice['message']['content']})}\n\n"
+                async for chunk in response:
+                    if isinstance(chunk, dict):
+                        yield f"data: {json.dumps(chunk)}\n\n"
                     else:
                         yield f"data: {json.dumps({'content': str(chunk)})}\n\n"
+                yield "data: [DONE]\n\n"
 
-            return StreamingResponse(event_stream(), media_type="text/event-stream")
+            return StreamingResponse(
+                stream_generator(),
+                media_type="text/event-stream"
+            )
         else:
-            # Non-streaming response
-            response = ChatCompletion.create(
-                model=chat_request.model,
-                messages=formatted_messages,
-                stream=False
+            response = await g4f.ChatCompletion.create_async(
+                model=request.model,
+                messages=messages,
+                temperature=request.temperature,
+                top_p=request.top_p,
+                max_tokens=request.max_tokens,
+                provider=RetryProvider([CustomBackend])
             )
-
+            
             if isinstance(response, str):
-                return ChatResponse(role="assistant", content=response)
-            elif isinstance(response, dict) and 'choices' in response:
+                return ChatResponse(content=response, model=request.model)
+            elif isinstance(response, dict):
                 return ChatResponse(
-                    role="assistant",
-                    content=response['choices'][0]['message']['content']
+                    content=response.get("choices", [{}])[0].get("message", {}).get("content", ""),
+                    model=request.model
                 )
-            else:
-                raise HTTPException(status_code=500, detail="Unexpected response structure.")
+            return ChatResponse(content=str(response), model=request.model
 
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error processing request: {str(e)}"
+        )
 
 if __name__ == "__main__":
     import uvicorn