The AI IPO Sprint and Apple WWDC 2026: A New Chapter in AI Capitalization and Consumer AI

// llm_gateway.go
// High-Performance AI Multi-Model Routing Gateway - Go Implementation
// Supports OpenAI, Anthropic, Google Gemini with intelligent routing and load balancing

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"sort"
	"strings"
	"sync"
	"time"
)

// ProviderType identifies the AI model provider
type ProviderType string

const (
	ProviderOpenAI    ProviderType = "openai"
	ProviderAnthropic ProviderType = "anthropic"
	ProviderGemini    ProviderType = "gemini"
)

// ModelCapability describes a model's routing attributes
type ModelCapability struct {
	Provider      ProviderType  `json:"provider"`
	ModelName     string        `json:"model_name"`
	CostPer1KIn   float64       `json:"cost_per_1k_in"`
	CostPer1KOut  float64       `json:"cost_per_1k_out"`
	ContextWindow int           `json:"context_window"`
	AvgLatency    time.Duration `json:"avg_latency"`
	IsAvailable   bool          `json:"is_available"`
	Priority      int           `json:"priority"`
}

// ModelRegistry manages the model catalog
type ModelRegistry struct {
	mu     sync.RWMutex
	models map[string]*ModelCapability
}

func NewModelRegistry() *ModelRegistry {
	return &ModelRegistry{
		models: make(map[string]*ModelCapability),
	}
}

func (r *ModelRegistry) Register(key string, m *ModelCapability) {
	r.mu.Lock()
	defer r.mu.Unlock()
	r.models[key] = m
}

func (r *ModelRegistry) ListAvailable() []*ModelCapability {
	r.mu.RLock()
	defer r.mu.RUnlock()
	var result []*ModelCapability
	for _, m := range r.models {
		if m.IsAvailable {
			result = append(result, m)
		}
	}
	return result
}

// RouterStrategy defines the interface for routing algorithms
type RouterStrategy interface {
	Select(models []*ModelCapability, req *ChatRequest) *ModelCapability
}

// CostOptimizedStrategy picks the cheapest model that meets requirements
type CostOptimizedStrategy struct{}

func (s *CostOptimizedStrategy) Select(models []*ModelCapability, req *ChatRequest) *ModelCapability {
	if len(models) == 0 {
		return nil
	}
	sort.Slice(models, func(i, j int) bool {
		costI := models[i].CostPer1KIn + models[i].CostPer1KOut
		costJ := models[j].CostPer1KIn + models[j].CostPer1KOut
		return costI < costJ
	})
	for _, m := range models {
		if req.EstimatedTokens <= m.ContextWindow {
			return m
		}
	}
	return models[0]
}

// LatencyOptimizedStrategy picks the fastest model
type LatencyOptimizedStrategy struct{}

func (s *LatencyOptimizedStrategy) Select(models []*ModelCapability, req *ChatRequest) *ModelCapability {
	if len(models) == 0 {
		return nil
	}
	sort.Slice(models, func(i, j int) bool {
		return models[i].AvgLatency < models[j].AvgLatency
	})
	for _, m := range models {
		if req.EstimatedTokens <= m.ContextWindow {
			return m
		}
	}
	return models[0]
}

// PriorityFailoverStrategy uses priority-based fallback
type PriorityFailoverStrategy struct{}

func (s *PriorityFailoverStrategy) Select(models []*ModelCapability, req *ChatRequest) *ModelCapability {
	if len(models) == 0 {
		return nil
	}
	sort.Slice(models, func(i, j int) bool {
		return models[i].Priority < models[j].Priority
	})
	for _, m := range models {
		if m.IsAvailable && req.EstimatedTokens <= m.ContextWindow {
			return m
		}
	}
	for _, m := range models {
		if m.IsAvailable {
			return m
		}
	}
	return nil
}

// ChatRequest represents a unified chat request
type ChatRequest struct {
	Messages        []Message `json:"messages"`
	EstimatedTokens int       `json:"estimated_tokens"`
	RouteStrategy   string    `json:"route_strategy,omitempty"`
	Tier            string    `json:"tier,omitempty"`
}

type Message struct {
	Role    string `json:"role"`
	Content string `json:"content"`
}

