Upload 10 files

.env

@@ -0,0 +1,9 @@
+FIREBASE_PROJECT_ID=telegram-storage-d867e
+FIREBASE_PRIVATE_KEY_ID=ed3500ce80c609b998e45849db7407c24af34290
+FIREBASE_PRIVATE_KEY="-----BEGIN PRIVATE KEY-----\nMIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQC+u4eVdX4f2Z3o\nrtSRixK1zpf+3qlANP6/oeQ3qYrwGC4YQ5B0Bfxr5EyzHlC4x6i9Vvnge/cb7bh9\n8J4m1yE5trpho4caOPSp63lCznVYcyG1fGVFSb0WJ40EgZvAtbVNC7kS+CzudE3p\nQ/U3iXB4COSlac/fsb1r2Mcbqb5svP/A+6j23jljwD4pgqKOmSgvCesTlpp/KRp8\nG6WZsnXfpP1Jvvd+9HkW3MzC0z24jKC7814JN0vU1yhsPuHZB6TW9FJuTgZPA5yR\ngMeKYDaemyZXpm3sB3A0fTcmOssX2A1h1U4TvOM6PKMJ2hj5B2o2ngsz1zJ7vrQK\n8oQlrDxpAgMBAAECggEASI1qPlqyrufnTucOOgzmgZ0EKXHGfQOLshahiuDl1n3E\nLvuoe9H5Got995a9CwT79YYbyB4vugJ77wA0EL89xsfw7wo27q0iuG43ssd5ULt+\n45vdo/UwRbimxkONHUmhnRyr+oDICq7YIjb1FPqleyua2ic9aTChxt/voWC47IBw\n+Vz586P+Q0+z/NYhHAJy4/MI/Du+6PutQQATVWp0RKS8MhRdxLpNFww/JJo+QaLd\nds39sGZbEy9H6xO1iT/P6i/zZ2vBMoAotGJhKywRgQl7rq6U9uroY0GylaDXd0Mh\nPjWwoxCYUGAcjnioP3VdzKlg89pvNfDX9B0WT8Ed5wKBgQD6PGOudL1uXxUQAcql\nhE8AcYaP49N52HNr+Kk2CPxtybG7yQT5oonW5tRakRFgwDYgfvV25A9j0ceSGmZC\nA4qxHHHgQ9FyZW4P7f9UZSqcgq3HHbcPQkSnUuRNTHG4/tCaqIRWUjWXx9lYkH3x\n6tg4jDATjJzTzsrg1FnR+cRvYwKBgQDDIEGVIxg23WaIzIDkEd4YlEdkK02ZDBlv\n4utVfhM4ckdEkz2myh8l9zDbi498L7ZF+b75jFkizSPbZ9SqHRRm8O5oYDZSTSs7\nlImst71m6tDqGMyuAumCzI4rLGEh6TCu3u6iQlcFhppic4PF6O1p3hIAqB9gkP1Q\njS3EHj5MwwKBgQCDmm0GXCkgOetW3spX4Ey4O/x8AmK/CyIw37cGTxWLG+9YhnES\nZPQ/TGjUNMVB7/THhF3OKEUbx0FBSpcLEtfHK+GMA77MfiGzSQTmusn9RBDmzm7v\nHHgE0+hz6sdIduL447WtvFCpQZbCKEPEjjEnFDtYnLQCBRjXw3Z1ovk3ZwKBgGX4\nkG1o5rmdYH0zKlSGBeQgcWKmwqmtyglPtB58gXzpM9dhf0GPtVF46f6B451Jrd7J\n0oTFVLu8KvX5QAkao1Pcqyq+xQSjsWk0ifJKH2AObNk51pVFjlS9o7pqOeSn4box\nZNJFCwcnPb0fkwi1XoUJ+ayAL82eV9NlxDoOeA5TAoGBAKBAh+QkYWu+Os8ughrJ\n393q6u1Quc1x6ZF/ZZX7WpSA1PvibfNHMHp1ba8cRtMjiXR1NexRfHcfZ6/c4cKf\npWYfMR1km/rKdVzxR6ZKcfGvLjyWdacz9OBKMC5rsZHgcbOeS4HiGt6ogZD46ZXl\nSDWbthk9NAOyllnGt04EAJ7/\n-----END PRIVATE KEY-----\n"
+FIREBASE_CLIENT_EMAIL=firebase-adminsdk-jne2o@telegram-storage-d867e.iam.gserviceaccount.com
+FIREBASE_CLIENT_ID=109271910426425629178
+FIREBASE_CLIENT_X509_CERT_URL=https://www.googleapis.com/robot/v1/metadata/x509/firebase-adminsdk-jne2o%40telegram-storage-d867e.iam.gserviceaccount.com
+DATABASE_URL=https://telegram-storage-d867e-default-rtdb.firebaseio.com/
+AIROPS_API_URL=https://app.airops.com/public_api/airops_apps/
+AMIGO_BASE_URL=https://api.amigochat.io/v1/chat/completions

API_provider.py

@@ -0,0 +1,110 @@
+import json
+import uuid
+from typing import Iterator, Union, List, Dict
+from dotenv import load_dotenv; load_dotenv()
+import os
+import requests
+
+AVAILABLE_MODELS = [
+    "meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo",
+    "o1-mini",
+    "claude-3-sonnet-20240229",
+    "gemini-1.5-pro",
+    "gemini-1.5-flash",
+    "o1-preview",
+    "gpt-4o"
+]
+
+def API_Inference(
+    messages: List[Dict[str, str]],
+    model: str = "meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo",
+    stream: bool = False,
+    max_tokens: int = 4000,
+    temperature: float = 0.7,
+    top_p: float = 0.95,
+) -> Union[str, Iterator[str], None]:
+    if model not in AVAILABLE_MODELS:
+        raise ValueError(
+            f"Model {model} not available. Available models: {', '.join(AVAILABLE_MODELS)}"
+        )
+    
+    if model == "claude-3-sonnet-20240229":
+        messages = [{"role": "system", "content": "."}] + [msg for msg in messages if msg["role"] != "system"]
+
+    api_endpoint = os.environ.get("AMIGO_BASE_URL")
+    headers = {
+        "Accept": "*/*",
+        "Accept-Encoding": "gzip, deflate, br, zstd",
+        "Authorization": "Bearer ",
+        "Content-Type": "application/json",
+        "User-Agent": (
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+            "AppleWebKit/537.36 (KHTML, like Gecko) "
+            "Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0"
+        ),
+        "X-Device-UUID": str(uuid.uuid4()),
+    }
+
+    payload = {
+        "messages": messages,
+        "model": model,
+        "max_tokens": max_tokens,
+        "stream": stream,
+        "presence_penalty": 0,
+        "temperature": temperature,
+        "top_p": top_p,
+    }
+
+    try:
+        response = requests.post(api_endpoint, headers=headers, json=payload, stream=stream)
+        response.raise_for_status()
+    except requests.exceptions.RequestException as e:
+        print("An error occurred while making the request:", e)
+        return None
+
+    def process_response() -> Iterator[str]:
+        for line in response.iter_lines():
+            if line:
+                # Decode the line from bytes to string
+                decoded_line = line.decode('utf-8').strip()
+                if decoded_line.startswith("data: "):
+                    data_str = decoded_line[6:]
+                    if data_str == "[DONE]":
+                        break
+                    try:
+                        # Load the JSON data
+                        data_json = json.loads(data_str)
+                        
+                        # Extract the content from the response
+                        choices = data_json.get("choices", [])
+                        if choices:
+                            delta = choices[0].get("delta", {})
+                            content = delta.get("content", "")
+                            if content:
+                                yield content 
+                    except json.JSONDecodeError:
+                        print(f"Received non-JSON data: {data_str}")
+
+    if stream:
+        return process_response()
+    else:
+        return "".join(process_response())
+
+if __name__ == "__main__":
+    # Example usage with the new format
+    conversation = [
+        {"role": "system", "content": "You are a helpful and friendly AI assistant."},
+        {"role": "user", "content": "What is the capital of France?"},
+        {"role": "assistant", "content": "Paris"},
+        {"role": "user", "content": "Who are you. Are you GPT-4o or gpt-3.5?"}
+    ]
+
+    # For non-streaming response
+    response = API_Inference(conversation, stream=False, model="claude-3-sonnet-20240229")
+    print(response)
+
+    print("--" * 50)
+
+    # # For streaming response
+    for chunk in API_Inference(conversation, stream=True, model="gpt-4o"):
+        print(chunk, end="", flush=True)

Dockerfile

@@ -0,0 +1,20 @@
+# Use an official Python runtime as the base image
+FROM python:3.9-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements file into the container
+COPY requirements.txt .
+
+# Install the required packages
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application code into the container
+COPY . .
+
+# Expose the port that FastAPI will run on
+EXPOSE 7860
+
+# Command to run the FastAPI application
+CMD ["uvicorn", "SERVER:app", "--host", "0.0.0.0", "--port", "7860"]

RUN.py

@@ -0,0 +1,40 @@
+from openai import OpenAI
+
+# Set up the client
+client = OpenAI(
+    base_url="http://localhost:8000/v1",  # Update this if you're not running locally
+    api_key="C0TNRcI8EuhmXpRTNiNsGbUHWBG6KFQt"  # This can be any string as we're not actually validating it
+)
+
+def test_non_streaming():
+    print("Testing non-streaming response:")
+    completion = client.chat.completions.create(
+        model="claude-3.5-sonnet",
+        messages=[
+            {"role": "system", "content": "."},
+            {"role": "user", "content": "how many 'r' are there in strawberry"}
+        ]
+    )
+    print(completion)
+    # print(completion.choices[0].message.content)
+
+def test_streaming():
+    print("\nTesting streaming response:")
+    completion = client.chat.completions.create(
+        model="o1-preview",
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": "how many 'r' are there in strawberry"}
+        ],
+        stream=True
+    )
+    for chunk in completion:
+        # print(chunk)
+        if chunk.choices[0].delta.content is not None:
+            print(chunk.choices[0].delta.content, end="", flush=True)
+    print()
+
+if __name__ == "__main__":
+    test_non_streaming()
+    print("-"*50)
+    test_streaming()

SERVER.py

@@ -0,0 +1,135 @@
+import uuid
+from fastapi import FastAPI, HTTPException, Depends
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+from typing import List, Optional
+import json
+from API_provider import API_Inference
+from core_logic import (
+    check_api_key_validity,
+    update_request_count,
+    get_rate_limit_status,
+    get_subscription_status,
+    get_available_models,
+    get_model_info,
+)
+
+app = FastAPI()
+security = HTTPBearer()
+
+class Message(BaseModel):
+    role: str
+    content: str
+
+class ChatCompletionRequest(BaseModel):
+    model: str
+    messages: List[Message]
+    stream: Optional[bool] = False
+    max_tokens: Optional[int] = 4000
+    temperature: Optional[float] = 0.5
+    top_p: Optional[float] = 0.95
+
+def get_api_key(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    return credentials.credentials
+
+@app.post("/v1/chat/completions")
+async def chat_completions(request: ChatCompletionRequest, api_key: str = Depends(get_api_key)):
+    try:
+        # Check API key validity and rate limit
+        is_valid, error_message = check_api_key_validity(api_key)
+        if not is_valid:
+            raise HTTPException(status_code=401, detail=error_message)
+
+        messages = [{"role": msg.role, "content": msg.content} for msg in request.messages]
+        
+        # Get model info
+        model_info = get_model_info(request.model)
+        if not model_info:
+            raise HTTPException(status_code=400, detail="Invalid model specified")
+        
+        if "meta-llama-405b-turbo" in request.model:
+            request.model = "meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo"
+
+        if "claude-3.5-sonnet" in request.model:
+            request.model = "claude-3-sonnet-20240229"
+
+        if request.stream:
+            def generate():
+                for chunk in API_Inference(messages, model=request.model, stream=True,
+                                        max_tokens=request.max_tokens,
+                                        temperature=request.temperature,
+                                        top_p=request.top_p):
+                    yield f"data: {json.dumps({'choices': [{'delta': {'content': chunk}}]})}\n\n"
+                yield "data: [DONE]\n\nCredits used: 1\n\n"
+
+            
+            # Update request count
+            if request.model == "gpt-4o" or request.model == "claude-3-sonnet-20240229" or request.model == "gemini-1.5-pro" or request.model == "gemini-1-5-flash" or request.model == "meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo":
+                update_request_count(api_key, 1) 
+
+            elif request.model == "o1-mini":
+                update_request_count(api_key, 2)
+
+            elif request.model == "o1-preview":
+                update_request_count(api_key, 3)
+                
+            return StreamingResponse(generate(), media_type="text/event-stream")
+        else:
+            response = API_Inference(messages, model=request.model, stream=False,
+                                  max_tokens=request.max_tokens,
+                                  temperature=request.temperature,
+                                  top_p=request.top_p)
+            
+            # Update request count
+            update_request_count(api_key, 1)  # Assume 1 credit per request, adjust as needed
+
+            return {
+                "id": f"chatcmpl-{uuid.uuid4()}",
+                "object": "chat.completion",
+                "created": int(uuid.uuid1().time // 1e7),
+                "model": request.model,
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {
+                            "role": "assistant",
+                            "content": response
+                        },
+                        "finish_reason": "stop"
+                    }
+                ],
+                "usage": {
+                    "prompt_tokens": len(' '.join(msg['content'] for msg in messages).split()),
+                    "completion_tokens": len(response.split()),
+                    "total_tokens": len(' '.join(msg['content'] for msg in messages).split()) + len(response.split())
+                },
+                "credits_used": 1
+            }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/rate_limit/status")
+async def get_rate_limit_status_endpoint(api_key: str = Depends(get_api_key)):
+    is_valid, error_message = check_api_key_validity(api_key, check_rate_limit=False)
+    if not is_valid:
+        raise HTTPException(status_code=401, detail=error_message)
+    return get_rate_limit_status(api_key)
+
+@app.get("/subscription/status")
+async def get_subscription_status_endpoint(api_key: str = Depends(get_api_key)):
+    is_valid, error_message = check_api_key_validity(api_key, check_rate_limit=False)
+    if not is_valid:
+        raise HTTPException(status_code=401, detail=error_message)
+    return get_subscription_status(api_key)
+
+@app.get("/models")
+async def get_available_models_endpoint(api_key: str = Depends(get_api_key)):
+    is_valid, error_message = check_api_key_validity(api_key, check_rate_limit=False)
+    if not is_valid:
+        raise HTTPException(status_code=401, detail=error_message)
+    return {"data": [{"id": model} for model in get_available_models().values()]}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

core_logic.py

@@ -0,0 +1,136 @@
+# api_key_manager.py
+
+from dotenv import load_dotenv; load_dotenv()
+import os
+import firebase_admin
+from firebase_admin import credentials, firestore
+import datetime
+from pytz import UTC
+
+# Initialize Firebase Admin SDK
+cred = credentials.Certificate({
+    "type": "service_account",
+    "project_id": os.environ.get("FIREBASE_PROJECT_ID"),
+    "private_key_id": os.environ.get("FIREBASE_PRIVATE_KEY_ID"),
+    "private_key": os.environ.get("FIREBASE_PRIVATE_KEY").replace("\\n", "\n"),
+    "client_email": os.environ.get("FIREBASE_CLIENT_EMAIL"),
+    "client_id": os.environ.get("FIREBASE_CLIENT_ID"),
+    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+    "token_uri": "https://oauth2.googleapis.com/token",
+    "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+    "client_x509_cert_url": os.environ.get("FIREBASE_CLIENT_X509_CERT_URL")
+})
+
+try:
+    firebase_admin.get_app()
+except ValueError:
+    firebase_admin.initialize_app(cred)
+
+db = firestore.client()
+
+def get_user_info(api_key):
+    doc = db.collection('Users').document(api_key).get(field_paths=[
+        'subscription_plan', 'requests_remaining', 'paid_models', 'ai_engine_secret_key'
+    ])
+    if doc.exists:
+        return doc.to_dict()
+    else:
+        return None
+
+def check_api_key_validity(api_key, check_rate_limit=True):
+    user_data = get_user_info(api_key)
+    if not user_data:
+        return False, "Invalid API key"
+   
+    if check_rate_limit:
+        if user_data.get('requests_remaining', 0) <= 0:
+            return False, "Rate limit exceeded. Kindly Upgrade to Premium for using the Devs Do Code API"
+    return True, ""
+
+def update_request_count(api_key, credits_used):
+    user_ref = db.collection('Users').document(api_key)
+    user_doc = user_ref.get(field_paths=['requests_remaining'])
+    if user_doc.exists:
+        requests_remaining = user_doc.to_dict().get('requests_remaining', 0)
+        new_requests_remaining = requests_remaining - credits_used  # Subtract credits used
+        user_ref.update({'requests_remaining': new_requests_remaining})
+        return True
+    else:
+        return False
+
+def get_rate_limit_status(api_key):
+    user_doc = db.collection('Users').document(api_key).get(field_paths=['requests_remaining'])
+    if not user_doc.exists:
+        return {"error": "Invalid API key"}
+   
+    requests_remaining = user_doc.to_dict().get('requests_remaining', 0)
+    return {"requests_remaining": requests_remaining}
+
+def get_subscription_status(api_key):
+    user_doc = db.collection('Users').document(api_key).get(field_paths=['subscription_plan'])
+    if not user_doc.exists:
+        return {"error": "Invalid API key"}
+   
+    subscription_plan = user_doc.to_dict().get('subscription_plan', 'Free')
+    return {"subscription_plan": subscription_plan}
+
+def get_available_models():
+    models = {
+        "gpt-4o": {
+            "name": "gpt-4o-2024-08-06",
+            "description": "Our high-intelligence flagship model for complex, multi-step tasks. GPT-4o is multimodal, processing text, audio, and images, and is faster and 50% cheaper than its predecessor. It has a maximum output of 16,384 tokens, if o1-mini is used",
+            "max_tokens": 4096,
+            "context_window": 128000,
+            "training_data": "Up to October 2023"
+            },
+        "o1-preview": {
+            "name": "o1-preview-2024-09-12",
+            "description": "OpenAI o1 is a new large language model optimized for complex reasoning tasks, utilizing reinforcement learning to enhance its problem-solving capabilities. It excels in STEM subjects and demonstrates impressive performance on challenging benchmarks, including achieving 83% accuracy on the AIME mathematics competition, significantly outperforming previous models like GPT-4o.",
+            "max_tokens": 32768,
+            "context_window": 128000,
+            "training_data": "Up to September 2024"
+            },
+        "claude-3.5-sonnet": {
+            "name": "claude-3.5-sonnet-latest",
+            "description": "Claude 3.5 Sonnet is a highly capable model developed by Anthropic, optimized for complex reasoning tasks and demonstrating significant advancements in performance compared to its predecessors. It excels in areas such as coding, multi-step workflows, and interpreting visual data.",
+            "context_window": 8192,
+            "max_tokens": 200000,
+            "training_data": "Up to April 2024"
+            },
+        "gemini-1.5-pro": {
+            "name": "Gemini-1.5-Pro",
+            "description": "Gemini is an AI chatbot developed by Google. Formerly known as Bard, it was released to the public in 2023. Gemini-1.5-Pro is an improved version of the model, offering more accurate and informative responses.",
+            "max_tokens": 4096,
+            "context_window": 131072,
+            "training_data": "Up to 2023"
+            },
+        "gemini-1-5-flash": {
+            "name": "Gemini 1.5 Flash",
+            "description": "A lighter-weight model than 1.5 Pro, designed to be fast and efficient to serve at scale. It's optimized for high-volume, high-frequency tasks and features a breakthrough long context window, making it highly capable of multimodal reasoning across vast amounts of information.",
+            "max_tokens": 4096,
+            "context_window": 131072, 
+            "training_data": "Up to 2024"
+            },
+        "o1-mini": {
+            "name": "o1-mini",
+            "description": "The o1-mini model is a cost-effective and efficient AI model designed for quick reasoning tasks, particularly in STEM fields such as coding and mathematics. It is optimized for speed and lower resource consumption, making it an ideal choice for applications requiring fast responses without the need for extensive world knowledge.",
+            "max_tokens": 65536,
+            "context_window": 128000,
+            "training_data": "Up to October 2023"
+        },
+        "meta-llama-405b-turbo": {
+            "name": "Meta-Llama-3.1-405B-Instruct-Turbo",
+            "description": "Meta-Llama-3.1-405B-Instruct-Turbo is a state-of-the-art AI model designed for instruction-based tasks. It excels in generating coherent and contextually relevant responses, making it suitable for applications in conversational AI, content creation, and more. This model leverages advanced techniques in natural language processing to provide high-quality outputs.",
+            "max_tokens": 4096,
+            "context_window": 128000,
+            "training_data": "Up to October 2023"
+        }
+    }
+    return models
+
+def get_model_info(model_name):
+    models = get_available_models()
+    return models.get(model_name)
+
+if __name__ == "__main__":
+    print(get_model_info("gpt4o"))

