hanzo 0.3.20__tar.gz → 0.3.21__tar.gz

{hanzo-0.3.20 → hanzo-0.3.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanzo
-Version: 0.3.20
+Version: 0.3.21
 Summary: Hanzo AI - Complete AI Infrastructure Platform with CLI, Router, MCP, and Agent Runtime
 Project-URL: Homepage, https://hanzo.ai
 Project-URL: Repository, https://github.com/hanzoai/python-sdk

{hanzo-0.3.20 → hanzo-0.3.21}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hanzo"
-version = "0.3.20"
+version = "0.3.21"
 description = "Hanzo AI - Complete AI Infrastructure Platform with CLI, Router, MCP, and Agent Runtime"
 authors = [
     {name = "Hanzo AI", email = "dev@hanzo.ai"},

{hanzo-0.3.20 → hanzo-0.3.21}/src/hanzo/cli.py

@@ -26,7 +26,7 @@ from .utils.output import console
 from .interactive.repl import HanzoREPL
 
 # Version
-__version__ = "0.3.20"
+__version__ = "0.3.21"
 
 
 @click.group(invoke_without_command=True)

{hanzo-0.3.20 → hanzo-0.3.21}/src/hanzo/dev.py

@@ -929,21 +929,14 @@ Examples:
             # Try smart fallback if no specific model configured
             if not hasattr(self.orchestrator, 'orchestrator_model') or \
                self.orchestrator.orchestrator_model == "auto":
-                from .fallback_handler import smart_chat
-                response = await smart_chat(enhanced_message, console)
+                # Use streaming if available
+                from .streaming import stream_with_fallback
+                response = await stream_with_fallback(enhanced_message, console)
+                
                 if response:
                     # Save AI response to memory
                     self.memory_manager.add_message("assistant", response)
-                    
-                    from rich.panel import Panel
-                    console.print()
-                    console.print(Panel(
-                        response,
-                        title="[bold cyan]AI Response[/bold cyan]",
-                        title_align="left",
-                        border_style="dim cyan",
-                        padding=(1, 2)
-                    ))
+                    # Response already displayed by streaming handler
                     return
                 else:
                     console.print("[red]No AI options available. Please configure API keys or install tools.[/red]")

{hanzo-0.3.20 → hanzo-0.3.21}/src/hanzo/fallback_handler.py

@@ -158,6 +158,8 @@ async def smart_chat(message: str, console=None) -> Optional[str]:
     Smart chat that automatically tries available AI options.
     Returns the AI response or None if all options fail.
     """
+    from .rate_limiter import smart_limiter
+    
     handler = FallbackHandler()
     
     if console:
@@ -171,17 +173,20 @@ async def smart_chat(message: str, console=None) -> Optional[str]:
     
     option_type, model = best_option
     
-    # Try the primary option
+    # Try the primary option with rate limiting
     try:
         if option_type == "openai_api":
-            from openai import AsyncOpenAI
-            client = AsyncOpenAI()
-            response = await client.chat.completions.create(
-                model="gpt-4",
-                messages=[{"role": "user", "content": message}],
-                max_tokens=500
-            )
-            return response.choices[0].message.content
+            async def call_openai():
+                from openai import AsyncOpenAI
+                client = AsyncOpenAI()
+                response = await client.chat.completions.create(
+                    model="gpt-4",
+                    messages=[{"role": "user", "content": message}],
+                    max_tokens=500
+                )
+                return response.choices[0].message.content
+            
+            return await smart_limiter.execute_with_limit("openai", call_openai)
             
         elif option_type == "anthropic_api":
             from anthropic import AsyncAnthropic

hanzo-0.3.21/src/hanzo/rate_limiter.py

@@ -0,0 +1,332 @@
+"""
+Rate limiting and error recovery for Hanzo Dev.
+Prevents API overuse and handles failures gracefully.
+"""
+
+import time
+import asyncio
+from typing import Dict, Optional, Any, Callable
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from collections import deque
+import random
+
+
+@dataclass
+class RateLimitConfig:
+    """Configuration for rate limiting."""
+    requests_per_minute: int = 20
+    requests_per_hour: int = 100
+    burst_size: int = 5
+    cooldown_seconds: int = 60
+    max_retries: int = 3
+    backoff_base: float = 2.0
+    jitter: bool = True
+
+
+@dataclass
+class RateLimitState:
+    """Current state of rate limiter."""
+    minute_requests: deque = field(default_factory=lambda: deque(maxlen=60))
+    hour_requests: deque = field(default_factory=lambda: deque(maxlen=3600))
+    last_request: Optional[datetime] = None
+    consecutive_errors: int = 0
+    total_requests: int = 0
+    total_errors: int = 0
+    is_throttled: bool = False
+    throttle_until: Optional[datetime] = None
+
+
+class RateLimiter:
+    """Rate limiter with error recovery."""
+    
+    def __init__(self, config: RateLimitConfig = None):
+        """Initialize rate limiter."""
+        self.config = config or RateLimitConfig()
+        self.states: Dict[str, RateLimitState] = {}
+        
+    def get_state(self, key: str = "default") -> RateLimitState:
+        """Get or create state for a key."""
+        if key not in self.states:
+            self.states[key] = RateLimitState()
+        return self.states[key]
+    
+    async def check_rate_limit(self, key: str = "default") -> tuple[bool, float]:
+        """
+        Check if request is allowed.
+        Returns (allowed, wait_seconds).
+        """
+        state = self.get_state(key)
+        now = datetime.now()
+        
+        # Check if throttled
+        if state.is_throttled and state.throttle_until:
+            if now < state.throttle_until:
+                wait_seconds = (state.throttle_until - now).total_seconds()
+                return False, wait_seconds
+            else:
+                # Throttle period ended
+                state.is_throttled = False
+                state.throttle_until = None
+        
+        # Clean old requests
+        minute_ago = now - timedelta(minutes=1)
+        hour_ago = now - timedelta(hours=1)
+        
+        # Remove old requests from queues
+        while state.minute_requests and state.minute_requests[0] < minute_ago:
+            state.minute_requests.popleft()
+        
+        while state.hour_requests and state.hour_requests[0] < hour_ago:
+            state.hour_requests.popleft()
+        
+        # Check minute limit
+        if len(state.minute_requests) >= self.config.requests_per_minute:
+            # Calculate wait time
+            oldest = state.minute_requests[0]
+            wait_seconds = (oldest + timedelta(minutes=1) - now).total_seconds()
+            return False, max(0, wait_seconds)
+        
+        # Check hour limit
+        if len(state.hour_requests) >= self.config.requests_per_hour:
+            # Calculate wait time
+            oldest = state.hour_requests[0]
+            wait_seconds = (oldest + timedelta(hours=1) - now).total_seconds()
+            return False, max(0, wait_seconds)
+        
+        # Check burst limit
+        if state.last_request:
+            time_since_last = (now - state.last_request).total_seconds()
+            if time_since_last < 1.0 / self.config.burst_size:
+                wait_seconds = (1.0 / self.config.burst_size) - time_since_last
+                return False, wait_seconds
+        
+        return True, 0
+    
+    async def acquire(self, key: str = "default") -> bool:
+        """
+        Acquire a rate limit slot.
+        Waits if necessary.
+        """
+        while True:
+            allowed, wait_seconds = await self.check_rate_limit(key)
+            
+            if allowed:
+                # Record request
+                state = self.get_state(key)
+                now = datetime.now()
+                state.minute_requests.append(now)
+                state.hour_requests.append(now)
+                state.last_request = now
+                state.total_requests += 1
+                return True
+            
+            # Wait before retrying
+            if wait_seconds > 0:
+                await asyncio.sleep(min(wait_seconds, 5))  # Check every 5 seconds max
+    
+    def record_error(self, key: str = "default", error: Exception = None):
+        """Record an error for the key."""
+        state = self.get_state(key)
+        state.consecutive_errors += 1
+        state.total_errors += 1
+        
+        # Implement exponential backoff on errors
+        if state.consecutive_errors >= 3:
+            # Throttle for increasing periods
+            backoff_minutes = min(
+                self.config.backoff_base ** (state.consecutive_errors - 2),
+                60  # Max 1 hour
+            )
+            state.is_throttled = True
+            state.throttle_until = datetime.now() + timedelta(minutes=backoff_minutes)
+    
+    def record_success(self, key: str = "default"):
+        """Record a successful request."""
+        state = self.get_state(key)
+        state.consecutive_errors = 0
+    
+    def get_status(self, key: str = "default") -> Dict[str, Any]:
+        """Get current status for monitoring."""
+        state = self.get_state(key)
+        now = datetime.now()
+        
+        return {
+            "requests_last_minute": len(state.minute_requests),
+            "requests_last_hour": len(state.hour_requests),
+            "total_requests": state.total_requests,
+            "total_errors": state.total_errors,
+            "consecutive_errors": state.consecutive_errors,
+            "is_throttled": state.is_throttled,
+            "throttle_remaining": (
+                (state.throttle_until - now).total_seconds()
+                if state.throttle_until and now < state.throttle_until
+                else 0
+            ),
+            "minute_limit": self.config.requests_per_minute,
+            "hour_limit": self.config.requests_per_hour,
+        }
+
+
+class ErrorRecovery:
+    """Error recovery with retries and fallback."""
+    
+    def __init__(self, rate_limiter: RateLimiter = None):
+        """Initialize error recovery."""
+        self.rate_limiter = rate_limiter or RateLimiter()
+        self.fallback_handlers: Dict[type, Callable] = {}
+        
+    def register_fallback(self, error_type: type, handler: Callable):
+        """Register a fallback handler for an error type."""
+        self.fallback_handlers[error_type] = handler
+    
+    async def with_retry(
+        self,
+        func: Callable,
+        *args,
+        key: str = "default",
+        max_retries: Optional[int] = None,
+        **kwargs
+    ) -> Any:
+        """
+        Execute function with retry logic.
+        """
+        max_retries = max_retries or self.rate_limiter.config.max_retries
+        last_error = None
+        
+        for attempt in range(max_retries):
+            try:
+                # Check rate limit
+                await self.rate_limiter.acquire(key)
+                
+                # Execute function
+                result = await func(*args, **kwargs)
+                
+                # Record success
+                self.rate_limiter.record_success(key)
+                
+                return result
+                
+            except Exception as e:
+                last_error = e
+                self.rate_limiter.record_error(key, e)
+                
+                # Check for fallback handler
+                for error_type, handler in self.fallback_handlers.items():
+                    if isinstance(e, error_type):
+                        try:
+                            return await handler(*args, **kwargs)
+                        except:
+                            pass  # Fallback failed, continue with retry
+                
+                # Calculate backoff
+                if attempt < max_retries - 1:
+                    backoff = self.rate_limiter.config.backoff_base ** attempt
+                    
+                    # Add jitter if configured
+                    if self.rate_limiter.config.jitter:
+                        backoff *= (0.5 + random.random())
+                    
+                    await asyncio.sleep(min(backoff, 60))  # Max 60 seconds
+        
+        # All retries failed
+        raise last_error or Exception("All retry attempts failed")
+    
+    async def with_circuit_breaker(
+        self,
+        func: Callable,
+        *args,
+        key: str = "default",
+        threshold: int = 5,
+        timeout: int = 60,
+        **kwargs
+    ) -> Any:
+        """
+        Execute function with circuit breaker pattern.
+        """
+        state = self.rate_limiter.get_state(key)
+        
+        # Check if circuit is open
+        if state.is_throttled:
+            raise Exception(f"Circuit breaker open for {key}")
+        
+        try:
+            result = await self.with_retry(func, *args, key=key, **kwargs)
+            return result
+            
+        except Exception as e:
+            # Check if we should open the circuit
+            if state.consecutive_errors >= threshold:
+                state.is_throttled = True
+                state.throttle_until = datetime.now() + timedelta(seconds=timeout)
+                raise Exception(f"Circuit breaker triggered for {key}: {e}")
+            raise
+
+
+class SmartRateLimiter:
+    """Smart rate limiter that adapts to API responses."""
+    
+    def __init__(self):
+        """Initialize smart rate limiter."""
+        self.limiters: Dict[str, RateLimiter] = {}
+        self.recovery = ErrorRecovery()
+        
+        # Default configs for known APIs
+        self.configs = {
+            "openai": RateLimitConfig(
+                requests_per_minute=60,
+                requests_per_hour=1000,
+                burst_size=10
+            ),
+            "anthropic": RateLimitConfig(
+                requests_per_minute=50,
+                requests_per_hour=1000,
+                burst_size=5
+            ),
+            "local": RateLimitConfig(
+                requests_per_minute=100,
+                requests_per_hour=10000,
+                burst_size=20
+            ),
+            "free": RateLimitConfig(
+                requests_per_minute=10,
+                requests_per_hour=100,
+                burst_size=2
+            ),
+        }
+    
+    def get_limiter(self, api_type: str) -> RateLimiter:
+        """Get or create limiter for API type."""
+        if api_type not in self.limiters:
+            config = self.configs.get(api_type, RateLimitConfig())
+            self.limiters[api_type] = RateLimiter(config)
+        return self.limiters[api_type]
+    
+    async def execute_with_limit(
+        self,
+        api_type: str,
+        func: Callable,
+        *args,
+        **kwargs
+    ) -> Any:
+        """Execute function with appropriate rate limiting."""
+        limiter = self.get_limiter(api_type)
+        recovery = ErrorRecovery(limiter)
+        
+        return await recovery.with_retry(
+            func,
+            *args,
+            key=api_type,
+            **kwargs
+        )
+    
+    def get_all_status(self) -> Dict[str, Dict[str, Any]]:
+        """Get status of all limiters."""
+        return {
+            api_type: limiter.get_status()
+            for api_type, limiter in self.limiters.items()
+        }
+
+
+# Global instance for easy use
+smart_limiter = SmartRateLimiter()

hanzo-0.3.21/src/hanzo/streaming.py

@@ -0,0 +1,271 @@
+"""
+Streaming response handler for Hanzo Dev.
+Provides real-time feedback as AI generates responses.
+"""
+
+import asyncio
+from typing import AsyncGenerator, Optional, Callable
+from rich.console import Console
+from rich.live import Live
+from rich.panel import Panel
+from rich.markdown import Markdown
+import time
+
+
+class StreamingHandler:
+    """Handles streaming responses from AI models."""
+    
+    def __init__(self, console: Console = None):
+        """Initialize streaming handler."""
+        self.console = console or Console()
+        self.current_response = ""
+        self.is_streaming = False
+        
+    async def stream_openai(self, client, messages: list, model: str = "gpt-4") -> str:
+        """Stream response from OpenAI API."""
+        try:
+            stream = await client.chat.completions.create(
+                model=model,
+                messages=messages,
+                stream=True,
+                max_tokens=1000
+            )
+            
+            self.current_response = ""
+            self.is_streaming = True
+            
+            with Live(
+                Panel("", title="[bold cyan]AI Response[/bold cyan]", 
+                      title_align="left", border_style="dim cyan"),
+                console=self.console,
+                refresh_per_second=10
+            ) as live:
+                async for chunk in stream:
+                    if chunk.choices[0].delta.content:
+                        self.current_response += chunk.choices[0].delta.content
+                        live.update(
+                            Panel(
+                                Markdown(self.current_response),
+                                title="[bold cyan]AI Response[/bold cyan]",
+                                title_align="left",
+                                border_style="dim cyan",
+                                padding=(1, 2)
+                            )
+                        )
+                        
+            self.is_streaming = False
+            return self.current_response
+            
+        except Exception as e:
+            self.console.print(f"[red]Streaming error: {e}[/red]")
+            self.is_streaming = False
+            return None
+    
+    async def stream_anthropic(self, client, messages: list, model: str = "claude-3-5-sonnet-20241022") -> str:
+        """Stream response from Anthropic API."""
+        try:
+            self.current_response = ""
+            self.is_streaming = True
+            
+            with Live(
+                Panel("", title="[bold cyan]AI Response[/bold cyan]",
+                      title_align="left", border_style="dim cyan"),
+                console=self.console,
+                refresh_per_second=10
+            ) as live:
+                async with client.messages.stream(
+                    model=model,
+                    messages=messages,
+                    max_tokens=1000
+                ) as stream:
+                    async for text in stream.text_stream:
+                        self.current_response += text
+                        live.update(
+                            Panel(
+                                Markdown(self.current_response),
+                                title="[bold cyan]AI Response[/bold cyan]",
+                                title_align="left",
+                                border_style="dim cyan",
+                                padding=(1, 2)
+                            )
+                        )
+            
+            self.is_streaming = False
+            return self.current_response
+            
+        except Exception as e:
+            self.console.print(f"[red]Streaming error: {e}[/red]")
+            self.is_streaming = False
+            return None
+    
+    async def stream_ollama(self, message: str, model: str = "llama3.2") -> str:
+        """Stream response from Ollama local model."""
+        import httpx
+        
+        try:
+            self.current_response = ""
+            self.is_streaming = True
+            
+            with Live(
+                Panel("", title="[bold cyan]AI Response (Local)[/bold cyan]",
+                      title_align="left", border_style="dim cyan"),
+                console=self.console,
+                refresh_per_second=10
+            ) as live:
+                async with httpx.AsyncClient() as client:
+                    async with client.stream(
+                        "POST",
+                        "http://localhost:11434/api/generate",
+                        json={"model": model, "prompt": message, "stream": True},
+                        timeout=60.0
+                    ) as response:
+                        async for line in response.aiter_lines():
+                            if line:
+                                import json
+                                data = json.loads(line)
+                                if "response" in data:
+                                    self.current_response += data["response"]
+                                    live.update(
+                                        Panel(
+                                            Markdown(self.current_response),
+                                            title="[bold cyan]AI Response (Local)[/bold cyan]",
+                                            title_align="left",
+                                            border_style="dim cyan",
+                                            padding=(1, 2)
+                                        )
+                                    )
+                                if data.get("done", False):
+                                    break
+            
+            self.is_streaming = False
+            return self.current_response
+            
+        except Exception as e:
+            self.console.print(f"[red]Ollama streaming error: {e}[/red]")
+            self.is_streaming = False
+            return None
+    
+    async def simulate_streaming(self, text: str, delay: float = 0.02) -> str:
+        """Simulate streaming for non-streaming APIs."""
+        self.current_response = ""
+        self.is_streaming = True
+        
+        words = text.split()
+        
+        with Live(
+            Panel("", title="[bold cyan]AI Response[/bold cyan]",
+                  title_align="left", border_style="dim cyan"),
+            console=self.console,
+            refresh_per_second=20
+        ) as live:
+            for i, word in enumerate(words):
+                self.current_response += word
+                if i < len(words) - 1:
+                    self.current_response += " "
+                
+                live.update(
+                    Panel(
+                        Markdown(self.current_response),
+                        title="[bold cyan]AI Response[/bold cyan]",
+                        title_align="left",
+                        border_style="dim cyan",
+                        padding=(1, 2)
+                    )
+                )
+                await asyncio.sleep(delay)
+        
+        self.is_streaming = False
+        return self.current_response
+    
+    def stop_streaming(self):
+        """Stop current streaming operation."""
+        self.is_streaming = False
+        if self.current_response:
+            self.console.print(f"\n[yellow]Streaming interrupted[/yellow]")
+
+
+class TypewriterEffect:
+    """Provides typewriter effect for text output."""
+    
+    def __init__(self, console: Console = None):
+        self.console = console or Console()
+    
+    async def type_text(self, text: str, speed: float = 0.03):
+        """Type text with typewriter effect."""
+        for char in text:
+            self.console.print(char, end="")
+            await asyncio.sleep(speed)
+        self.console.print()  # New line at end
+    
+    async def type_code(self, code: str, language: str = "python", speed: float = 0.01):
+        """Type code with syntax highlighting."""
+        from rich.syntax import Syntax
+        
+        # Build up code progressively
+        current_code = ""
+        lines = code.split('\n')
+        
+        with Live(console=self.console, refresh_per_second=30) as live:
+            for line in lines:
+                for char in line:
+                    current_code += char
+                    syntax = Syntax(current_code, language, theme="monokai", line_numbers=True)
+                    live.update(syntax)
+                    await asyncio.sleep(speed)
+                current_code += '\n'
+                syntax = Syntax(current_code, language, theme="monokai", line_numbers=True)
+                live.update(syntax)
+
+
+async def stream_with_fallback(message: str, console: Console = None) -> Optional[str]:
+    """
+    Stream response with automatic fallback to available options.
+    """
+    import os
+    handler = StreamingHandler(console)
+    
+    # Try OpenAI streaming
+    if os.getenv("OPENAI_API_KEY"):
+        try:
+            from openai import AsyncOpenAI
+            client = AsyncOpenAI()
+            return await handler.stream_openai(
+                client,
+                [{"role": "user", "content": message}]
+            )
+        except Exception as e:
+            if console:
+                console.print(f"[yellow]OpenAI streaming failed: {e}[/yellow]")
+    
+    # Try Anthropic streaming
+    if os.getenv("ANTHROPIC_API_KEY"):
+        try:
+            from anthropic import AsyncAnthropic
+            client = AsyncAnthropic()
+            return await handler.stream_anthropic(
+                client,
+                [{"role": "user", "content": message}]
+            )
+        except Exception as e:
+            if console:
+                console.print(f"[yellow]Anthropic streaming failed: {e}[/yellow]")
+    
+    # Try Ollama streaming
+    try:
+        return await handler.stream_ollama(message)
+    except:
+        pass
+    
+    # Fallback to non-streaming with simulated effect
+    if console:
+        console.print("[yellow]Falling back to non-streaming mode[/yellow]")
+    
+    # Get response from fallback handler
+    from .fallback_handler import smart_chat
+    response = await smart_chat(message, console)
+    
+    if response:
+        # Simulate streaming
+        return await handler.simulate_streaming(response)
+    
+    return None