hanzo 0.3.21__tar.gz → 0.3.22__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanzo
-Version: 0.3.21
+Version: 0.3.22
 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.21 → hanzo-0.3.22}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hanzo"
-version = "0.3.21"
+version = "0.3.22"
 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.21 → hanzo-0.3.22}/src/hanzo/cli.py

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

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

@@ -697,34 +697,35 @@ class HanzoDevREPL:
             padding=(0, 1)
         ))
         console.print()
+        
+        # Check for available API keys and show status
+        from .fallback_handler import FallbackHandler
+        handler = FallbackHandler()
+        if not handler.fallback_order:
+            console.print("[yellow]⚠️  No API keys detected[/yellow]")
+            console.print("[dim]Set OPENAI_API_KEY or ANTHROPIC_API_KEY to enable AI[/dim]")
+            console.print()
+        else:
+            primary = handler.fallback_order[0][1]
+            console.print(f"[green]✅ Using {primary} for AI responses[/green]")
+            console.print()
 
         while True:
             try:
-                # Draw input box border (top)
-                console.print("[dim white]╭" + "─" * 78 + "╮[/dim white]")
-                
-                # Get input with styled prompt inside the box
-                console.print("[dim white]│[/dim white] ", end="")
-                
+                # Simple prompt without box borders to avoid rendering issues
                 try:
-                    # Get input - using simple input() wrapped in executor for async
-                    # The visual box is drawn by console.print statements
+                    # Add spacing to prevent UI cutoff at bottom
                     user_input = await asyncio.get_event_loop().run_in_executor(
                         None,
                         input,
-                        '› '  # Using › instead of > for a more modern look
+                        '› '  # Clean prompt
                     )
-                    
-                    # Draw input box border (bottom)
-                    console.print("[dim white]╰" + "─" * 78 + "╯[/dim white]")
+                    console.print()  # Add spacing after input
                     
                 except EOFError:
                     console.print()  # New line before exit
-                    console.print("[dim white]╰" + "─" * 78 + "╯[/dim white]")
                     break
                 except KeyboardInterrupt:
-                    console.print()  # Complete the box
-                    console.print("[dim white]╰" + "─" * 78 + "╯[/dim white]")
                     console.print("\n[dim yellow]Use /exit to quit[/dim]")
                     continue
 
@@ -1044,8 +1045,25 @@ Examples:
             await self._use_local_model(message)
             return
         
-        # Try OpenAI first
-        if os.getenv("OPENAI_API_KEY"):
+        # Use the fallback handler to intelligently try available options
+        from .fallback_handler import smart_chat
+        response = await smart_chat(message, console=console)
+        
+        if 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)
+            ))
+            return
+        
+        # Try OpenAI first explicitly (in case fallback handler missed it)
+        openai_key = os.environ.get("OPENAI_API_KEY") or os.getenv("OPENAI_API_KEY")
+        if openai_key:
             try:
                 from openai import AsyncOpenAI
                 
@@ -1578,13 +1596,10 @@ async def run_dev_orchestrator(**kwargs):
             console_obj.print("[red]Failed to initialize network[/red]")
             return
     else:
-        # Fallback to multi-Claude mode
-        console_obj.print(f"[cyan]Mode: Multi-Claude Orchestration (legacy)[/cyan]")
-        console_obj.print(
-            f"Instances: {instances} (1 primary + {instances-1} critic{'s' if instances > 2 else ''})"
-        )
+        # Fallback to API mode
+        console_obj.print(f"[cyan]Mode: AI Chat[/cyan]")
+        console_obj.print(f"Model: {orchestrator_model}")
         console_obj.print(f"MCP Tools: {'Enabled' if mcp_tools else 'Disabled'}")