database_initializer.py

@@ -0,0 +1,26 @@
+import os
+import firebase_admin
+from firebase_admin import credentials, firestore
+from dotenv import load_dotenv; load_dotenv()
+
+# Initialize Firebase Admin SDK
+
+# Initialize Firebase app with credentials and options
+cred = credentials.Certificate({
+    "type": "service_account",
+    "project_id": os.environ.get("FIREBASE_PROJECT_ID"),
+    "private_key_id": os.environ.get("FIREBASE_PRIVATE_KEY_ID"),
+    "private_key": os.environ.get("FIREBASE_PRIVATE_KEY").replace("\\n", "\n"),
+    "client_email": os.environ.get("FIREBASE_CLIENT_EMAIL"),
+    "client_id": os.environ.get("FIREBASE_CLIENT_ID"),
+    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+    "token_uri": "https://oauth2.googleapis.com/token",
+    "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+    "client_x509_cert_url": os.environ.get("FIREBASE_CLIENT_X509_CERT_URL")
+})
+try:
+    firebase_admin.get_app()
+except ValueError:
+    firebase_admin.initialize_app(cred, {
+        'databaseURL': os.environ.get("DATABASE_URL")
+    })

problems.md

@@ -0,0 +1,21 @@
+```json
+"gemini-1.5-pro": {
+            "name": "gemini-1.5-pro",
+            "description": "",
+        },
+```
+
+
+I am providing you the name of the AI model and Google. I am providing you how to fill the extra details -->
+
+```json
+"gpt-4o": {
+            "name": "gpt-4o-2024-08-06",
+            "description": "Our high-intelligence flagship model for complex, multi-step tasks. GPT-4o is multimodal, processing text, audio, and images, and is faster and 50% cheaper than its predecessor. It has a maximum output of 16,384 tokens, if o1-mini is used",
+            "max_tokens": 4096,
+            "context_window": 128000,
+            "training_data": "Up to October 2023"
+            },
+```
+
+You have to provide the complete json data along with name description, max token, context, window and training data of that specific ai model. After searching on Internet

