[ User Request ] 
       │
       ▼ (1. Payload Bloat: Prompt tidak terkompresi)
[ Backend Service ] 
       │
       ▼ (2. Connection Overhead: Tanpa HTTP Keep-Alive / HTTP/2)
[ Network Transit ] 
       │
       ▼ (3. Blind Routing: Model kelas berat untuk tugas sepele)
[ AI Provider Engine ] ──► (4. Memory Waste: Ketiadaan Context Caching)

[ User Prompt ]
          │
          ▼
┌──────────────────┐      HIT      ┌──────────────────────┐
│  Semantic Cache  │ ────────────► │ Return Cached Result │
│ (Embedding Sim)  │               └──────────────────────┘
└──────────────────┘
          │ MISS
          ▼
┌──────────────────┐
│  Intent Classifier│ ──► Low Complexity  ──► Gemini 1.5 Flash / DeepSeek V3
│ (Lightweight LLM) │ ──► High Complexity ──► Claude 3.5 Sonnet / GPT-4o
└──────────────────┘
          │
          ▼
┌────────────────────────────────────────────────────────┐
│             AiStudio.id API Gateway                    │
│   (Single Endpoint, Multi-Provider, Token Tracking)    │
└────────────────────────────────────────────────────────┘

import os
import asyncio
import logging
import httpx
from typing import AsyncGenerator, Dict, Any, Optional
from pydantic import BaseModel, Field

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("AI-Client")

class TaskComplexity(BaseModel):
    tier: str = Field(description="Klasifikasi kompleksitas: 'flash', 'balanced', atau 'reasoning'")
    requires_code: bool
    estimated_context_tokens: int

class ResilientAIClient:
    """
    Klien AI asinkron dengan connection pooling, failover terotomasi,
    dan integrasi ke AiStudio.id API Gateway.
    """
    def __init__(self, api_key: str, base_url: str = "https://api.aistudio.id/v1"):
        self.api_key = api_key
        self.base_url = base_url
        # Menggunakan HTTP/2 dan batas koneksi persisten untuk efisiensi soket
        limits = httpx.Limits(max_keepalive_connections=50, max_connections=200, keepalive_expiry=30.0)
        self.client = httpx.AsyncClient(
            base_url=self.base_url,
            headers={
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json",
            },
            limits=limits,
            http2=True,
            timeout=httpx.Timeout(connect=5.0, read=45.0, write=5.0, pool=5.0)
        )

    def _resolve_model_name(self, complexity: str) -> str:
        """Dynamic routing model berdasarkan kebutuhan kognitif beban kerja."""
        routing_map = {
            "flash": "google/gemini-1.5-flash",
            "balanced": "deepseek/deepseek-chat",
            "reasoning": "anthropic/claude-3-5-sonnet"
        }
        return routing_map.get(complexity, "google/gemini-1.5-flash")

    async def generate_stream(
        self,
        prompt: str,
        system_prompt: str = "You are a concise, high-efficiency assistant.",
        tier: str = "flash",
        max_retries: int = 3
    ) -> AsyncGenerator[str, None]:
        """
        Streaming response dengan retry exponential backoff transparan.
        """
        model = self._resolve_model_name(tier)
        payload = {
            "model": model,
            "messages": [
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": prompt}
            ],
            "stream": True,
            "temperature": 0.2, # Menurunkan keacakan untuk efisiensi deterministik
        }

        delay = 1.0
        for attempt in range(1, max_retries + 1):
            try:
                async with self.client.stream("POST", "/chat/completions", json=payload) as response:
                    if response.status_code == 429:
                        logger.warning(f"Rate limited(429). Percobaan {attempt}/{max_retries}. Backoff {delay}s.")
                        await asyncio.sleep(delay)
                        delay *= 2
                        continue
                    
                    response.raise_for_status()
                    
                    async for line in response.aiter_lines():
                        if line.startswith("data: "):
                            token_data = line.removeprefix("data: ").strip()
                            if token_data == "[DONE]":
                                break
                            # Di aplikasi riil, lakukan parsing JSON payload delta chunk
                            yield token_data
                    return

            except (httpx.TransportError, httpx.HTTPStatusError) as exc:
                logger.error(f"Kesalahan jaringan pada percobaan {attempt}: {str(exc)}")
                if attempt == max_retries:
                    raise RuntimeError(f"Gagal mengeksekusi inferensi setelah {max_retries} percobaan.") from exc
                await asyncio.sleep(delay)
                delay *= 2

    async def close(self):
        await self.client.aclose()

# Contoh penggunaan operasional
async def main():
    API_KEY = os.getenv("AISTUDIO_API_KEY", "sk-live-aistudio-sample-key")
    ai_service = ResilientAIClient(api_key=API_KEY)

    print("--- Mengirim Permintaan Inferensi Terstruktur ---")
    try:
        # Menjalankan tugas klasifikasi ringan pada tier hemat
        async for chunk in ai_service.generate_stream(
            prompt="Ekstraksi nama entitas dan nilai transaksi dari: 'Budi mentransfer Rp 500.000 ke BCA'",
            tier="flash"
        ):
            print(chunk, end="", flush=True)
        print("\n")
    finally:
        await ai_service.close()

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

┌───────────────────────────────────────────────────────────┐
│                      Microservices                        │
│         (Auth, Checkout, Support, Data Engine)            │
└─────────────────────────────┬─────────────────────────────┘
                              │
                              ▼ (Single OpenAI-Compatible API)
┌───────────────────────────────────────────────────────────┐
│                 AiStudio.id API Gateway                   │
│  ┌───────────────────┬─────────────────────────────────┐  │
│  │ Local IDR Billing │ Unified Observability & Telemetry│  │
│  ├───────────────────┼─────────────────────────────────┤  │
│  │ Automatic Failover│ Global Low-Latency Edge Proxy   │  │
│  └───────────────────┴─────────────────────────────────┘  │
└──────┬──────────────────────┬──────────────────────┬──────┘
       │                      │                      │
       ▼                      ▼                      ▼
┌──────────────┐       ┌──────────────┐       ┌──────────────┐
│  Anthropic   │       │    OpenAI    │       │    Google    │
│(Claude 3.5 S)│       │  (GPT-4o)    │       │(Gemini Flash)│
└──────────────┘       └──────────────┘       └──────────────┘