// AIAdapter abstracts provider-specific API differences
type AIAdapter interface {
	Chat(ctx context.Context, req *ChatRequest) (*ChatResponse, error)
}

type ChatResponse struct {
	Content   string `json:"content"`
	Model     string `json:"model"`
	Provider  string `json:"provider"`
	TokensIn  int    `json:"tokens_in"`
	TokensOut int    `json:"tokens_out"`
	LatencyMs int64  `json:"latency_ms"`
}

// OpenAIAdapter implements AIAdapter for OpenAI
type OpenAIAdapter struct {
	apiKey  string
	baseURL string
	client  *http.Client
}

func NewOpenAIAdapter(apiKey string) *OpenAIAdapter {
	return &OpenAIAdapter{
		apiKey:  apiKey,
		baseURL: "https://api.openai.com/v1",
		client:  &http.Client{Timeout: 60 * time.Second},
	}
}

func (a *OpenAIAdapter) Chat(ctx context.Context, req *ChatRequest) (*ChatResponse, error) {
	payload := map[string]interface{}{
		"model":    "gpt-4o",
		"messages": req.Messages,
	}
	body, _ := json.Marshal(payload)
	httpReq, _ := http.NewRequestWithContext(ctx, "POST",
		a.baseURL+"/chat/completions", strings.NewReader(string(body)))
	httpReq.Header.Set("Authorization", "Bearer "+a.apiKey)
	httpReq.Header.Set("Content-Type", "application/json")

	start := time.Now()
	resp, err := a.client.Do(httpReq)
	if err != nil {
		return nil, fmt.Errorf("openai request failed: %w", err)
	}
	defer resp.Body.Close()

	respBody, _ := io.ReadAll(resp.Body)
	var result struct {
		Choices []struct {
			Message struct {
				Content string `json:"content"`
			} `json:"message"`
		} `json:"choices"`
		Usage struct {
			PromptTokens     int `json:"prompt_tokens"`
			CompletionTokens int `json:"completion_tokens"`
		} `json:"usage"`
	}
	json.Unmarshal(respBody, &result)

	latency := time.Since(start).Milliseconds()
	content := ""
	if len(result.Choices) > 0 {
		content = result.Choices[0].Message.Content
	}

	return &ChatResponse{
		Content:   content,
		Model:     "gpt-4o",
		Provider:  string(ProviderOpenAI),
		TokensIn:  result.Usage.PromptTokens,
		TokensOut: result.Usage.CompletionTokens,
		LatencyMs: latency,
	}, nil
}

// AIGateway — the unified entry point with strategy-based routing
type AIGateway struct {
	registry   *ModelRegistry
	adapters   map[ProviderType]AIAdapter
	strategies map[string]RouterStrategy
	stats      *GatewayStats
}

type GatewayStats struct {
	mu           sync.Mutex
	TotalReqs    int64
	SuccessReqs  int64
	FailReqs     int64
	LatencySum   int64
	ModelCounter map[string]int64
	ProviderCost map[string]float64
}

func NewGatewayStats() *GatewayStats {
	return &GatewayStats{
		ModelCounter: make(map[string]int64),
		ProviderCost: make(map[string]float64),
	}
}

