GPT-5.6 Sol/Terra/Luna Unveiled: From Codex Code Leak to July 7 Precision Timing — Deep Dive into OpenAI's "Opportunistic" Commercial Hunting Strategy

// ============================================================
// GPT-5.6 Sol Ultra Sub-Agent Scheduling Framework
// Simulates GPT-5.6 Ultra mode multi-agent parallel inference
// ============================================================
package main

import (
    "context"
    "fmt"
    "math/rand"
    "strings"
    "sync"
    "time"
)

// Task defines work to be processed
type Task struct {
    ID           string
    Description  string
    Type         TaskType
    Complexity   int // 1-10
    Dependencies []string
}

type TaskType int

const (
    TaskCoding   TaskType = iota
    TaskAnalysis
    TaskResearch
    TaskSecurity
    TaskPlanning
)

// SubAgent defines a specialized worker agent
type SubAgent struct {
    ID        string
    Expertise TaskType
    Capacity  int
    Status    string
    results   chan Result
    ctx       context.Context
    cancel    context.CancelFunc
}

// Result captures processing output
type Result struct {
    TaskID     string
    AgentID    string
    Output     string
    TokensUsed int
    Duration   time.Duration
    Error      error
}

// UltraScheduler manages the sub-agent pool
type UltraScheduler struct {
    agents    []*SubAgent
    taskQueue chan Task
    results   map[string]Result
    mu        sync.RWMutex
    wg        sync.WaitGroup
}

func NewUltraScheduler() *UltraScheduler {
    s := &UltraScheduler{
        taskQueue: make(chan Task, 100),
        results:   make(map[string]Result),
    }

    // Initialize specialized sub-agent pool
    // Corresponds to GPT-5.6 Ultra mode's multi-agent coordination
    specializations := []struct {
        id        string
        expertise TaskType
    }{
        {"code-agent-1", TaskCoding},
        {"code-agent-2", TaskCoding},
        {"analysis-agent", TaskAnalysis},
        {"research-agent", TaskResearch},
        {"security-agent", TaskSecurity},
        {"planning-agent", TaskPlanning},
    }

    for _, spec := range specializations {
        ctx, cancel := context.WithCancel(context.Background())
        agent := &SubAgent{
            ID:        spec.id,
            Expertise: spec.expertise,
            Capacity:  3,
            Status:    "idle",
            results:   make(chan Result, 10),
            ctx:       ctx,
            cancel:    cancel,
        }
        s.agents = append(s.agents, agent)
    }
    return s
}

// DispatchTask routes a task to the optimal sub-agent
func (s *UltraScheduler) DispatchTask(task Task) {
    s.wg.Add(1)
    go func() {
        defer s.wg.Done()
        agent := s.selectOptimalAgent(task)
        if agent == nil {
            fmt.Printf("[Ultra] No available agent for task %s\n", task.ID)
            return
        }

        fmt.Printf("[Ultra] Dispatching %s (%s) → agent %s (%v)\n",
            task.ID, task.Description, agent.ID, agent.Expertise)

        start := time.Now()
        time.Sleep(time.Duration(100+task.Complexity*50) * time.Millisecond)

        result := Result{
            TaskID:     task.ID,
            AgentID:    agent.ID,
            Output:     fmt.Sprintf("Task %s completed by %s", task.ID, agent.ID),
            TokensUsed: 1000 + task.Complexity*500,
            Duration:   time.Since(start),
        }

        s.mu.Lock()
        s.results[task.ID] = result
        s.mu.Unlock()

        fmt.Printf("[Ultra] Task %s done in %v (tokens: %d)\n",
            task.ID, result.Duration, result.TokensUsed)
    }()
}

// selectOptimalAgent scores agents by expertise match and load
func (s *UltraScheduler) selectOptimalAgent(task Task) *SubAgent {
    var bestAgent *SubAgent
    bestScore := -1

    for _, agent := range s.agents {
        score := 0
        if agent.Expertise == task.Type {
            score += 50
        }
        switch task.Type {
        case TaskCoding:
            if agent.Expertise == TaskSecurity {
                score += 20
            }
        case TaskAnalysis:
            if agent.Expertise == TaskResearch {
                score += 25
            }
        }
        score -= len(agent.results) * 5
        if score > bestScore {
            bestScore = score
            bestAgent = agent
        }
    }
    return bestAgent
}

// AggregateResults collects all sub-agent outputs
func (s *UltraScheduler) AggregateResults() []Result {
    s.mu.RLock()
    defer s.mu.RUnlock()
    results := make([]Result, 0, len(s.results))
    for _, r := range s.results {
        results = append(results, r)
    }
    return results
}

// SimulateUltraMode runs a full Ultra mode simulation
func SimulateUltraMode() {
    scheduler := NewUltraScheduler()
    tasks := []Task{
        {ID: "T1", Description: "Analyze codebase architecture", Type: TaskAnalysis, Complexity: 7},
        {ID: "T2", Description: "Refactor module A", Type: TaskCoding, Complexity: 8},
        {ID: "T3", Description: "Security audit dependencies", Type: TaskSecurity, Complexity: 6},
        {ID: "T4", Description: "Generate unit tests", Type: TaskCoding, Complexity: 5},
        {ID: "T5", Description: "Research new API compatibility", Type: TaskResearch, Complexity: 4},
        {ID: "T6", Description: "Plan release strategy", Type: TaskPlanning, Complexity: 3},
    }

    fmt.Println("=" + strings.Repeat("=", 59))
    fmt.Println("  GPT-5.6 Sol Ultra Mode Sub-Agent Dispatch Simulation")
    fmt.Println("=" + strings.Repeat("=", 59))
    fmt.Printf("\nTotal Tasks: %d\n", len(tasks))
    fmt.Printf("Sub-Agent Pool: %d specialized agents\n\n", len(scheduler.agents))

    for _, task := range tasks {
        scheduler.DispatchTask(task)
    }
    scheduler.wg.Wait()

    results := scheduler.AggregateResults()
    fmt.Printf("\n[Ultra Mode Complete] %d tasks processed\n", len(results))

    var totalTokens, totalDuration int64
    for _, r := range results {
        totalTokens += int64(r.TokensUsed)
        totalDuration += r.Duration.Milliseconds()
    }
    fmt.Printf("Total Token Consumption: %d\n", totalTokens)
    fmt.Printf("Total Duration: %dms\n", totalDuration)
    fmt.Printf("Avg Tokens/Task: %d\n", totalTokens/int64(len(results)))

    singlePathTokens := 0
    for _, task := range tasks {
        singlePathTokens += 2000 + task.Complexity*800
    }
    fmt.Printf("\nPerformance Comparison (Ultra vs Single-Path):\n")
    fmt.Printf("  Ultra Mode Tokens: %d\n", totalTokens)
    fmt.Printf("  Single-Path Tokens: %d\n", singlePathTokens)
    fmt.Printf("  Savings: %.1f%%\n",
        (1-float64(totalTokens)/float64(singlePathTokens))*100)
}

func main() {
    SimulateUltraMode()
}

#!/usr/bin/env python3
"""
GPT-5.6 Speed Dial: Dynamic Inference Compute Allocation
Simulates how Speed Dial adjusts reasoning intensity on the same model
"""

import time
import math
from enum import Enum
from typing import Any, Dict, Optional


class SpeedDialPosition(Enum):
    """Speed Dial gear positions"""
    TURBO = 0.0       # Extreme speed - shortest inference path
    FAST = 0.25       # Fast mode - streamlined inference
    BALANCED = 0.5    # Balanced mode - default inference
    PRECISE = 0.75    # Precise mode - enhanced inference
    ULTRA = 1.0       # Ultra mode - maximum reasoning depth


class DynamicInferenceEngine:
    """
    Dynamic inference engine.
    Allocates inference compute based on Speed Dial position.
    Core mechanism: adjusts reasoning depth, sampling width,
    and self-consistency checks to control inference cost.
    """

    def __init__(self, model_name: str):
        self.model_name = model_name
        self.base_params = {
            "max_tokens": 4096,
            "temperature": 0.7,
            "top_p": 0.9,
        }

        self.speed_dial_configs = {
            SpeedDialPosition.TURBO: {
                "description": "Turbo - best for simple Q&A, brainstorming",
                "reasoning_depth": 0.2,
                "sampling_width": 1,
                "self_consistency": 1,
                "think_budget_ratio": 0.1,
                "latency_target_ms": 500,
            },
            SpeedDialPosition.FAST: {
                "description": "Fast - best for daily dev, document processing",
                "reasoning_depth": 0.4,
                "sampling_width": 2,
                "self_consistency": 1,
                "think_budget_ratio": 0.3,
                "latency_target_ms": 1500,
            },
            SpeedDialPosition.BALANCED: {
                "description": "Balanced - default mode, general purpose",
                "reasoning_depth": 0.6,
                "sampling_width": 3,
                "self_consistency": 2,
                "think_budget_ratio": 0.5,
                "latency_target_ms": 3000,
            },
            SpeedDialPosition.PRECISE: {
                "description": "Precise - best for code review, data analysis",
                "reasoning_depth": 0.8,
                "sampling_width": 4,
                "self_consistency": 3,
                "think_budget_ratio": 0.7,
                "latency_target_ms": 5000,
            },
            SpeedDialPosition.ULTRA: {
                "description": "Ultra - best for complex reasoning, research",
                "reasoning_depth": 1.0,
                "sampling_width": 6,
                "self_consistency": 5,
                "think_budget_ratio": 1.0,
                "latency_target_ms": 10000,
            },
        }

    def estimate_cost(self,
                      position: SpeedDialPosition,
                      input_tokens: int,
                      output_tokens: int) -> Dict[str, Any]:
        """
        Estimate inference cost at a given Speed Dial position.
        Cost model:
        - Base cost = input_tokens × input_price + output_tokens × output_price
        - Reasoning cost = base_cost × (1 + depth × think_budget)
        - Consistency cost = reasoning_cost × self_consistency
        """
        config = self.speed_dial_configs[position]
        prices = {
            "Sol": {"input": 5, "output": 30},
            "Terra": {"input": 2.5, "output": 15},
            "Luna": {"input": 1, "output": 6},
        }.get(self.model_name, {"input": 2.5, "output": 15})

        base_cost = (input_tokens * prices["input"] + output_tokens * prices["output"]) / 1_000_000
        depth_factor = 1 + config["reasoning_depth"] * config["think_budget_ratio"]
        reasoning_cost = base_cost * depth_factor
        total_cost = reasoning_cost * config["self_consistency"]
        est_latency = config["latency_target_ms"] * (1 + output_tokens / 1000)

        return {
            "position": position.name,
            "description": config["description"],
            "base_cost_usd": round(base_cost, 6),
            "reasoning_cost_usd": round(reasoning_cost, 6),
            "total_cost_usd": round(total_cost, 6),
            "estimated_latency_ms": round(est_latency, 0),
            "effective_output_tokens": output_tokens,
            "total_tokens_consumed": output_tokens * config["self_consistency"],
            "reasoning_depth": config["reasoning_depth"],
            "self_consistency_checks": config["self_consistency"],
        }

    def optimize_speed_dial(self,
                            task_type: str,
                            input_tokens: int,
                            output_tokens: int,
                            max_latency_ms: int = 3000,
                            max_cost_usd: float = 0.1) -> SpeedDialPosition:
        """
        Auto-optimize Speed Dial position based on task characteristics.
        Corresponds to GPT-5.6's intelligent recommendation feature.
        """
        task_recommendations = {
            "chat": SpeedDialPosition.FAST,
            "code_completion": SpeedDialPosition.FAST,
            "code_review": SpeedDialPosition.PRECISE,
            "debugging": SpeedDialPosition.PRECISE,
            "architecture": SpeedDialPosition.ULTRA,
            "analysis": SpeedDialPosition.BALANCED,
            "creative_writing": SpeedDialPosition.BALANCED,
            "research": SpeedDialPosition.ULTRA,
            "simple_qa": SpeedDialPosition.TURBO,
            "translation": SpeedDialPosition.FAST,
        }

        recommended = task_recommendations.get(task_type, SpeedDialPosition.BALANCED)
        for position in [SpeedDialPosition.FAST, SpeedDialPosition.BALANCED,
                         SpeedDialPosition.PRECISE, SpeedDialPosition.ULTRA]:
            cost_est = self.estimate_cost(position, input_tokens, output_tokens)
            if cost_est["estimated_latency_ms"] > max_latency_ms:
                continue
            if cost_est["total_cost_usd"] > max_cost_usd:
                continue
            return position
        return SpeedDialPosition.TURBO

    def simulate_inference(self, prompt: str, position: SpeedDialPosition) -> Dict[str, Any]:
        """Simulate inference behavior at a given Speed Dial position."""
        config = self.speed_dial_configs[position]
        input_tokens = len(prompt.split())
        think_time = 0.1 * config["reasoning_depth"] * config["think_budget_ratio"]
        if config["self_consistency"] > 1:
            think_time *= config["self_consistency"]
        time.sleep(min(think_time, 0.5))

        quality_metrics = {
            "accuracy": 0.5 + config["reasoning_depth"] * 0.4,
            "completeness": 0.3 + config["reasoning_depth"] * 0.6,
            "creativity": 0.7 - config["reasoning_depth"] * 0.3,
            "consistency": 0.4 + config["self_consistency"] * 0.1,
        }

        return {
            "model": self.model_name,
            "speed_dial": position.name,
            "input_tokens": input_tokens,
            "think_time_seconds": round(think_time, 3),
            "quality_metrics": quality_metrics,
            "config": config,
        }


