Delete api

api/app.py

@@ -1,42 +0,0 @@
-# api/app.py
-
-from fastapi import FastAPI, Request
-from starlette.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
-from api.logger import setup_logger
-from api.routes import router
-
-logger = setup_logger(__name__)
-
-def create_app():
-    app = FastAPI(
-        title="AmigoChat API Gateway",
-        docs_url=None,          # Disable Swagger UI
-        redoc_url=None,         # Disable ReDoc
-        openapi_url=None,       # Disable OpenAPI schema
-    )
-
-    # CORS settings
-    app.add_middleware(
-        CORSMiddleware,
-        allow_origins=["*"],                   # Adjust as needed for security
-        allow_credentials=True,
-        allow_methods=["*"],
-        allow_headers=["*"],
-    )
-
-    # Include routes
-    app.include_router(router)
-
-    # Global exception handler for better error reporting
-    @app.exception_handler(Exception)
-    async def global_exception_handler(request: Request, exc: Exception):
-        logger.error(f"An error occurred: {str(exc)}")
-        return JSONResponse(
-            status_code=500,
-            content={"message": "An internal server error occurred."},
-        )
-
-    return app
-
-app = create_app()

api/auth.py

@@ -1,12 +0,0 @@
-# api/auth.py
-
-from fastapi import Depends, HTTPException
-from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
-from api.config import APP_SECRET
-
-security = HTTPBearer()
-
-def verify_app_secret(credentials: HTTPAuthorizationCredentials = Depends(security)):
-    if credentials.credentials != APP_SECRET:
-        raise HTTPException(status_code=403, detail="Invalid APP_SECRET")
-    return credentials.credentials

api/config.py

@@ -1,8 +0,0 @@
-# api/config.py
-
-import os
-from dotenv import load_dotenv
-
-load_dotenv()
-
-APP_SECRET = os.getenv("APP_SECRET")

api/logger.py

@@ -1,22 +0,0 @@
-# api/logger.py
-
-import logging
-
-def setup_logger(name):
-    logger = logging.getLogger(name)
-    if not logger.handlers:
-        logger.setLevel(logging.INFO)
-        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-        
-        # Console handler
-        console_handler = logging.StreamHandler()
-        console_handler.setFormatter(formatter)
-        logger.addHandler(console_handler)
-        
-        # File Handler - Error Level (Optional)
-        # error_file_handler = logging.FileHandler('error.log')
-        # error_file_handler.setFormatter(formatter)
-        # error_file_handler.setLevel(logging.ERROR)
-        # logger.addHandler(error_file_handler)
-    
-    return logger

api/models.py

@@ -1,16 +0,0 @@
-# api/models.py
-
-from typing import List, Optional
-from pydantic import BaseModel
-
-class Message(BaseModel):
-    role: str
-    content: str
-
-class ChatRequest(BaseModel):
-    model: str
-    messages: List[Message]
-    stream: Optional[bool] = False
-    temperature: Optional[float] = 0.5
-    top_p: Optional[float] = 0.95
-    max_tokens: Optional[int] = 4000

api/providers.py