func NewAIGateway(openAIKey, anthropicKey, geminiKey string) *AIGateway {
	gw := &AIGateway{
		registry:   NewModelRegistry(),
		adapters:   make(map[ProviderType]AIAdapter),
		strategies: make(map[string]RouterStrategy),
		stats:      NewGatewayStats(),
	}

	// Register all supported models
	gw.registry.Register("gpt-4o", &ModelCapability{
		Provider: ProviderOpenAI, ModelName: "gpt-4o",
		CostPer1KIn: 0.0025, CostPer1KOut: 0.01,
		ContextWindow: 128000, AvgLatency: 1800 * time.Millisecond,
		IsAvailable: true, Priority: 1,
	})
	gw.registry.Register("claude-sonnet-4-6", &ModelCapability{
		Provider: ProviderAnthropic, ModelName: "claude-sonnet-4-6",
		CostPer1KIn: 0.003, CostPer1KOut: 0.015,
		ContextWindow: 200000, AvgLatency: 2200 * time.Millisecond,
		IsAvailable: true, Priority: 1,
	})
	gw.registry.Register("gemini-1.5-pro", &ModelCapability{
		Provider: ProviderGemini, ModelName: "gemini-1.5-pro",
		CostPer1KIn: 0.00125, CostPer1KOut: 0.005,
		ContextWindow: 1000000, AvgLatency: 1500 * time.Millisecond,
		IsAvailable: true, Priority: 2,
	})
	gw.registry.Register("gpt-4o-mini", &ModelCapability{
		Provider: ProviderOpenAI, ModelName: "gpt-4o-mini",
		CostPer1KIn: 0.00015, CostPer1KOut: 0.0006,
		ContextWindow: 128000, AvgLatency: 800 * time.Millisecond,
		IsAvailable: true, Priority: 3,
	})
	gw.registry.Register("claude-haiku-4-5", &ModelCapability{
		Provider: ProviderAnthropic, ModelName: "claude-haiku-4-5",
		CostPer1KIn: 0.00025, CostPer1KOut: 0.00125,
		ContextWindow: 200000, AvgLatency: 600 * time.Millisecond,
		IsAvailable: true, Priority: 3,
	})

	gw.adapters[ProviderOpenAI] = NewOpenAIAdapter(openAIKey)
	gw.adapters[ProviderAnthropic] = NewAnthropicAdapter(anthropicKey)
	gw.adapters[ProviderGemini] = NewGeminiAdapter(geminiKey)

	gw.strategies["cost"] = &CostOptimizedStrategy{}
	gw.strategies["latency"] = &LatencyOptimizedStrategy{}
	gw.strategies["failover"] = &PriorityFailoverStrategy{}

	return gw
}

// Route selects the optimal model and executes the request
func (gw *AIGateway) Route(ctx context.Context, req *ChatRequest) (*ChatResponse, error) {
	strategyName := req.RouteStrategy
	if strategyName == "" {
		switch req.Tier {
		case "premium":
			strategyName = "failover"
		case "standard":
			strategyName = "latency"
		default:
			strategyName = "cost"
		}
	}

	strategy, ok := gw.strategies[strategyName]
	if !ok {
		return nil, fmt.Errorf("unknown strategy: %s", strategyName)
	}

	available := gw.registry.ListAvailable()
	if len(available) == 0 {
		return nil, fmt.Errorf("no available models")
	}

	selected := strategy.Select(available, req)
	if selected == nil {
		return nil, fmt.Errorf("no suitable model found")
	}

	adapter, ok := gw.adapters[selected.Provider]
	if !ok {
		return nil, fmt.Errorf("no adapter for provider: %s", selected.Provider)
	}

	maxRetries := 2
	var lastErr error
	for attempt := 0; attempt <= maxRetries; attempt++ {
		resp, err := adapter.Chat(ctx, req)
		if err == nil {
			return resp, nil
		}
		lastErr = err
		// Fallback to next available model
		available = gw.registry.ListAvailable()
		selected = strategy.Select(available, req)
		if selected == nil {
			break
		}
		adapter = gw.adapters[selected.Provider]
	}

	return nil, fmt.Errorf("all models failed, last error: %w", lastErr)
}

func main() {
	gw := NewAIGateway("sk-openai-xxx", "sk-ant-xxx", "AIzaSyXXX")

	http.HandleFunc("/v1/chat/completions", func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodPost {
			http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
			return
		}
		var req ChatRequest
		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
			http.Error(w, err.Error(), http.StatusBadRequest)
			return
		}
		for _, msg := range req.Messages {
			req.EstimatedTokens += len(strings.Fields(msg.Content)) * 2
		}
		resp, err := gw.Route(r.Context(), &req)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(resp)
	})

	http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
		json.NewEncoder(w).Encode(map[string]bool{"healthy": len(gw.registry.ListAvailable()) > 0})
	})

	log.Println("AI Gateway running on :8080")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

// NewAnthropicAdapter and NewGeminiAdapter follow the same pattern

"""
ai_model_router.py
Intelligent AI Model Routing Selector - Python Implementation
Real-time optimal model selection based on request characteristics
"""

import time
import json
import hashlib
from enum import Enum
from dataclasses import dataclass, field
from typing import Optional
from collections import deque
import statistics


class Provider(Enum):
    OPENAI = "openai"
    ANTHROPIC = "anthropic"
    GEMINI = "gemini"


class TaskType(Enum):
    CHAT = "chat"
    CODE = "code"
    REASONING = "reasoning"
    EXTRACTION = "extraction"
    CLASSIFICATION = "classification"
    SUMMARIZATION = "summarization"


@dataclass
class ModelConfig:
    """Model configuration with cost and performance attributes"""
    provider: Provider
    model_name: str
    cost_per_1k_input: float
    cost_per_1k_output: float
    context_window: int
    latency_p50: float  # milliseconds
    latency_p95: float
    is_available: bool = True
    tasks: list[TaskType] = field(default_factory=list)

    def estimate_cost(self, input_tokens: int, output_tokens: int) -> float:
        return (input_tokens / 1000 * self.cost_per_1k_input +
                output_tokens / 1000 * self.cost_per_1k_output)


@dataclass
class RoutingDecision:
    """Records each routing decision for observability"""
    model: ModelConfig
    strategy: str
    estimated_cost: float
    decision_time_ms: float
    reason: str


class LatencyTracker:
    """Sliding window latency tracker for P50/P95"""

    def __init__(self, window_size: int = 100):
        self.window: deque = deque(maxlen=window_size)

    def record(self, latency_ms: float):
        self.window.append(latency_ms)

    @property
    def p50(self) -> float:
        if not self.window:
            return 0.0
        return statistics.median(self.window)

    @property
    def p95(self) -> float:
        if not self.window:
            return 0.0
        sorted_data = sorted(self.window)
        idx = int(len(sorted_data) * 0.95)
        return sorted_data[min(idx, len(sorted_data) - 1)]


class SemanticCache:
    """Semantic caching using similarity matching"""

    def __init__(self, similarity_threshold: float = 0.92):
        self.cache: dict[str, tuple[str, float]] = {}
        self.threshold = similarity_threshold
        self.hits = 0
        self.misses = 0

    def get(self, query: str) -> Optional[str]:
        key = hashlib.sha256(query.encode()).hexdigest()[:16]
        if key in self.cache:
            self.hits += 1
            return self.cache[key][0]
        for cached_key, (cached_response, similarity) in self.cache.items():
            if similarity >= self.threshold:
                self.hits += 1
                return cached_response
        self.misses += 1
        return None

    def set(self, query: str, response: str, similarity: float = 1.0):
        key = hashlib.sha256(query.encode()).hexdigest()[:16]
        self.cache[key] = (response, similarity)

    @property
    def hit_rate(self) -> float:
        total = self.hits + self.misses
        return self.hits / total if total > 0 else 0.0


