Provider Routing

from openai import OpenAI

client = OpenAI(
    base_url="https://api.parrotrouter.com/v1",
    api_key="your-api-key"
)

# Let ParrotRouter choose the best provider
response = client.chat.completions.create(
    model="gpt-4-turbo-preview",
    messages=[{"role": "user", "content": "Hello!"}]
)
print(f"Provider used: {response.provider}")  # e.g., "openai"

# Prefer specific provider
response = client.chat.completions.create(
    model="gpt-4-turbo-preview",
    messages=[{"role": "user", "content": "Hello!"}],
    extra_headers={
        "X-Provider-Preference": "anthropic,openai,google"
    }
)

# Force specific provider
response = client.chat.completions.create(
    model="gpt-4-turbo-preview",
    messages=[{"role": "user", "content": "Hello!"}],
    extra_headers={
        "X-Provider": "openai"  # Only use OpenAI
    }
)

# Use OpenAI's function calling
response = client.chat.completions.create(
    model="gpt-4-turbo-preview",
    messages=[{"role": "user", "content": "What's the weather?"}],
    tools=[{
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string"}
                }
            }
        }
    }],
    extra_headers={
        "X-Provider": "openai"  # OpenAI has native function calling
    }
)

# Use Anthropic's system prompts
response = client.chat.completions.create(
    model="claude-3-opus",
    messages=[
        {"role": "system", "content": "You are a helpful assistant"},
        {"role": "user", "content": "Help me code"}
    ],
    extra_headers={
        "X-Provider": "anthropic"  # Anthropic handles system prompts differently
    }
)

# Use Google's safety settings
response = client.chat.completions.create(
    model="gemini-pro",
    messages=[{"role": "user", "content": "Generate content"}],
    extra_headers={
        "X-Provider": "google",
        "X-Google-Safety-Settings": json.dumps({
            "harm_block_threshold": "BLOCK_MEDIUM_AND_ABOVE",
            "categories": ["HARM_CATEGORY_HATE_SPEECH", "HARM_CATEGORY_VIOLENCE"]
        })
    }
)

# Simple failover chain
response = client.chat.completions.create(
    model="gpt-4-turbo-preview",
    messages=[{"role": "user", "content": "Important request"}],
    extra_headers={
        "X-Provider-Fallbacks": "openai,anthropic,google",
        "X-Retry-On-Provider-Error": "true",
        "X-Max-Provider-Retries": "3"
    }
)

# Advanced failover configuration
failover_config = {
    "primary_provider": "openai",
    "fallback_rules": [
        {
            "provider": "anthropic",
            "trigger": ["rate_limit", "timeout"],
            "model_mapping": {
                "gpt-4-turbo-preview": "claude-3-opus",
                "gpt-3.5-turbo": "claude-3-haiku"
            }
        },
        {
            "provider": "google",
            "trigger": ["server_error", "model_overloaded"],
            "model_mapping": {
                "gpt-4-turbo-preview": "gemini-pro",
                "gpt-3.5-turbo": "gemini-pro"
            },
            "max_additional_latency_ms": 1000
        }
    ],
    "circuit_breaker": {
        "enabled": true,
        "failure_threshold": 5,
        "recovery_timeout": 300  # seconds
    }
}

response = client.chat.completions.create(
    model="gpt-4-turbo-preview",
    messages=[{"role": "user", "content": "Process with failover"}],
    extra_headers={
        "X-Failover-Config": json.dumps(failover_config)
    }
)

import requests

# Get provider health status
response = requests.get(
    "https://api.parrotrouter.com/v1/providers/health",
    headers={"Authorization": "Bearer your-api-key"}
)

health_data = response.json()
for provider in health_data['providers']:
    print(f"
{provider['name']}:")
    print(f"  Status: {provider['status']}")  # healthy, degraded, down
    print(f"  Uptime: {provider['uptime_percentage']}%")
    print(f"  Response time: {provider['avg_response_time_ms']}ms")
    print(f"  Error rate: {provider['error_rate']}%")
    print(f"  Rate limit usage: {provider['rate_limit_usage']}%")
    
    for model in provider['models']:
        print(f"    {model['name']}: {model['status']}")

# Subscribe to provider status updates
import websocket

ws = websocket.WebSocket()
ws.connect("wss://api.parrotrouter.com/v1/providers/health/stream", 
           header=["Authorization: Bearer your-api-key"])

while True:
    update = json.loads(ws.recv())
    if update['type'] == 'provider_status_change':
        print(f"Provider {update['provider']} is now {update['status']}")