def benchmark_speed_dial():
    """Compare performance and cost across Speed Dial positions."""
    print("=" * 70)
    print("GPT-5.6 Speed Dial Performance Benchmark")
    print("=" * 70)

    test_cases = [
        ("Simple Q&A", "What is the capital of France?", "simple_qa", 50, 50),
        ("Code Review", "Review this Go function for concurrency issues", "code_review", 500, 300),
        ("Architecture Design", "Design a microservice architecture", "architecture", 1000, 2000),
        ("Research Analysis", "Analyze the new transformer architecture", "research", 2000, 1500),
    ]

    for task_name, prompt, task_type, in_tokens, out_tokens in test_cases:
        print(f"\n{'='*70}")
        print(f"Task: {task_name} ({task_type})")
        print(f"Input: ~{in_tokens} tokens, Output: ~{out_tokens} tokens")
        print(f"{'='*70}")

        for model in ["Sol", "Terra", "Luna"]:
            engine = DynamicInferenceEngine(model)
            optimal = engine.optimize_speed_dial(
                task_type, in_tokens, out_tokens,
                max_latency_ms=5000, max_cost_usd=0.5
            )
            print(f"\n  [{model}] Recommended Dial: {optimal.name}")
            cost = engine.estimate_cost(optimal, in_tokens, out_tokens)
            print(f"    Cost: ${cost['total_cost_usd']:.6f}")
            print(f"    Latency: {cost['estimated_latency_ms']:.0f}ms")
            print(f"    Reasoning Depth: {cost['reasoning_depth']:.0%}")
            print(f"    Consistency Checks: {cost['self_consistency_checks']}")


if __name__ == "__main__":
    benchmark_speed_dial()

// ============================================================
// GPT-5.6 Pricing Strategy Analyzer
// Models cost comparison across models and scenarios
// ============================================================
package main

import (
    "encoding/json"
    "fmt"
)

// ModelPricing defines a model's cost structure
type ModelPricing struct {
    Name        string
    Provider    string
    InputPrice  float64 // $ per 1M tokens
    OutputPrice float64 // $ per 1M tokens
    Quality     float64 // Terminal-Bench 2.1 score
}

// UsageScenario defines a typical usage pattern
type UsageScenario struct {
    Name        string
    DailyInput  int // tokens
    DailyOutput int // tokens
    DaysPerMonth int
}

// ScenarioCost calculates monthly cost for a scenario
type ScenarioCost struct {
    ModelName   string
    MonthlyCost float64
    DailyCost   float64
    SavingsVsFable5 float64
}

func calculateMonthlyCost(m ModelPricing, s UsageScenario) float64 {
    dailyInputCost := float64(s.DailyInput) * m.InputPrice / 1_000_000
    dailyOutputCost := float64(s.DailyOutput) * m.OutputPrice / 1_000_000
    return (dailyInputCost + dailyOutputCost) * float64(s.DaysPerMonth)
}

func main() {
    models := []ModelPricing{
        {"GPT-5.6 Sol", "OpenAI", 5, 30, 91.9},
        {"GPT-5.6 Terra", "OpenAI", 2.5, 15, 86.1},
        {"GPT-5.6 Luna", "OpenAI", 1, 6, 75.8},
        {"Claude Fable 5", "Anthropic", 10, 50, 84.3},
        {"Claude Sonnet 5", "Anthropic", 2, 10, 85.0},
        {"Claude Mythos 5", "Anthropic", 10, 50, 88.0},
        {"DeepSeek V4", "DeepSeek", 0.435, 0.87, 72.8},
    }

    scenarios := []UsageScenario{
        {"Individual Developer", 50000, 20000, 22},
        {"Small Team", 200000, 100000, 22},
        {"Enterprise Batch", 2000000, 500000, 30},
        {"Heavy Agent Usage", 1000000, 500000, 30},
    }

    fmt.Println("=" + strings.Repeat("=", 69))
    fmt.Println("  GPT-5.6 Pricing Strategy Analysis")
    fmt.Println("=" + strings.Repeat("=", 69))

    for _, scenario := range scenarios {
        fmt.Printf("\n📋 Scenario: %s\n", scenario.Name)
        fmt.Printf("   Daily: %d in / %d out, %d days/month\n",
            scenario.DailyInput, scenario.DailyOutput, scenario.DaysPerMonth)
        fmt.Println(strings.Repeat("-", 70))
        fmt.Printf("%-22s %12s %12s %14s\n", "Model", "Daily Cost", "Monthly Cost", "vs Fable 5")
        fmt.Println(strings.Repeat("-", 70))

        var fable5Cost float64
        var allCosts []ScenarioCost

        for _, m := range models {
            cost := calculateMonthlyCost(m, scenario)
            dailyCost := cost / float64(scenario.DaysPerMonth)

            if m.Name == "Claude Fable 5" {
                fable5Cost = cost
            }

            allCosts = append(allCosts, ScenarioCost{
                ModelName:   m.Name,
                DailyCost:   dailyCost,
                MonthlyCost: cost,
            })
        }

        for _, sc := range allCosts {
            savings := 0.0
            if fable5Cost > 0 && sc.ModelName != "Claude Fable 5" {
                savings = (1 - sc.MonthlyCost/fable5Cost) * 100
            }
            fmt.Printf("%-22s $%9.2f $%10.2f %12.1f%%\n",
                sc.ModelName, sc.DailyCost, sc.MonthlyCost, savings)
        }
    }

    fmt.Println("\n\n## Key Insight ##")
    fmt.Println("GPT-5.6 Luna saves 80-90% vs Fable 5 for batch workloads")
    fmt.Println("GPT-5.6 Terra saves 60-70% vs Fable 5 for daily enterprise use")
    fmt.Println("GPT-5.6 Sol saves 35-45% vs Fable 5 for flagship scenarios")
}

// ============================================================
// GPT-5.6 Multi-Model Intelligent Routing Middleware
// Supports Sol/Terra/Luna automatic routing
// Strategies: weighted random, cost-first, quality-first, latency-first
// ============================================================
package main

import (
    "container/heap"
    "encoding/json"
    "fmt"
    "math/rand"
    "sort"
    "strings"
    "sync"
    "time"
)

// Model defines a model's capabilities and pricing
type Model struct {
    Name        string  `json:"name"`
    Provider    string  `json:"provider"`
    InputPrice  float64 `json:"input_price"`
    OutputPrice float64 `json:"output_price"`
    Quality     float64 `json:"quality"`     // 0-1, based on Terminal-Bench 2.1
    Latency     float64 `json:"latency"`     // ms average
    MaxTokens   int     `json:"max_tokens"`
    IsAvailable bool    `json:"is_available"`
}

// RoutingDecision captures the routing outcome
type RoutingDecision struct {
    SelectedModel *Model  `json:"selected_model"`
    Strategy      string  `json:"strategy"`
    EstimatedCost float64 `json:"estimated_cost"`
    Reason        string  `json:"reason"`
}

// Request defines the request context for routing
type Request struct {
    TaskType     string  `json:"task_type"`
    InputTokens  int     `json:"input_tokens"`
    OutputTokens int     `json:"output_tokens"`
    MaxLatencyMs int     `json:"max_latency_ms"`
    MaxCostUsd   float64 `json:"max_cost_usd"`
    MinQuality   float64 `json:"min_quality"`
    Priority     int     `json:"priority"` // 1-10
}

// ModelRouter routes requests to optimal models
type ModelRouter struct {
    models   []*Model
    usageLog []UsageRecord
    mu       sync.RWMutex
    stats    RouterStats
}

type UsageRecord struct {
    Timestamp time.Time
    ModelName string
    TaskType  string
    Cost      float64
    Latency   float64
    TokensIn  int
    TokensOut int
}

type RouterStats struct {
    TotalRequests  int64
    TotalCost      float64
    ModelCounts    map[string]int64
    AverageLatency float64
}

func NewModelRouter() *ModelRouter {
    return &ModelRouter{
        models: []*Model{
            {Name: "GPT-5.6 Sol", Provider: "OpenAI", InputPrice: 5, OutputPrice: 30,
                Quality: 0.95, Latency: 3000, MaxTokens: 1500000, IsAvailable: true},
            {Name: "GPT-5.6 Terra", Provider: "OpenAI", InputPrice: 2.5, OutputPrice: 15,
                Quality: 0.88, Latency: 1500, MaxTokens: 1500000, IsAvailable: true},
            {Name: "GPT-5.6 Luna", Provider: "OpenAI", InputPrice: 1, OutputPrice: 6,
                Quality: 0.78, Latency: 500, MaxTokens: 1500000, IsAvailable: true},
            {Name: "Claude Fable 5", Provider: "Anthropic", InputPrice: 10, OutputPrice: 50,
                Quality: 0.93, Latency: 2500, MaxTokens: 500000, IsAvailable: true},
            {Name: "Claude Sonnet 5", Provider: "Anthropic", InputPrice: 2, OutputPrice: 10,
                Quality: 0.85, Latency: 1200, MaxTokens: 1000000, IsAvailable: true},
            {Name: "DeepSeek V4", Provider: "DeepSeek", InputPrice: 0.435, OutputPrice: 0.87,
                Quality: 0.75, Latency: 800, MaxTokens: 1000000, IsAvailable: true},
        },
        stats: RouterStats{ModelCounts: make(map[string]int64)},
    }
}

// Route sends a request through the specified routing strategy
func (r *ModelRouter) Route(req Request, strategy string) RoutingDecision {
    r.mu.Lock()
    defer r.mu.Unlock()

    var decision RoutingDecision
    switch strategy {
    case "cost_first":
        decision = r.routeCostFirst(req)
    case "quality_first":
        decision = r.routeQualityFirst(req)
    case "latency_first":
        decision = r.routeLatencyFirst(req)
    case "weighted_random":
        decision = r.routeWeightedRandom(req)
    default:
        decision = r.routeBalanced(req)
    }

    if decision.SelectedModel != nil {
        r.stats.TotalRequests++
        r.stats.TotalCost += decision.EstimatedCost
        r.stats.ModelCounts[decision.SelectedModel.Name]++
        r.usageLog = append(r.usageLog, UsageRecord{
            Timestamp: time.Now(),
            ModelName: decision.SelectedModel.Name,
            TaskType:  req.TaskType,
            Cost:      decision.EstimatedCost,
            TokensIn:  req.InputTokens,
            TokensOut: req.OutputTokens,
        })
    }
    return decision
}

func (r *ModelRouter) routeCostFirst(req Request) RoutingDecision {
    var candidates []*Model
    for _, m := range r.models {
        if !m.IsAvailable {
            continue
        }
        cost := estimateCost(m, req)
        if req.MaxCostUsd > 0 && cost > req.MaxCostUsd {
            continue
        }
        if m.Quality >= req.MinQuality {
            candidates = append(candidates, m)
        }
    }
    if len(candidates) == 0 {
        for _, m := range r.models {
            if m.IsAvailable && m.Quality >= req.MinQuality {
                candidates = append(candidates, m)
            }
        }
    }
    if len(candidates) == 0 {
        return RoutingDecision{Reason: "no available models matching criteria"}
    }
    sort.Slice(candidates, func(i, j int) bool {
        return estimateCost(candidates[i], req) < estimateCost(candidates[j], req)
    })
    best := candidates[0]
    return RoutingDecision{
        SelectedModel: best, Strategy: "cost_first",
        EstimatedCost: estimateCost(best, req),
        Reason: fmt.Sprintf("Lowest cost: %s ($%.6f)", best.Name, estimateCost(best, req)),
    }
}

func (r *ModelRouter) routeQualityFirst(req Request) RoutingDecision {
    var candidates []*Model
    for _, m := range r.models {
        if !m.IsAvailable {
            continue
        }
        cost := estimateCost(m, req)
        if req.MaxCostUsd > 0 && cost > req.MaxCostUsd {
            continue
        }
        if m.Latency <= float64(req.MaxLatencyMs) || req.MaxLatencyMs == 0 {
            candidates = append(candidates, m)
        }
    }
    if len(candidates) == 0 {
        candidates = r.getAvailableModels()
    }
    sort.Slice(candidates, func(i, j int) bool {
        return candidates[i].Quality > candidates[j].Quality
    })
    best := candidates[0]
    return RoutingDecision{
        SelectedModel: best, Strategy: "quality_first",
        EstimatedCost: estimateCost(best, req),
        Reason: fmt.Sprintf("Highest quality: %s (score: %.2f)", best.Name, best.Quality),
    }
}

func (r *ModelRouter) routeLatencyFirst(req Request) RoutingDecision {
    var candidates []*Model
    for _, m := range r.models {
        if !m.IsAvailable || m.Quality < req.MinQuality {
            continue
        }
        candidates = append(candidates, m)
    }
    sort.Slice(candidates, func(i, j int) bool {
        return candidates[i].Latency < candidates[j].Latency
    })
    best := candidates[0]
    return RoutingDecision{
        SelectedModel: best, Strategy: "latency_first",
        EstimatedCost: estimateCost(best, req),
        Reason: fmt.Sprintf("Lowest latency: %s (%.0fms)", best.Name, best.Latency),
    }
}

func (r *ModelRouter) routeWeightedRandom(req Request) RoutingDecision {
    type weightedModel struct {
        model  *Model
        weight float64
    }
    var candidates []weightedModel
    for _, m := range r.models {
        if !m.IsAvailable || m.Quality < req.MinQuality {
            continue
        }
        cost := estimateCost(m, req)
        if cost <= 0 {
            cost = 0.001
        }
        weight := m.Quality / cost
        switch req.TaskType {
        case "coding":
            if strings.Contains(m.Name, "Sol") || strings.Contains(m.Name, "Fable") {
                weight *= 1.5
            }
        case "batch":
            if strings.Contains(m.Name, "Luna") || strings.Contains(m.Name, "DeepSeek") {
                weight *= 2.0
            }
        case "chat":
            if strings.Contains(m.Name, "Terra") || strings.Contains(m.Name, "Sonnet") {
                weight *= 1.3
            }
        }
        candidates = append(candidates, weightedModel{m, weight})
    }

    totalWeight := 0.0
    for _, c := range candidates {
        totalWeight += c.weight
    }
    rnd := rand.Float64() * totalWeight
    cumulative := 0.0
    for _, c := range candidates {
        cumulative += c.weight
        if rnd <= cumulative {
            return RoutingDecision{
                SelectedModel: c.model, Strategy: "weighted_random",
                EstimatedCost: estimateCost(c.model, req),
                Reason: fmt.Sprintf("Weighted random: %s (weight: %.2f)", c.model.Name, c.weight),
            }
        }
    }
    return RoutingDecision{Reason: "weighted random selection failed"}
}