class AIModelRouter:
    """
    Intelligent AI Model Router
    
    Routes requests to the optimal model based on cost, latency,
    task type, and user tier. Supports multiple strategies:
    - Cost-optimized: cheapest capable model
    - Latency-optimized: fastest model
    - Quality-optimized: most capable model
    - Hybrid: tier-aware dynamic routing
    """

    def __init__(self):
        self.models: dict[str, ModelConfig] = {}
        self.latency_trackers: dict[str, LatencyTracker] = {}
        self.cache = SemanticCache()
        self.decisions: list[RoutingDecision] = []
        self._init_default_models()

    def _init_default_models(self):
        """Initialize the default model registry"""
        models = [
            # Frontier models
            ModelConfig(Provider.OPENAI, "gpt-4o",
                        0.0025, 0.01, 128000,
                        1800, 3500, True,
                        [TaskType.CHAT, TaskType.REASONING, TaskType.CODE]),
            ModelConfig(Provider.ANTHROPIC, "claude-sonnet-4-6",
                        0.003, 0.015, 200000,
                        2200, 4000, True,
                        [TaskType.CODE, TaskType.REASONING, TaskType.CHAT]),
            ModelConfig(Provider.GEMINI, "gemini-1.5-pro",
                        0.00125, 0.005, 1000000,
                        1500, 2800, True,
                        [TaskType.CHAT, TaskType.REASONING,
                         TaskType.SUMMARIZATION]),
            # Economy models
            ModelConfig(Provider.OPENAI, "gpt-4o-mini",
                        0.00015, 0.0006, 128000,
                        800, 1500, True,
                        [TaskType.CHAT, TaskType.CLASSIFICATION,
                         TaskType.EXTRACTION, TaskType.SUMMARIZATION]),
            ModelConfig(Provider.ANTHROPIC, "claude-haiku-4-5",
                        0.00025, 0.00125, 200000,
                        600, 1200, True,
                        [TaskType.CHAT, TaskType.CLASSIFICATION,
                         TaskType.EXTRACTION]),
            ModelConfig(Provider.GEMINI, "gemini-1.5-flash",
                        0.000075, 0.0003, 1000000,
                        500, 1000, True,
                        [TaskType.CHAT, TaskType.CLASSIFICATION,
                         TaskType.EXTRACTION, TaskType.SUMMARIZATION]),
        ]
        for m in models:
            key = f"{m.provider.value}/{m.model_name}"
            self.models[key] = m
            self.latency_trackers[key] = LatencyTracker()

    def _get_suitable_models(self, task_type: TaskType,
                             input_tokens: int) -> list[ModelConfig]:
        """Filter models by task type and context window"""
        suitable = []
        for model in self.models.values():
            if not model.is_available:
                continue
            if task_type not in model.tasks:
                continue
            if input_tokens > model.context_window:
                continue
            suitable.append(model)
        return suitable

    def cost_optimized_select(self, task_type: TaskType,
                              input_tokens: int,
                              output_tokens: int = 500) -> Optional[ModelConfig]:
        """Select the cheapest capable model"""
        suitable = self._get_suitable_models(task_type, input_tokens)
        if not suitable:
            return None
        return min(suitable,
                   key=lambda m: m.estimate_cost(input_tokens, output_tokens))

    def latency_optimized_select(self, task_type: TaskType,
                                 input_tokens: int) -> Optional[ModelConfig]:
        """Select the fastest available model"""
        suitable = self._get_suitable_models(task_type, input_tokens)
        if not suitable:
            return None
        return min(suitable, key=lambda m: self.latency_trackers[
            f"{m.provider.value}/{m.model_name}"].p50 or m.latency_p50)

    def quality_optimized_select(self, task_type: TaskType,
                                 input_tokens: int) -> Optional[ModelConfig]:
        """Select the most capable model"""
        suitable = self._get_suitable_models(task_type, input_tokens)
        if not suitable:
            return None
        priority_order = [TaskType.CODE, TaskType.REASONING,
                          TaskType.CHAT, TaskType.SUMMARIZATION,
                          TaskType.EXTRACTION, TaskType.CLASSIFICATION]
        for priority_task in priority_order:
            for model in suitable:
                if priority_task in model.tasks:
                    return model
        return suitable[0]

    def hybrid_select(self, task_type: TaskType,
                      input_tokens: int,
                      user_tier: str = "standard") -> tuple[Optional[ModelConfig], str]:
        """
        Hybrid routing strategy based on user tier
        
        - premium: quality-first with automatic failover
        - standard: latency-first with cost awareness
        - free: cost-first
        """
        if user_tier == "premium":
            return self.quality_optimized_select(task_type, input_tokens), "quality"
        elif user_tier == "standard":
            return self.latency_optimized_select(task_type, input_tokens), "latency"
        else:
            return self.cost_optimized_select(task_type, input_tokens), "cost"

    def route_with_fallback(self, task_type: TaskType,
                            input_text: str,
                            user_tier: str = "standard") -> tuple[ModelConfig, RoutingDecision]:
        """
        Smart routing with automatic fallback
        
        Pipeline:
        1. Check semantic cache
        2. Select optimal model by strategy
        3. Auto-failover on failure
        4. Record decision for observability
        """
        start_time = time.time()
        input_tokens = sum(len(w) for w in input_text.split()) // 2 + 1
        output_tokens = min(input_tokens, 4096)

        # 1. Check cache
        cached = self.cache.get(input_text[:100])
        if cached:
            model = self.cost_optimized_select(task_type, input_tokens)
            decision = RoutingDecision(
                model=model, strategy="cache_hit",
                estimated_cost=0.0,
                decision_time_ms=(time.time() - start_time) * 1000,
                reason="Cache hit, skipped model invocation"
            )
            return model, decision

        # 2. Primary routing
        model, strategy = self.hybrid_select(task_type, input_tokens, user_tier)
        if model is None:
            raise RuntimeError("No available models")

        primary = RoutingDecision(
            model=model, strategy=strategy,
            estimated_cost=model.estimate_cost(input_tokens, output_tokens),
            decision_time_ms=(time.time() - start_time) * 1000,
            reason=f"Primary route: strategy={strategy}, task={task_type.value}, tier={user_tier}"
        )

        # 3. Simulated invocation check
        latency_ms = self.latency_trackers[
            f"{model.provider.value}/{model.model_name}"].p50 or model.latency_p50
        success = latency_ms < model.latency_p95 * 1.5

        if not success:
            # Fallback to next best model
            fallback = self.latency_optimized_select(task_type, input_tokens)
            if fallback and fallback != model:
                decision = RoutingDecision(
                    model=fallback,
                    strategy=f"failover_from_{strategy}",
                    estimated_cost=fallback.estimate_cost(input_tokens, output_tokens),
                    decision_time_ms=(time.time() - start_time) * 1000,
                    reason=f"Primary {model.model_name} timed out, "
                           f"failover to {fallback.model_name}"
                )
                self.decisions.append(decision)
                return fallback, decision

        self.decisions.append(primary)
        return model, primary

    def get_stats(self) -> dict:
        """Return routing statistics"""
        total_cost = sum(d.estimated_cost for d in self.decisions)
        strategy_count = {}
        for d in self.decisions:
            strategy_count[d.strategy] = strategy_count.get(d.strategy, 0) + 1
        return {
            "total_decisions": len(self.decisions),
            "total_estimated_cost": round(total_cost, 4),
            "cache_hit_rate": round(self.cache.hit_rate, 3),
            "strategy_distribution": strategy_count,
            "model_latency_p50": {
                k: round(t.p50, 1)
                for k, t in self.latency_trackers.items() if t.p50 > 0
            }
        }