-        console_obj.print(f"Networking: {'Enabled' if network_mode else 'Disabled'}")
         console_obj.print(f"Guardrails: {'Enabled' if guardrails else 'Disabled'}\n")
 
         orchestrator = MultiClaudeOrchestrator(
@@ -2216,6 +2231,21 @@ class MultiClaudeOrchestrator(HanzoDevOrchestrator):
 
     async def initialize(self):
         """Initialize all Claude instances with MCP networking."""
+        # Check if Claude is available first
+        claude_available = False
+        try:
+            import shutil
+            if self.claude_code_path and Path(self.claude_code_path).exists():
+                claude_available = True
+            elif shutil.which("claude"):
+                claude_available = True
+        except:
+            pass
+        
+        if not claude_available:
+            # Skip Claude instance initialization - will use API fallback silently
+            return
+        
         self.console.print("[cyan]Initializing Claude instances...[/cyan]")
 
         for i in range(self.num_instances):
@@ -2237,7 +2267,8 @@ class MultiClaudeOrchestrator(HanzoDevOrchestrator):
             if success:
                 self.console.print(f"[green]✓ Instance {i} started[/green]")
             else:
-                self.console.print(f"[red]✗ Failed to start instance {i}[/red]")
+                # Don't show error, just skip silently
+                pass
 
     async def _create_instance_config(self, index: int, role: str) -> Dict:
         """Create configuration for a Claude instance."""
@@ -2377,7 +2408,12 @@ class MultiClaudeOrchestrator(HanzoDevOrchestrator):
 
         # Check if instances are initialized
         if not self.claude_instances:
-            # No instances started, use direct API
+            # No instances started, use fallback handler for smart routing
+            from .fallback_handler import smart_chat
+            response = await smart_chat(task, console=self.console)
+            if response:
+                return {"output": response, "success": True}
+            # If smart_chat fails, try direct API as last resort
             return await self._call_api_model(task)
 
         # Step 1: Primary execution
@@ -2530,11 +2566,12 @@ class MultiClaudeOrchestrator(HanzoDevOrchestrator):
         """Call API-based model and return structured response."""
         import os
         
-        # Try OpenAI
-        if os.getenv("OPENAI_API_KEY"):
+        # Try OpenAI first (check environment variable properly)
+        openai_key = os.environ.get("OPENAI_API_KEY") or os.getenv("OPENAI_API_KEY")
+        if openai_key:
             try:
                 from openai import AsyncOpenAI
-                client = AsyncOpenAI()
+                client = AsyncOpenAI(api_key=openai_key)
                 response = await client.chat.completions.create(
                     model="gpt-4",
                     messages=[{"role": "user", "content": prompt}],
@@ -2546,10 +2583,11 @@ class MultiClaudeOrchestrator(HanzoDevOrchestrator):
                 logger.error(f"OpenAI API error: {e}")
         
         # Try Anthropic
-        if os.getenv("ANTHROPIC_API_KEY"):
+        anthropic_key = os.environ.get("ANTHROPIC_API_KEY") or os.getenv("ANTHROPIC_API_KEY")
+        if anthropic_key:
             try:
                 from anthropic import AsyncAnthropic
-                client = AsyncAnthropic()
+                client = AsyncAnthropic(api_key=anthropic_key)
                 response = await client.messages.create(
                     model="claude-3-5-sonnet-20241022",
                     messages=[{"role": "user", "content": prompt}],
@@ -2560,6 +2598,12 @@ class MultiClaudeOrchestrator(HanzoDevOrchestrator):
             except Exception as e:
                 logger.error(f"Anthropic API error: {e}")
         
+        # Try fallback handler as last resort
+        from .fallback_handler import smart_chat
+        response = await smart_chat(prompt, console=None)  # No console to avoid duplicate messages
+        if response:
+            return {"output": response, "success": True}
+        
         return {"output": "No API keys configured. Set OPENAI_API_KEY or ANTHROPIC_API_KEY", "success": False}
 
     async def _validate_improvement(self, original: Dict, improved: Dict) -> bool: