entroplain 0.1.1 → 0.2.0

package/entroplain/__init__.py

@@ -1,33 +1,30 @@
-"""
-Entroplain — Entropy-based early exit for efficient agent reasoning.
-"""
-
-__version__ = "0.1.1"
-__author__ = "Entroplain Contributors"
-
-from .monitor import EntropyMonitor, calculate_entropy
-from .providers import (
-    OpenAIProvider,
-    AnthropicProvider,
-    GeminiProvider,
-    NVIDIAProvider,
-    OllamaProvider,
-    LlamaCppProvider,
-)
-from .hooks import track_entropy, early_exit
-from .proxy import EntropyProxy, ProxyConfig
-
-__all__ = [
-    "EntropyMonitor",
-    "calculate_entropy",
-    "OpenAIProvider",
-    "AnthropicProvider",
-    "GeminiProvider",
-    "NVIDIAProvider",
-    "OllamaProvider",
-    "LlamaCppProvider",
-    "track_entropy",
-    "early_exit",
-    "EntropyProxy",
-    "ProxyConfig",
-]
+"""
+Entroplain — Entropy-based early exit for efficient agent reasoning.
+"""
+
+__version__ = "0.2.0"
+__author__ = "Entroplain Contributors"
+
+from .monitor import EntropyMonitor, calculate_entropy
+from .providers import (
+    OpenAIProvider,
+    AnthropicProvider,
+    GeminiProvider,
+    NVIDIAProvider,
+    OllamaProvider,
+    LlamaCppProvider,
+)
+from .hooks import track_entropy, early_exit
+
+__all__ = [
+    "EntropyMonitor",
+    "calculate_entropy",
+    "OpenAIProvider",
+    "AnthropicProvider",
+    "GeminiProvider",
+    "NVIDIAProvider",
+    "OllamaProvider",
+    "LlamaCppProvider",
+    "track_entropy",
+    "early_exit",
+]

package/entroplain/cost_tracker.py