def demo_apple_siri_router():
    """Simulate Apple Siri AI's three-tier routing architecture"""
    print("=" * 60)
    print("🍎 Apple Siri AI Three-Tier Routing Simulation")
    print("=" * 60)

    tiers = [
        ("L1-On-device", ["Apple Neural Engine"], (0.1, 50), 0.0),
        ("L2-Private Cloud", ["Apple Foundation Model"], (50, 500), 0.0001),
        ("L3-Google Cloud", ["Gemini 1.2T", "Claude", "ChatGPT"],
         (500, 3000), 0.005),
    ]

    requests = [
        ("Set alarm for 10 minutes", "Simple", "L1-On-device"),
        ("Find hotel confirmation from last week's email",
         "Moderate", "L2-Private Cloud"),
        ("Analyze this 20-page PDF and summarize key findings",
         "Complex", "L3-Google Cloud"),
    ]

    for query, complexity, expected in requests:
        print(f"\n   🗣️ \"{query}\"")
        print(f"   Complexity: {complexity}")
        print(f"   Routed to: {expected}")


def demo_cost_comparison():
    """Demonstrate cost comparison across routing strategies"""
    print("=" * 60)
    print("📊 Multi-Model Routing - Cost Comparison")
    print("=" * 60)

    router = AIModelRouter()
    test_cases = [
        (TaskType.CLASSIFICATION, "Classify this review", 50),
        (TaskType.CODE, "Implement binary tree level-order traversal", 500),
        (TaskType.REASONING, "Analyze this 20-page mathematical proof", 2000),
        (TaskType.SUMMARIZATION, "Summarize this 5000-word article", 1000),
    ]

    for task_type, text, out_tokens in test_cases:
        in_tokens = sum(len(w) for w in text.split()) // 2 + 1
        cost_model = router.cost_optimized_select(task_type, in_tokens, out_tokens)
        if cost_model:
            cost = cost_model.estimate_cost(in_tokens, out_tokens)
            print(f"\n📌 {task_type.value}: {cost_model.model_name} (${cost:.6f})")

        latency_model = router.latency_optimized_select(task_type, in_tokens)
        if latency_model:
            print(f"   ⚡ Latency opt: {latency_model.model_name} "
                  f"({latency_model.latency_p50}ms)")


if __name__ == "__main__":
    demo_cost_comparison()
    demo_apple_siri_router()

    router = AIModelRouter()
    router.route_with_fallback(TaskType.CHAT, "hello", "free")
    router.route_with_fallback(TaskType.CODE, "write a binary search", "premium")
    print(json.dumps(router.get_stats(), indent=2))