func (r *ModelRouter) routeBalanced(req Request) RoutingDecision {
    taskModelMap := map[string]string{
        "coding": "GPT-5.6 Sol", "analysis": "GPT-5.6 Terra",
        "chat": "GPT-5.6 Terra", "batch": "GPT-5.6 Luna",
        "research": "GPT-5.6 Sol", "debugging": "GPT-5.6 Sol",
        "review": "GPT-5.6 Terra",
    }
    recommendedName := taskModelMap[req.TaskType]
    if recommendedName == "" {
        recommendedName = "GPT-5.6 Terra"
    }
    for _, m := range r.models {
        if m.Name == recommendedName && m.IsAvailable {
            return RoutingDecision{
                SelectedModel: m, Strategy: "balanced",
                EstimatedCost: estimateCost(m, req),
                Reason: fmt.Sprintf("Task-based: %s → %s", req.TaskType, m.Name),
            }
        }
    }
    for _, m := range r.models {
        if m.Name == "GPT-5.6 Terra" && m.IsAvailable {
            return RoutingDecision{
                SelectedModel: m, Strategy: "balanced_fallback",
                EstimatedCost: estimateCost(m, req),
                Reason: "Default fallback to Terra",
            }
        }
    }
    return RoutingDecision{Reason: "no available models"}
}

func (r *ModelRouter) getAvailableModels() []*Model {
    var available []*Model
    for _, m := range r.models {
        if m.IsAvailable {
            available = append(available, m)
        }
    }
    return available
}

func estimateCost(m *Model, req Request) float64 {
    inputCost := float64(req.InputTokens) * m.InputPrice / 1_000_000
    outputCost := float64(req.OutputTokens) * m.OutputPrice / 1_000_000
    return inputCost + outputCost
}

// PriorityQueue for priority-based request queuing
type PriorityRequest struct {
    Request  Request
    Decision RoutingDecision
    Index    int
}
type PriorityQueue []*PriorityRequest

func (pq PriorityQueue) Len() int { return len(pq) }
func (pq PriorityQueue) Less(i, j int) bool {
    return pq[i].Request.Priority > pq[j].Request.Priority
}
func (pq PriorityQueue) Swap(i, j int) {
    pq[i], pq[j] = pq[j], pq[i]
    pq[i].Index = i
    pq[j].Index = j
}
func (pq *PriorityQueue) Push(x interface{}) {
    n := len(*pq)
    item := x.(*PriorityRequest)
    item.Index = n
    *pq = append(*pq, item)
}
func (pq *PriorityQueue) Pop() interface{} {
    old := *pq
    n := len(old)
    item := old[n-1]
    old[n-1] = nil
    item.Index = -1
    *pq = old[0 : n-1]
    return item
}

func main() {
    fmt.Println("=" + strings.Repeat("=", 69))
    fmt.Println("  GPT-5.6 Multi-Model Intelligent Router Benchmark")
    fmt.Println("=" + strings.Repeat("=", 69))

    router := NewModelRouter()
    testRequests := []Request{
        {"coding", 2000, 1000, 5000, 0.5, 0.85, 8},
        {"chat", 500, 200, 2000, 0.05, 0.7, 3},
        {"batch", 10000, 5000, 10000, 0.1, 0.6, 1},
        {"analysis", 3000, 1500, 3000, 0.2, 0.8, 5},
        {"research", 5000, 3000, 8000, 1.0, 0.9, 10},
    }
    strategies := []string{"cost_first", "quality_first", "latency_first", "weighted_random", "balanced"}

    for _, req := range testRequests {
        fmt.Printf("\n📋 Task: %s (in:%d, out:%d, priority:%d)\n",
            req.TaskType, req.InputTokens, req.OutputTokens, req.Priority)
        fmt.Println(strings.Repeat("-", 70))
        for _, strategy := range strategies {
            decision := router.Route(req, strategy)
            if decision.SelectedModel != nil {
                fmt.Printf("  %-16s → %-20s | $%.6f | %s\n",
                    strategy, decision.SelectedModel.Name,
                    decision.EstimatedCost, decision.Reason[:minInt(40, len(decision.Reason))])
            } else {
                fmt.Printf("  %-16s → ❌ %s\n", strategy, decision.Reason)
            }
        }
    }

    fmt.Println("\n" + strings.Repeat("=", 69))
    fmt.Println("  Routing Statistics")
    fmt.Println(strings.Repeat("=", 69))
    fmt.Printf("Total Requests: %d\n", router.stats.TotalRequests)
    fmt.Printf("Total Cost: $%.4f\n", router.stats.TotalCost)
    fmt.Println("Model Usage Counts:")
    for name, count := range router.stats.ModelCounts {
        fmt.Printf("  %-20s: %d\n", name, count)
    }
}

func minInt(a, b int) int {
    if a < b {
        return a
    }
    return b
}

#!/usr/bin/env python3
"""
Terminal-Bench 2.1 Analysis Tool
Supports model comparison, cost-effectiveness, and scenario recommendation
"""

from dataclasses import dataclass
from typing import Dict, List, Tuple


@dataclass
class BenchmarkResult:
    model: str
    standard_score: float
    ultra_score: float
    input_price: float
    output_price: float
    category: str