@@ -1,159 +0,0 @@
-# api/providers.py
-
-from __future__ import annotations
-
-import json
-import uuid
-from aiohttp import ClientSession, ClientTimeout
-from typing import AsyncGenerator, List, Dict, Any, Union
-
-from api.logger import setup_logger
-
-logger = setup_logger(__name__)
-
-class AmigoChat:
-    url = "https://amigochat.io"
-    chat_api_endpoint = "https://api.amigochat.io/v1/chat/completions"
-    image_api_endpoint = "https://api.amigochat.io/v1/images/generations"
-    default_model = 'gpt-4o-mini'
-
-    chat_models = [
-        'gpt-4o',
-        default_model,
-        'o1-preview',
-        'o1-mini',
-        'meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo',
-        'meta-llama/Llama-3.2-90B-Vision-Instruct-Turbo',
-        'claude-3-sonnet-20240229',
-        'gemini-1.5-pro',
-    ]
-
-    image_models = [
-        'flux-pro/v1.1',
-        'flux-realism',
-        'flux-pro',
-        'dalle-e-3',
-    ]
-
-    models = chat_models + image_models
-
-    model_aliases = {
-        "o1": "o1-preview",
-        "llama-3.1-405b": "meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo",
-        "llama-3.2-90b": "meta-llama/Llama-3.2-90B-Vision-Instruct-Turbo",
-        "claude-3.5-sonnet": "claude-3-sonnet-20240229",
-        "gemini-pro": "gemini-1.5-pro",
-        "flux-pro": "flux-pro/v1.1",
-        "dalle-3": "dalle-e-3",
-    }
-
-    persona_ids = {
-        'gpt-4o': "gpt",
-        'gpt-4o-mini': "amigo",
-        'o1-preview': "openai-o-one",
-        'o1-mini': "openai-o-one-mini",
-        'meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo': "llama-three-point-one",
-        'meta-llama/Llama-3.2-90B-Vision-Instruct-Turbo': "llama-3-2",
-        'claude-3-sonnet-20240229': "claude",
-        'gemini-1.5-pro': "gemini-1-5-pro",
-        'flux-pro/v1.1': "flux-1-1-pro",
-        'flux-realism': "flux-realism",
-        'flux-pro': "flux-pro",
-        'dalle-e-3': "dalle-three",
-    }
-
-    @classmethod
-    def get_model(cls, model: str) -> str:
-        return cls.model_aliases.get(model, model if model in cls.models else cls.default_model)
-
-    @classmethod
-    def get_persona_id(cls, model: str) -> str:
-        return cls.persona_ids.get(model, "amigo")
-
-    @classmethod
-    async def generate_response(
-        cls,
-        model: str,
-        messages: List[Dict[str, Any]],
-        stream: bool = False,
-        proxy: str = None,
-    ) -> Union[AsyncGenerator[str, None], str]:
-        model = cls.get_model(model)
-        device_uuid = str(uuid.uuid4())
-
-        headers = {
-            "accept": "*/*",
-            "accept-language": "en-US,en;q=0.9",
-            "authorization": "Bearer",
-            "cache-control": "no-cache",
-            "content-type": "application/json",
-            "origin": cls.url,
-            "pragma": "no-cache",
-            "priority": "u=1, i",
-            "referer": f"{cls.url}/",
-            "sec-ch-ua": '"Chromium";v="129", "Not=A?Brand";v="8"',
-            "sec-ch-ua-mobile": "?0",
-            "sec-ch-ua-platform": '"Linux"',
-            "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36",
-            "x-device-language": "en-US",
-            "x-device-platform": "web",
-            "x-device-uuid": device_uuid,
-            "x-device-version": "1.0.32"
-        }
-
-        async with ClientSession(headers=headers) as session:
-            if model in cls.chat_models:
-                data = {
-                    "messages": messages,
-                    "model": model,
-                    "personaId": cls.get_persona_id(model),
-                    "frequency_penalty": 0,
-                    "max_tokens": 4000,
-                    "presence_penalty": 0,
-                    "stream": stream,
-                    "temperature": 0.5,
-                    "top_p": 0.95
-                }
-
-                timeout = ClientTimeout(total=300)
-                try:
-                    async with session.post(cls.chat_api_endpoint, json=data, proxy=proxy, timeout=timeout) as response:
-                        if response.status not in (200, 201):
-                            error_text = await response.text()
-                            raise Exception(f"Error {response.status}: {error_text}")
-
-                        if stream:
-                            async def stream_content():
-                                async for line in response.content:
-                                    line = line.decode('utf-8').strip()
-                                    if line.startswith('data: '):
-                                        if line == 'data: [DONE]':
-                                            break
-                                        try:
-                                            chunk = json.loads(line[6:])
-                                            if 'choices' in chunk and len(chunk['choices']) > 0:
-                                                choice = chunk['choices'][0]
-                                                if 'delta' in choice:
-                                                    content = choice['delta'].get('content')
-                                                elif 'text' in choice:
-                                                    content = choice['text']
-                                                else:
-                                                    content = None
-                                                if content:
-                                                    yield content
-                                        except json.JSONDecodeError:
-                                            pass
-                            return stream_content()
-                        else:
-                            response_data = await response.json()
-                            if 'choices' in response_data and len(response_data['choices']) > 0:
-                                content = response_data['choices'][0]['message']['content']
-                                return content
-                            else:
-                                return ""
-                except Exception as e:
-                    logger.error(f"Error during request: {e}")
-                    raise
-            else:
-                # Handle image models or other cases if necessary
-                pass

api/routes.py