requirements.txt

@@ -0,0 +1,9 @@
+fastapi==0.110.2
+Flask==3.0.3
+Requests==2.31.0
+uvicorn==0.29.0
+python-dotenv==1.0.1
+firebase-admin
+colorama
+pytz
+pydantic==2.9.2

test_check.py

@@ -0,0 +1,68 @@
+import requests
+import json
+
+BASE_URL = "http://localhost:8000"
+API_KEY = "C0TNRcI8EuhmXpRTNiNsGbUHWBG6KFQt"  # Replace with a valid API key
+
+headers = {
+    "Content-Type": "application/json",
+    "Authorization": f"Bearer {API_KEY}"  # Use Bearer token authentication
+}
+
+def test_chat_completions_non_stream():
+    url = f"{BASE_URL}/v1/chat/completions"
+    payload = {
+        "model": "meta-llama-405b-turbo",
+        "messages": [
+            {"role": "user", "content": "Hello, how are you?"},
+        ],
+    }
+    print("Chat Completions Non Streaming Response:")
+    response = requests.post(url, headers=headers, json=payload)
+    print(json.dumps(response.json(), indent=2))
+    print("\n")
+
+def test_chat_completions_stream():
+    url = f"{BASE_URL}/v1/chat/completions"
+    payload = {
+        "model": "meta-llama-405b-turbo",
+        "messages": [
+            {"role": "user", "content": "Hello, how are you?"},
+        ],
+        "stream": True,
+    }
+    print("Chat Completions Streaming Response:")
+    response = requests.post(url, headers=headers, json=payload, stream=True)
+    for chunk in response.iter_lines():
+        if chunk:
+            print(chunk.decode("utf-8").replace("data: ", "").strip(), end="\n", flush=True)
+
+    print("\n")
+
+def test_rate_limit_status():
+    url = f"{BASE_URL}/rate_limit/status"  # Updated endpoint
+    response = requests.get(url, headers=headers)
+    print("Rate Limit Status Response:")
+    print(json.dumps(response.json(), indent=2))
+    print("\n")
+
+def test_subscription_status():
+    url = f"{BASE_URL}/subscription/status"  # Updated endpoint
+    response = requests.get(url, headers=headers)
+    print("Subscription Status Response:")
+    print(json.dumps(response.json(), indent=2))
+    print("\n")
+
+def test_available_models():
+    url = f"{BASE_URL}/models"  # Updated endpoint
+    response = requests.get(url, headers=headers)
+    print("Available Models Response:")
+    print(json.dumps(response.json(), indent=2))
+    print("\n")
+
+if __name__ == "__main__":
+    test_chat_completions_non_stream()
+    test_chat_completions_stream()
+    test_rate_limit_status()
+    test_subscription_status()
+    test_available_models()