class BenchmarkAnalyzer:
    def __init__(self):
        self.results = [
            BenchmarkResult("GPT-5.6 Sol Ultra", 91.9, 91.9, 5, 30, "flagship"),
            BenchmarkResult("GPT-5.6 Sol", 88.8, 91.9, 5, 30, "flagship"),
            BenchmarkResult("Claude Mythos 5", 88.0, 88.0, 10, 50, "flagship"),
            BenchmarkResult("Claude Fable 5", 84.3, 84.3, 10, 50, "flagship"),
            BenchmarkResult("GPT-5.6 Terra", 82.4, 86.1, 2.5, 15, "balanced"),
            BenchmarkResult("GPT-5.5", 79.2, 83.5, 5, 15, "balanced"),
            BenchmarkResult("GPT-5.6 Luna", 72.1, 75.8, 1, 6, "lightweight"),
            BenchmarkResult("DeepSeek V4-Pro", 72.8, 72.8, 0.435, 0.87, "opensource"),
        ]

    def cost_performance_analysis(self, input_tokens=1000, output_tokens=500):
        """Score per dollar — the core metric of GPT-5.6 pricing strategy."""
        analysis = []
        for r in self.results:
            cost = (input_tokens * r.input_price + output_tokens * r.output_price) / 1_000_000
            score_per_dollar = r.standard_score / cost if cost > 0 else float('inf')
            analysis.append({
                "model": r.model, "benchmark_score": r.standard_score,
                "cost_per_task": round(cost, 6),
                "score_per_dollar": round(score_per_dollar, 0),
                "category": r.category,
            })
        analysis.sort(key=lambda x: x["score_per_dollar"], reverse=True)
        return analysis

    def ultra_mode_improvement(self) -> List[Dict]:
        """Analyze Ultra mode performance improvement."""
        improvements = []
        for r in self.results:
            if r.ultra_score > r.standard_score:
                imp = ((r.ultra_score - r.standard_score) / r.standard_score) * 100
                improvements.append({
                    "model": r.model, "standard": r.standard_score,
                    "ultra": r.ultra_score, "improvement_pct": round(imp, 2),
                })
        improvements.sort(key=lambda x: x["improvement_pct"], reverse=True)
        return improvements

    def recommend_model(self, budget_constraint=0.1, min_quality=0.7, task_type="general"):
        """Recommend optimal model under constraints."""
        recommendations = []
        for r in self.results:
            cost = (1000 * r.input_price + 500 * r.output_price) / 1_000_000
            score_norm = r.standard_score / 100.0
            if cost > budget_constraint or score_norm < min_quality:
                continue
            task_fit = 1.0
            if task_type == "coding" and r.category == "flagship":
                task_fit = 1.3
            elif task_type == "batch" and r.category == "lightweight":
                task_fit = 1.4
            elif task_type == "chat" and r.category == "balanced":
                task_fit = 1.2
            effective = score_norm * task_fit / cost
            recommendations.append((r.model, f"Score: {effective:.1f}"))
        recommendations.sort(key=lambda x: float(x[1].split(": ")[1]), reverse=True)
        return recommendations


def main():
    analyzer = BenchmarkAnalyzer()

    print("=" * 70)
    print("Terminal-Bench 2.1 Deep Analysis")
    print("=" * 70)

    print("\n📊 Cost-Performance Analysis (Score per Dollar)")
    print("-" * 70)
    print(f"{'Model':<25} {'Score':<8} {'Cost/Task':<12} {'Score/$':<12} {'Category':<12}")
    print("-" * 70)
    for item in analyzer.cost_performance_analysis():
        print(f"{item['model']:<25} {item['benchmark_score']:<8.1f} "
              f"${item['cost_per_task']:<8.6f} {item['score_per_dollar']:<12,.0f} {item['category']:<12}")

    print("\n\n📊 Ultra Mode Improvement")
    print("-" * 50)
    print(f"{'Model':<25} {'Standard':<10} {'Ultra':<10} {'Improvement':<12}")
    print("-" * 50)
    for item in analyzer.ultra_mode_improvement():
        print(f"{item['model']:<25} {item['standard']:<10.1f} "
              f"{item['ultra']:<10.1f} +{item['improvement_pct']:<9.2f}%")

    print("\n\n🎯 Scenario Recommendations")
    print("-" * 70)
    scenarios = [
        ("Code Development", "coding", 0.5, 0.85),
        ("Batch Processing", "batch", 0.05, 0.6),
        ("Daily Chat", "chat", 0.1, 0.7),
        ("General Tasks", "general", 0.2, 0.75),
    ]
    for name, task_type, budget, min_qual in scenarios:
        print(f"\n  {name} (Budget: ${budget}, Min Quality: {min_qual})")
        for model, reason in analyzer.recommend_model(budget, min_qual, task_type)[:3]:
            print(f"    → {model:<25} {reason}")


if __name__ == "__main__":
    main()