import asyncio
from nexusai_client import AIGateway

async def main():
    # Detects active keys in .env and routes: Free Tiers -> Paid Backups
    async with AIGateway.auto_fallback() as client:
        res = await client.generate_text("Explain transformer attention mechanisms.")
        print(f"Generated via: [{res.provider}] / Model: [{res.model}]")
        print(res.text)

if __name__ == "__main__":
    asyncio.run(main())

# Custom explicit chain: Cerebras -> Groq -> Gemini Free -> DeepSeek
custom_chain = ["cerebras", "groq", "gemini_free", "deepseek"]

async with AIGateway.with_fallback(custom_chain, timeout=20.0) as client:
    res = await client.generate_text("Summarize the news.")
    print(f"[{res.provider}] {res.text}")

import asyncio
from nexusai_client import AIGateway

async def main():
    async with AIGateway("groq") as client:
        print("Streaming token-by-token:")
        async for chunk in client.stream_text("Write a short story about artificial intelligence."):
            print(chunk, end="", flush=True)

if __name__ == "__main__":
    asyncio.run(main())

import asyncio
from nexusai_client import AIGateway

async def main():
    # Automatically selects the best Vision model (Gemini 2.5 Flash, Llama 3.2 Vision, Qwen 3.8 Vision, Aya Vision, Pixtral)
    async with AIGateway.auto_fallback_vision() as client:
        res = await client.analyze_image(
            prompt="Extract the invoice line items, tax rate, and total amount as JSON.",
            image="invoice_sample.png",
            json_mode=True,
        )
        print(f"Vision provider: {res.provider}")
        print(res.text)

if __name__ == "__main__":
    asyncio.run(main())

import asyncio
import json
from nexusai_client import AIGateway

async def main():
    async with AIGateway("groq") as client:
        res = await client.generate_text(
            prompt="Extract user profile from: 'John Doe, 32, Lead AI Architect at Zurich'",
            system_prompt="Output schema: {'name': str, 'age': int, 'role': str, 'city': str}",
            json_mode=True,
        )
        data = json.loads(res.text)
        print("Parsed JSON data:", data)

if __name__ == "__main__":
    asyncio.run(main())

import asyncio
from nexusai_client import AIGateway

async def main():
    # 1. Single provider inspection
    async with AIGateway("deepseek") as client:
        account = await client.get_account_info()
        print(account.format_summary())
        # Example output: "Solde restant: $4.99 | (Offert: $0.00) | Consommé: $0.0120"

    # 2. Parallel inspection across all configured providers
    all_accounts = await AIGateway.get_all_account_infos()
    for prov_name, info in all_accounts.items():
        print(f"[{prov_name.upper()}]: {info.format_summary()}")

if __name__ == "__main__":
    asyncio.run(main())

import asyncio
from nexusai_client import AIGateway

async def main():
    # List free models across OpenRouter
    async with AIGateway("openrouter") as client:
        models = await client.list_models(free_only=True)
        print(f"Found {len(models)} free models on OpenRouter:")
        for m in models[:5]:
            print(f" - {m.id} (Context: {m.context_length} tokens)")

    # Parallel discovery across all providers
    catalog = await AIGateway.list_all_available_models(free_only=True)
    for prov, m_list in catalog.items():
        print(f"Provider [{prov}] offers {len(m_list)} free models.")

if __name__ == "__main__":
    asyncio.run(main())

from nexusai_client import FunctionDefinition, ToolDefinition

weather_tool = ToolDefinition(
    function=FunctionDefinition(
        name="get_current_weather",
        description="Retrieve the current temperature and conditions for a given city.",
        parameters={
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "City and state/country, e.g. 'Tokyo, Japan'",
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Temperature unit",
                },
            },
            "required": ["location"],
        },
    )
)

import asyncio
from nexusai_client import AIGateway, ChatMessage

async def main():
    # Tools work seamlessly across single providers and auto-fallback chains!
    async with AIGateway.auto_fallback() as client:
        messages = [
            ChatMessage(role="user", content="What is the weather like in Tokyo right now?")
        ]
        
        response = await client.chat(messages=messages, tools=[weather_tool])

        if response.has_tool_calls:
            for call in response.tool_calls:
                print(f"🔧 Tool ID       : {call.id}")
                print(f"📌 Function Name : {call.name}")
                print(f"📦 Arguments     : {call.arguments}")
                # e.g. Arguments: {'location': 'Tokyo, Japan', 'unit': 'celsius'}
        else:
            print("💬 Normal Text Reply:", response.text)

if __name__ == "__main__":
    asyncio.run(main())

 ┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
 │                                   LEVEL 1: INTRA-PROVIDER SMART MODEL ROTATION                             │
 │                                                                                                             │
 │  1. gemini-3.5-flash-lite (500 RPD) ──► 2. gemini-3.1-flash-lite (500 RPD) ──► 3. gemini-flash-lite-latest   │
 │                                                                                                             │
 │       ▼ (If 429 Quota Exceeded)                                                                             │
 │  4. gemini-3.7-flash (20 RPD)       ──► 5. gemini-3.6-flash (20 RPD)       ──► 6. gemini-3.5-flash (20 RPD)   │
 │                                                                                                             │
 │       ▼ (If 429 Quota Exceeded)                                                                             │
 │  7. gemini-flash-latest             ──► 8. gemini-2.5-flash-lite (500 RPD) ──► 9. gemini-2.5-flash (20 RPD)   │
 │                                                                                                             │
 │       ▼ (If 429 Quota Exceeded)                                                                             │
 │  10. gemma-4-31b-it (14.4k RPD)     ──► 11. gemma-4-26b-a4b-it (14.4k RPD)                                  │
 └──────────────────────────────────────────────────────┬──────────────────────────────────────────────────────┘
                                                        │ (Only if ALL 11 Gemini models exhausted)
                                                        ▼
 ┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
 │                               LEVEL 2: INTER-PROVIDER AUTO-FALLBACK FAILOVER                                │
 │   Groq LPU ──► Cerebras CS-3 ──► Nvidia NIM ──► OrcaRouter ──► Mistral ──► Cohere ──► OpenRouter ──► DeepSeek│
 └─────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

import asyncio
from nexusai_client import AIGateway

async def main():
    # 1. Zero configuration auto-failover
    async with AIGateway("gemini_free") as client:
        res = await client.generate_text("Explain quantum entanglement simply.")
        print(f"✅ Served by model [{res.model}] (Provider: {res.provider}):\n{res.text}")

        # 2. Live rotation status and cooldown diagnostics
        info = await client.get_account_info()
        print(f"Active Model: {info.extra_details['current_active_model']}")
        print(f"Cooldown Status: {info.extra_details['models_in_cooldown']}")

if __name__ == "__main__":
    asyncio.run(main())

import asyncio
from nexusai_client import AIGateway

async def main():
    # Cascade: Gemini Free (11 models) -> Groq LPU -> Cerebras CS-3 -> Nvidia NIM -> OrcaRouter -> Mistral -> Cohere -> OpenRouter
    async with AIGateway.auto_fallback_free() as client:
        res = await client.generate_text("Write a concise summary of AI agents architecture.")
        print(f"✅ Served by [{res.provider} / {res.model}]:\n{res.text}")

if __name__ == "__main__":
    asyncio.run(main())