@@ -1,69 +0,0 @@
-# api/routes.py
-
-import json
-from fastapi import APIRouter, Depends, HTTPException, Request, Response
-from fastapi.responses import StreamingResponse
-from api.auth import verify_app_secret
-from api.models import ChatRequest
-from api.utils import process_non_streaming_response, process_streaming_response
-from api.providers import AmigoChat
-from api.logger import setup_logger
-
-logger = setup_logger(__name__)
-
-router = APIRouter()
-
-@router.options("/v1/chat/completions")
-@router.options("/api/v1/chat/completions")
-async def chat_completions_options():
-    return Response(
-        status_code=200,
-        headers={
-            "Access-Control-Allow-Origin": "*",
-            "Access-Control-Allow-Methods": "POST, OPTIONS",
-            "Access-Control-Allow-Headers": "Content-Type, Authorization",
-        },
-    )
-
-@router.get("/v1/models")
-@router.get("/api/v1/models")
-async def list_models():
-    allowed_models = [{"id": model, "name": model} for model in AmigoChat.models]
-    return {"object": "list", "data": allowed_models}
-
-@router.post("/v1/chat/completions")
-@router.post("/api/v1/chat/completions")
-async def chat_completions(
-    request: ChatRequest, app_secret: str = Depends(verify_app_secret)
-):
-    logger.info("Entering chat_completions route")
-    logger.info(f"Processing chat completion request for model: {request.model}")
-
-    valid_models = AmigoChat.models + list(AmigoChat.model_aliases.keys())
-
-    if request.model not in valid_models:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Model {request.model} is not allowed. Allowed models are: {', '.join(AmigoChat.models)}",
-        )
-
-    if request.stream:
-        logger.info("Streaming response")
-        return StreamingResponse(
-            process_streaming_response(request),
-            media_type="text/event-stream",
-            headers={"Cache-Control": "no-cache"},
-        )
-    else:
-        logger.info("Non-streaming response")
-        response = await process_non_streaming_response(request)
-        return Response(content=json.dumps(response), media_type="application/json")
-
-@router.get('/')
-@router.get('/healthz')
-@router.get('/ready')
-@router.get('/alive')
-@router.get('/status')
-@router.get("/health")
-def health_check(request: Request):
-    return Response(content=json.dumps({"status": "ok"}), media_type="application/json")

api/utils.py

@@ -1,90 +0,0 @@
-# api/utils.py
-
-from datetime import datetime
-import json
-import uuid
-from typing import Any, Dict, Optional, AsyncGenerator, List
-
-from fastapi import HTTPException
-from api.models import ChatRequest, Message
-from api.logger import setup_logger
-from api.providers import AmigoChat
-
-logger = setup_logger(__name__)
-
-async def process_streaming_response(request: ChatRequest) -> AsyncGenerator[str, None]:
-    logger.info("Processing streaming response with AmigoChat")
-    messages = [msg.dict() for msg in request.messages]
-
-    try:
-        async for content in await AmigoChat.generate_response(
-            model=request.model,
-            messages=messages,
-            stream=True
-        ):
-            timestamp = int(datetime.now().timestamp())
-            chunk = {
-                "id": f"chatcmpl-{uuid.uuid4()}",
-                "object": "chat.completion.chunk",
-                "created": timestamp,
-                "model": request.model,
-                "choices": [
-                    {
-                        "index": 0,
-                        "delta": {"content": content},
-                        "finish_reason": None,
-                    }
-                ],
-            }
-            yield f"data: {json.dumps(chunk)}\n\n"
-
-        # Indicate the end of the stream
-        end_chunk = {
-            "id": f"chatcmpl-{uuid.uuid4()}",
-            "object": "chat.completion.chunk",
-            "created": int(datetime.now().timestamp()),
-            "model": request.model,
-            "choices": [
-                {
-                    "index": 0,
-                    "delta": {},
-                    "finish_reason": "stop",
-                }
-            ],
-        }
-        yield f"data: {json.dumps(end_chunk)}\n\n"
-        yield "data: [DONE]\n\n"
-
-    except Exception as e:
-        logger.error(f"Error in streaming response: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-async def process_non_streaming_response(request: ChatRequest):
-    logger.info("Processing non-streaming response with AmigoChat")
-    messages = [msg.dict() for msg in request.messages]
-
-    try:
-        content = await AmigoChat.generate_response(
-            model=request.model,
-            messages=messages,
-            stream=False
-        )
-
-        return {
-            "id": f"chatcmpl-{uuid.uuid4()}",
-            "object": "chat.completion",
-            "created": int(datetime.now().timestamp()),
-            "model": request.model,
-            "choices": [
-                {
-                    "index": 0,
-                    "message": {"role": "assistant", "content": content},
-                    "finish_reason": "stop",
-                }
-            ],
-            "usage": None,
-        }
-
-    except Exception as e:
-        logger.error(f"Error in non-streaming response: {e}")
-        raise HTTPException(status_code=500, detail=str(e))