@@ -0,0 +1,231 @@
+"""
+Cost tracking and savings calculator.
+
+Estimates cost savings from early exit based on token usage.
+"""
+
+import math
+from dataclasses import dataclass
+from typing import Optional, Dict, Any
+from enum import Enum
+
+
+class PricingTier(Enum):
+    """Pricing tiers for different models."""
+    # OpenAI
+    GPT4O = ("gpt-4o", 2.50, 10.00)  # input, output per 1M tokens
+    GPT4O_MINI = ("gpt-4o-mini", 0.15, 0.60)
+    GPT4_TURBO = ("gpt-4-turbo", 10.00, 30.00)
+    
+    # Anthropic
+    CLAUDE_4_OPUS = ("claude-4-opus", 15.00, 75.00)
+    CLAUDE_4_SONNET = ("claude-4-sonnet", 3.00, 15.00)
+    
+    # NVIDIA
+    LLAMA_70B = ("meta/llama-3.1-70b-instruct", 0.70, 0.70)
+    LLAMA_405B = ("meta/llama-3.1-405b-instruct", 2.70, 2.70)
+    
+    # Default (unknown model)
+    DEFAULT = ("default", 1.00, 1.00)
+
+
+@dataclass
+class CostEstimate:
+    """Estimated cost for a completion."""
+    model: str
+    input_tokens: int
+    output_tokens: int
+    output_tokens_full: int  # If no early exit
+    cost_actual_usd: float
+    cost_full_usd: float
+    cost_saved_usd: float
+    savings_percent: float
+
+
+class CostTracker:
+    """
+    Track token usage and calculate cost savings.
+    
+    Usage:
+        tracker = CostTracker(model="gpt-4o")
+        tracker.track_input(100)  # 100 input tokens
+        tracker.track_output(50)  # 50 output tokens
+        tracker.set_full_estimate(150)  # Would have been 150 output tokens
+        
+        estimate = tracker.get_estimate()
+        print(f"Saved ${estimate.cost_saved_usd:.4f}")
+    """
+    
+    # Model name to pricing tier mapping
+    MODEL_ALIASES = {
+        # OpenAI
+        "gpt-4o": PricingTier.GPT4O,
+        "gpt-4o-mini": PricingTier.GPT4O_MINI,
+        "gpt-4-turbo": PricingTier.GPT4_TURBO,
+        "gpt-4-turbo-preview": PricingTier.GPT4_TURBO,
+        
+        # Anthropic
+        "claude-4-opus": PricingTier.CLAUDE_4_OPUS,
+        "claude-opus-4": PricingTier.CLAUDE_4_OPUS,
+        "claude-4-sonnet": PricingTier.CLAUDE_4_SONNET,
+        "claude-sonnet-4": PricingTier.CLAUDE_4_SONNET,
+        
+        # NVIDIA / Meta
+        "meta/llama-3.1-70b-instruct": PricingTier.LLAMA_70B,
+        "llama-3.1-70b": PricingTier.LLAMA_70B,
+        "meta/llama-3.1-405b-instruct": PricingTier.LLAMA_405B,
+        "llama-3.1-405b": PricingTier.LLAMA_405B,
+    }
+    
+    def __init__(
+        self,
+        model: str = "default",
+        custom_pricing: Optional[tuple] = None
+    ):
+        """
+        Initialize cost tracker.
+        
+        Args:
+            model: Model name (e.g., "gpt-4o", "claude-4-sonnet")
+            custom_pricing: Optional (input_price, output_price) per 1M tokens
+        """
+        self.model = model
+        self.input_tokens = 0
+        self.output_tokens = 0
+        self.estimated_full_output = None
+        self._custom_pricing = custom_pricing
+        
+        # Get pricing for model
+        if custom_pricing:
+            self._input_price, self._output_price = custom_pricing
+        else:
+            tier = self.MODEL_ALIASES.get(model.lower(), PricingTier.DEFAULT)
+            self._input_price, self._output_price = tier.value[1], tier.value[2]
+    
+    def track_input(self, tokens: int):
+        """Track input tokens."""
+        self.input_tokens += tokens
+    
+    def track_output(self, tokens: int):
+        """Track output tokens generated."""
+        self.output_tokens += tokens
+    
+    def set_full_estimate(self, tokens: int):
+        """Set estimate of what output would have been without early exit."""
+        self.estimated_full_output = tokens
+    
+    def estimate_full_output(self, multiplier: float = 2.0) -> int:
+        """
+        Auto-estimate full output if not set.
+        
+        Uses a simple multiplier based on observed tokens.
+        Default assumes early exit saves ~50%.
+        """
+        if self.estimated_full_output:
+            return self.estimated_full_output
+        return int(self.output_tokens * multiplier)
+    
+    def calculate_cost(self, input_tokens: int, output_tokens: int) -> float:
+        """Calculate cost for given token counts."""
+        input_cost = (input_tokens / 1_000_000) * self._input_price
+        output_cost = (output_tokens / 1_000_000) * self._output_price
+        return input_cost + output_cost
+    
+    def get_estimate(self) -> CostEstimate:
+        """Get cost estimate with savings calculation."""
+        full_output = self.estimate_full_output()
+        
+        cost_actual = self.calculate_cost(self.input_tokens, self.output_tokens)
+        cost_full = self.calculate_cost(self.input_tokens, full_output)
+        cost_saved = cost_full - cost_actual
+        
+        if cost_full > 0:
+            savings_pct = (cost_saved / cost_full) * 100
+        else:
+            savings_pct = 0.0
+        
+        return CostEstimate(
+            model=self.model,
+            input_tokens=self.input_tokens,
+            output_tokens=self.output_tokens,
+            output_tokens_full=full_output,
+            cost_actual_usd=cost_actual,
+            cost_full_usd=cost_full,
+            cost_saved_usd=cost_saved,
+            savings_percent=savings_pct
+        )
+    
+    def reset(self):
+        """Reset tracking for new request."""
+        self.input_tokens = 0
+        self.output_tokens = 0
+        self.estimated_full_output = None
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get current stats as dict."""
+        estimate = self.get_estimate()
+        return {
+            "model": estimate.model,
+            "input_tokens": estimate.input_tokens,
+            "output_tokens": estimate.output_tokens,
+            "output_tokens_full": estimate.output_tokens_full,
+            "tokens_saved": estimate.output_tokens_full - estimate.output_tokens,
+            "cost_actual_usd": estimate.cost_actual_usd,
+            "cost_full_usd": estimate.cost_full_usd,
+            "cost_saved_usd": estimate.cost_saved_usd,
+            "savings_percent": estimate.savings_percent,
+        }
+
+
+# Convenience function for quick estimates
+def estimate_savings(
+    model: str,
+    tokens_generated: int,
+    tokens_if_full: int,
+    input_tokens: int = 0
+) -> CostEstimate:
+    """
+    Quick estimate of cost savings.
+    
+    Args:
+        model: Model name
+        tokens_generated: Actual tokens generated (with early exit)
+        tokens_if_full: Tokens that would have been generated without early exit
+        input_tokens: Input prompt tokens
+    
+    Returns:
+        CostEstimate with savings details
+    """
+    tracker = CostTracker(model)
+    tracker.track_input(input_tokens)
+    tracker.track_output(tokens_generated)
+    tracker.set_full_estimate(tokens_if_full)
+    return tracker.get_estimate()
+
+
+def format_cost_report(estimate: CostEstimate) -> str:
+    """Format a human-readable cost report."""
+    lines = [
+        f"📊 Cost Report for {estimate.model}",
+        f"",
+        f"  Input tokens:    {estimate.input_tokens:,}",
+        f"  Output tokens:   {estimate.output_tokens:,} (actual)",
+        f"                   {estimate.output_tokens_full:,} (if no early exit)",
+        f"  Tokens saved:    {estimate.output_tokens_full - estimate.output_tokens:,}",
+        f"",
+        f"  Cost actual:     ${estimate.cost_actual_usd:.6f}",
+        f"  Cost if full:    ${estimate.cost_full_usd:.6f}",
+        f"  💰 Cost saved:   ${estimate.cost_saved_usd:.6f} ({estimate.savings_percent:.1f}%)",
+    ]
+    return "\n".join(lines)
+
+
+if __name__ == "__main__":
+    # Demo
+    estimate = estimate_savings(
+        model="gpt-4o",
+        tokens_generated=82,
+        tokens_if_full=150,
+        input_tokens=50
+    )
+    print(format_cost_report(estimate))

package/entroplain/dashboard.py

@@ -0,0 +1,368 @@
+"""
+Real-time entropy visualization dashboard.
+
+Run with: entroplain-dashboard --port 8765
+Then open: http://localhost:8050
+"""
+
+import asyncio
+import json
+from datetime import datetime
+from typing import Dict, List, Any, Optional
+from dataclasses import dataclass, field
+from fastapi import FastAPI, WebSocket
+from fastapi.responses import HTMLResponse
+import uvicorn
+
+
+@dataclass
+class DashboardConfig:
+    """Configuration for the dashboard."""
+    port: int = 8050
+    proxy_port: int = 8765
+    update_interval_ms: int = 100
+
+
+# HTML template for the dashboard
+DASHBOARD_HTML = """
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Entroplain Dashboard</title>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <style>
+        * { box-sizing: border-box; margin: 0; padding: 0; }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: #0a0a0a;
+            color: #e0e0e0;
+            padding: 20px;
+        }
+        .container { max-width: 1200px; margin: 0 auto; }
+        h1 {
+            font-size: 24px;
+            margin-bottom: 20px;
+            color: #4ade80;
+        }
+        .grid {
+            display: grid;
+            grid-template-columns: 1fr 300px;
+            gap: 20px;
+        }
+        .chart-container {
+            background: #1a1a1a;
+            border-radius: 8px;
+            padding: 20px;
+        }
+        .stats-panel {
+            display: flex;
+            flex-direction: column;
+            gap: 15px;
+        }
+        .stat-card {
+            background: #1a1a1a;
+            border-radius: 8px;
+            padding: 15px;
+        }
+        .stat-label {
+            font-size: 12px;
+            color: #888;
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+        }
+        .stat-value {
+            font-size: 32px;
+            font-weight: 600;
+            color: #fff;
+            margin-top: 5px;
+        }
+        .stat-value.savings { color: #4ade80; }
+        .stat-value.cost { color: #fbbf24; }
+        .valleys { color: #60a5fa; }
+        .status-badge {
+            display: inline-block;
+            padding: 4px 12px;
+            border-radius: 12px;
+            font-size: 12px;
+            font-weight: 500;
+        }
+        .status-active { background: #22c55e; color: #000; }
+        .status-idle { background: #374151; color: #888; }
+        .status-exited { background: #f59e0b; color: #000; }
+        #status { margin-top: 10px; }
+        .legend {
+            display: flex;
+            gap: 20px;
+            margin-top: 15px;
+            font-size: 12px;
+        }
+        .legend-item {
+            display: flex;
+            align-items: center;
+            gap: 5px;
+        }
+        .legend-dot {
+            width: 10px;
+            height: 10px;
+            border-radius: 50%;
+        }
+        .dot-entropy { background: #60a5fa; }
+        .dot-valley { background: #f59e0b; }
+        .dot-threshold { background: #ef4444; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>🎯 Entroplain Dashboard</h1>
+        
+        <div class="grid">
+            <div class="chart-container">
+                <canvas id="entropyChart" height="300"></canvas>
+                <div class="legend">
+                    <div class="legend-item">
+                        <div class="legend-dot dot-entropy"></div>
+                        <span>Entropy</span>
+                    </div>
+                    <div class="legend-item">
+                        <div class="legend-dot dot-valley"></div>
+                        <span>Valley Detected</span>
+                    </div>
+                    <div class="legend-item">
+                        <div class="legend-dot dot-threshold"></div>
+                        <span>Threshold (0.15)</span>
+                    </div>
+                </div>
+            </div>
+            
+            <div class="stats-panel">
+                <div class="stat-card">
+                    <div class="stat-label">Status</div>
+                    <div id="status">
+                        <span class="status-badge status-idle">Idle</span>
+                    </div>
+                </div>
+                
+                <div class="stat-card">
+                    <div class="stat-label">Tokens Generated</div>
+                    <div class="stat-value" id="tokens">0</div>
+                </div>
+                
+                <div class="stat-card">
+                    <div class="stat-label">Valleys Detected</div>
+                    <div class="stat-value valleys" id="valleys">0</div>
+                </div>
+                
+                <div class="stat-card">
+                    <div class="stat-label">Current Entropy</div>
+                    <div class="stat-value" id="currentEntropy">-</div>
+                </div>
+                
+                <div class="stat-card">
+                    <div class="stat-label">Mean Entropy</div>
+                    <div class="stat-value" id="meanEntropy">-</div>
+                </div>
+                
+                <div class="stat-card">
+                    <div class="stat-label">Tokens Saved</div>
+                    <div class="stat-value savings" id="saved">0%</div>
+                </div>
+                
+                <div class="stat-card">
+                    <div class="stat-label">Cost Saved</div>
+                    <div class="stat-value cost" id="costSaved">$0.00</div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        const ctx = document.getElementById('entropyChart').getContext('2d');
+        
+        const chart = new Chart(ctx, {
+            type: 'line',
+            data: {
+                labels: [],
+                datasets: [
+                    {
+                        label: 'Entropy',
+                        data: [],
+                        borderColor: '#60a5fa',
+                        backgroundColor: 'rgba(96, 165, 250, 0.1)',
+                        fill: true,
+                        tension: 0.3,
+                        pointRadius: 0,
+                    },
+                    {
+                        label: 'Threshold',
+                        data: [],
+                        borderColor: '#ef4444',
+                        borderDash: [5, 5],
+                        pointRadius: 0,
+                        fill: false,
+                    },
+                    {
+                        label: 'Valleys',
+                        data: [],
+                        borderColor: '#f59e0b',
+                        pointBackgroundColor: '#f59e0b',
+                        pointRadius: 6,
+                        showLine: false,
+                    }
+                ]
+            },
+            options: {
+                responsive: true,
+                maintainAspectRatio: false,
+                animation: { duration: 0 },
+                scales: {
+                    x: {
+                        title: { display: true, text: 'Tokens', color: '#888' },
+                        grid: { color: '#333' },
+                        ticks: { color: '#888' }
+                    },
+                    y: {
+                        title: { display: true, text: 'Entropy (bits)', color: '#888' },
+                        min: 0,
+                        max: 1,
+                        grid: { color: '#333' },
+                        ticks: { color: '#888' }
+                    }
+                },
+                plugins: {
+                    legend: { display: false }
+                }
+            }
+        });
+
+        const ws = new WebSocket(`ws://${location.host}/ws`);
+        
+        ws.onmessage = (event) => {
+            const data = JSON.parse(event.data);
+            updateChart(data);
+            updateStats(data);
+        };
+
+        function updateChart(data) {
+            const labels = data.trajectory.map((_, i) => i);
+            const entropies = data.trajectory.map(p => p.entropy);
+            const threshold = data.trajectory.map(() => data.threshold || 0.15);
+            
+            // Mark valleys
+            const valleyPoints = data.trajectory.map(p => 
+                p.is_valley ? p.entropy : null
+            );
+
+            chart.data.labels = labels;
+            chart.data.datasets[0].data = entropies;
+            chart.data.datasets[1].data = threshold;
+            chart.data.datasets[2].data = valleyPoints;
+            chart.update();
+        }
+
+        function updateStats(data) {
+            document.getElementById('tokens').textContent = data.token_count;
+            document.getElementById('valleys').textContent = data.valley_count;
+            document.getElementById('currentEntropy').textContent = 
+                data.current_entropy ? data.current_entropy.toFixed(3) : '-';
+            document.getElementById('meanEntropy').textContent = 
+                data.mean_entropy ? data.mean_entropy.toFixed(3) : '-';
+            
+            // Calculate savings
+            if (data.exited_early) {
+                const savedPct = Math.round((data.tokens_saved / data.tokens_total) * 100);
+                document.getElementById('saved').textContent = savedPct + '%';
+                document.getElementById('costSaved').textContent = '$' + data.cost_saved.toFixed(4);
+            }
+            
+            // Update status
+            const statusEl = document.getElementById('status');
+            if (data.exited_early) {
+                statusEl.innerHTML = '<span class="status-badge status-exited">Exited Early</span>';
+            } else if (data.active) {
+                statusEl.innerHTML = '<span class="status-badge status-active">Active</span>';
+            } else {
+                statusEl.innerHTML = '<span class="status-badge status-idle">Idle</span>';
+            }
+        }
+    </script>
+</body>
+</html>
+"""
+
+
+class Dashboard:
+    """Real-time dashboard server."""
+    
+    def __init__(self, config: DashboardConfig):
+        self.config = config
+        self.app = FastAPI(title="Entroplain Dashboard")
+        self._websocket_clients: List[WebSocket] = []
+        self._current_data: Dict[str, Any] = {
+            "trajectory": [],
+            "token_count": 0,
+            "valley_count": 0,
+            "current_entropy": 0,
+            "mean_entropy": 0,
+            "active": False,
+            "exited_early": False,
+        }
+        self._setup_routes()
+    
+    def _setup_routes(self):
+        @self.app.get("/")
+        async def root():
+            return HTMLResponse(content=DASHBOARD_HTML)
+        
+        @self.app.websocket("/ws")
+        async def websocket_endpoint(websocket: WebSocket):
+            await websocket.accept()
+            self._websocket_clients.append(websocket)
+            try:
+                while True:
+                    # Keep connection alive
+                    data = await websocket.receive_text()
+            except Exception:
+                self._websocket_clients.remove(websocket)
+    
+    async def broadcast_update(self, data: Dict[str, Any]):
+        """Broadcast entropy data to all connected clients."""
+        self._current_data = data
+        for client in self._websocket_clients:
+            try:
+                await client.send_json(data)
+            except Exception:
+                self._websocket_clients.remove(client)
+    
+    def run(self):
+        """Start the dashboard server."""
+        uvicorn.run(self.app, host="0.0.0.0", port=self.config.port)
+
+
+def main():
+    """CLI entry point for the dashboard."""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Entroplain Dashboard")
+    parser.add_argument("--port", type=int, default=8050, help="Dashboard port")
+    parser.add_argument("--proxy-port", type=int, default=8765, help="Proxy port to monitor")
+    args = parser.parse_args()
+    
+    config = DashboardConfig(port=args.port, proxy_port=args.proxy_port)
+    dashboard = Dashboard(config)
+    
+    print(f"""
+==============================================================
+  ENTROPPLAIN DASHBOARD
+==============================================================
+  Dashboard: http://localhost:{args.port}
+  Monitoring proxy on port {args.proxy_port}
+==============================================================
+  Open the dashboard to see real-time entropy visualization
+==============================================================
+""")
+    
+    dashboard.run()
+
+
+if __name__ == "__main__":
+    main()