hanzo 0.3.23__py3-none-any.whl → 0.3.24__py3-none-any.whl

hanzo/commands/router.py

@@ -0,0 +1,152 @@
+"""Router command for starting Hanzo router proxy."""
+
+import os
+import sys
+import subprocess
+from typing import Optional
+from pathlib import Path
+
+import click
+
+from ..utils.output import console
+
+
+@click.group(name="router")
+def router_group():
+    """Manage Hanzo router (LLM proxy)."""
+    pass
+
+
+@router_group.command(name="start")
+@click.option("--port", "-p", default=4000, help="Port to run router on")
+@click.option("--config", "-c", help="Config file path")
+@click.option("--detach", "-d", is_flag=True, help="Run in background")
+@click.pass_context
+def start_router(ctx, port: int, config: Optional[str], detach: bool):
+    """Start the Hanzo router proxy server."""
+    # Find router directory
+    router_paths = [
+        Path.home() / "work" / "hanzo" / "router",
+        Path.home() / "hanzo" / "router",
+        Path.cwd().parent / "router",
+    ]
+    
+    router_dir = None
+    for path in router_paths:
+        if path.exists() and (path / "litellm" / "proxy" / "proxy_server.py").exists():
+            router_dir = path
+            break
+    
+    if not router_dir:
+        console.print("[red]Error:[/red] Hanzo router not found")
+        console.print("\nPlease clone the router:")
+        console.print("  git clone https://github.com/hanzoai/router.git ~/work/hanzo/router")
+        return
+    
+    console.print(f"[green]✓[/green] Found router at {router_dir}")
+    
+    # Prepare environment
+    env = os.environ.copy()
+    env["PYTHONPATH"] = str(router_dir) + ":" + env.get("PYTHONPATH", "")
+    
+    # Build command
+    cmd = [
+        sys.executable,
+        "-m", "litellm.proxy.proxy_server",
+        "--port", str(port),
+    ]
+    
+    if config:
+        # Use provided config
+        config_path = Path(config)
+        if not config_path.exists():
+            console.print(f"[red]Error:[/red] Config file not found: {config}")
+            return
+        cmd.extend(["--config", str(config_path)])
+    else:
+        # Check for default config
+        default_config = router_dir / "config.yaml"
+        if default_config.exists():
+            cmd.extend(["--config", str(default_config)])
+            console.print(f"[dim]Using config: {default_config}[/dim]")
+    
+    console.print(f"\n[bold cyan]Starting Hanzo Router on port {port}[/bold cyan]")
+    console.print(f"API endpoint: http://localhost:{port}/v1")
+    console.print("\nPress Ctrl+C to stop\n")
+    
+    try:
+        # Change to router directory and run
+        os.chdir(router_dir)
+        
+        if detach:
+            # Run in background
+            process = subprocess.Popen(
+                cmd,
+                env=env,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True
+            )
+            console.print(f"[green]✓[/green] Router started in background (PID: {process.pid})")
+            console.print(f"Check status: curl http://localhost:{port}/health")
+        else:
+            # Run in foreground
+            subprocess.run(cmd, env=env)
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Router stopped[/yellow]")
+    except Exception as e:
+        console.print(f"[red]Error starting router: {e}[/red]")
+
+
+@router_group.command(name="stop")
+@click.option("--port", "-p", default=4000, help="Port router is running on")
+def stop_router(port: int):
+    """Stop the router."""
+    import signal
+
+    import psutil
+    
+    found = False
+    for proc in psutil.process_iter(['pid', 'cmdline']):
+        try:
+            cmdline = proc.info['cmdline']
+            if cmdline and 'proxy_server' in ' '.join(cmdline) and str(port) in ' '.join(cmdline):
+                console.print(f"[yellow]Stopping router (PID: {proc.info['pid']})[/yellow]")
+                proc.send_signal(signal.SIGTERM)
+                proc.wait(timeout=5)
+                found = True
+                console.print("[green]✓[/green] Router stopped")
+        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.TimeoutExpired):
+            continue
+    
+    if not found:
+        console.print(f"[yellow]No router found on port {port}[/yellow]")
+
+
+@router_group.command(name="status")
+@click.option("--port", "-p", default=4000, help="Port to check")
+def router_status(port: int):
+    """Check router status."""
+    import httpx
+    
+    try:
+        response = httpx.get(f"http://localhost:{port}/health", timeout=2.0)
+        if response.status_code == 200:
+            console.print(f"[green]✓[/green] Router is running on port {port}")
+            
+            # Try to get models
+            try:
+                models_response = httpx.get(f"http://localhost:{port}/models", timeout=2.0)
+                if models_response.status_code == 200:
+                    data = models_response.json()
+                    if "data" in data:
+                        console.print(f"Available models: {len(data['data'])}")
+            except Exception:
+                pass
+        else:
+            console.print(f"[yellow]Router responding but unhealthy (status: {response.status_code})[/yellow]")
+    except httpx.ConnectError:
+        console.print(f"[red]Router not running on port {port}[/red]")
+        console.print("\nStart with: hanzo router start")
+    except Exception as e:
+        console.print(f"[red]Error checking router: {e}[/red]")

hanzo/dev.py

@@ -2359,7 +2359,7 @@ class MultiClaudeOrchestrator(HanzoDevOrchestrator):
                 claude_available = True
             elif shutil.which("claude"):
                 claude_available = True
-        except:
+        except Exception:
             pass
 
         if not claude_available:

hanzo/fallback_handler.py

@@ -44,7 +44,7 @@ class FallbackHandler:
                 if response.status_code == 200:
                     data = response.json()
                     return len(data.get("models", [])) > 0
-        except:
+        except Exception:
             pass
         return False
 

hanzo/interactive/repl.py

@@ -35,8 +35,11 @@ class HanzoREPL:
         # Don't print welcome message here since it's already printed in cli.py
 
         # Set up command completer
+        cli_commands = ["chat", "ask", "agent", "node", "mcp", "network", 
+                       "auth", "config", "tools", "miner", "serve", "net", 
+                       "dev", "router"]
         completer = WordCompleter(
-            list(self.commands.keys()) + ["chat", "agent", "cluster", "mcp", "network"],
+            list(self.commands.keys()) + cli_commands,
             ignore_case=True,
         )
 
@@ -58,8 +61,12 @@ class HanzoREPL:
                 # Execute command
                 if cmd in self.commands:
                     await self.commands[cmd](args)
-                else:
+                elif cmd in ["chat", "ask", "agent", "node", "mcp", "network", "auth", "config", "tools", "miner", "serve", "net", "dev", "router"]:
+                    # Execute known CLI commands
                     await self.execute_command(cmd, args)
+                else:
+                    # Treat as chat message if not a known command
+                    await self.chat_with_ai(command)
 
             except KeyboardInterrupt:
                 continue
@@ -83,7 +90,7 @@ class HanzoREPL:
 All Hanzo CLI commands are available:
 - `chat <message>` - Chat with AI
 - `agent start` - Start an agent
-- `cluster status` - Check cluster status
+- `node status` - Check node status
 - `mcp tools` - List MCP tools
 - `network agents` - List network agents
 
@@ -91,7 +98,7 @@ All Hanzo CLI commands are available:
 ```
 hanzo> chat How do I create a Python web server?
 hanzo> agent list
-hanzo> cluster start --models llama-3.2-3b
+hanzo> node start --models llama-3.2-3b
 hanzo> mcp run read_file --arg path=README.md
 ```
 
@@ -114,53 +121,60 @@ hanzo> mcp run read_file --arg path=README.md
     async def show_status(self, args: str = ""):
         """Show system status."""
         status = {
-            "cluster": await self.check_cluster_status(),
+            "node": await self.check_node_status(),
             "agents": await self.count_agents(),
             "auth": self.check_auth_status(),
         }
 
         self.console.print("[cyan]System Status:[/cyan]")
-        self.console.print(f"  Cluster: {status['cluster']}")
+        self.console.print(f"  Node: {status['node']}")
         self.console.print(f"  Agents: {status['agents']}")
         self.console.print(f"  Auth: {status['auth']}")
 
     async def execute_command(self, cmd: str, args: str):
         """Execute a CLI command."""
-        # Import here to avoid circular imports
+        import os
         import sys
-
-        import click
-
-        from .. import cli
-
-        # Build command line
-        argv = [cmd]
+        import shutil
+        import subprocess
+
+        # Find hanzo executable
+        hanzo_cmd = shutil.which("hanzo")
+        if not hanzo_cmd:
+            # Try using Python module directly
+            hanzo_cmd = sys.executable
+            argv = [hanzo_cmd, "-m", "hanzo", cmd]
+        else:
+            argv = [hanzo_cmd, cmd]
+        
         if args:
             import shlex
-
             argv.extend(shlex.split(args))
 
-        # Create a new context
+        # Execute as subprocess to avoid context issues
         try:
-            # Save original argv
-            orig_argv = sys.argv
-            sys.argv = ["hanzo"] + argv
-
-            # Execute command
-            ctx = click.Context(cli.cli)
-            cli.cli.invoke(ctx)
-
-        except SystemExit:
-            # Catch exit from commands
-            pass
+            result = subprocess.run(
+                argv,
+                capture_output=True,
+                text=True,
+                timeout=30,
+                env=os.environ.copy()  # Pass environment variables
+            )
+            
+            if result.stdout:
+                self.console.print(result.stdout.rstrip())
+            if result.stderr and result.returncode != 0:
+                self.console.print(f"[red]{result.stderr.rstrip()}[/red]")
+                
+        except subprocess.TimeoutExpired:
+            self.console.print("[red]Command timed out[/red]")
+        except FileNotFoundError:
+            self.console.print("[red]Command not found. Make sure 'hanzo' is installed.[/red]")
         except Exception as e:
             self.console.print(f"[red]Command error: {e}[/red]")
-        finally:
-            # Restore argv
-            sys.argv = orig_argv
 
-    async def check_cluster_status(self) -> str:
-        """Check if cluster is running."""
+    async def check_node_status(self) -> str:
+        """Check if node is running."""
         try:
             import httpx
 
@@ -185,3 +199,9 @@ hanzo> mcp run read_file --arg path=README.md
             return "authenticated (saved)"
         else:
             return "not authenticated"
+    
+    async def chat_with_ai(self, message: str):
+        """Chat with AI when user types natural language."""
+        # For natural language input, try to use it as a chat message
+        # Default to cloud mode to avoid needing local server
+        await self.execute_command("ask", f"--cloud {message}")

hanzo/mcp_server.py

@@ -6,11 +6,16 @@ import click
 
 
 def main():
-    """Start the Hanzo MCP server."""
+    """Start the Hanzo MCP server.
+
+    This wrapper defers to hanzo_mcp.cli:main so that the CLI can parse
+    transport flags and configure logging BEFORE importing any heavy modules,
+    preventing stdio protocol corruption.
+    """
     try:
-        from hanzo_mcp.server import main as mcp_main
+        from hanzo_mcp.cli import main as cli_main
 
-        mcp_main()
+        cli_main()
     except ImportError:
         click.echo(
             "Error: hanzo-mcp is not installed. Please run: pip install hanzo[mcp] or pip install hanzo[all]",

hanzo/memory_manager.py

@@ -116,7 +116,7 @@ class MemoryManager:
             try:
                 with open(self.session_file, "r") as f:
                     self.session_context = json.load(f)
-            except:
+            except Exception:
                 self.session_context = {}
         else:
             self.session_context = {

hanzo/model_registry.py

@@ -6,9 +6,9 @@ eliminating duplication and ensuring consistency across the codebase.
 
 from __future__ import annotations
 
-from dataclasses import dataclass, field
-from typing import Dict, List, Optional, Set
 from enum import Enum
+from typing import Set, Dict, List, Optional
+from dataclasses import field, dataclass
 
 
 class ModelProvider(Enum):

hanzo/rate_limiter.py

@@ -218,7 +218,7 @@ class ErrorRecovery:
                     if isinstance(e, error_type):
                         try:
                             return await handler(*args, **kwargs)
-                        except:
+                        except Exception:
                             pass  # Fallback failed, continue with retry
 
                 # Calculate backoff

hanzo/streaming.py

@@ -273,7 +273,7 @@ async def stream_with_fallback(message: str, console: Console = None) -> Optiona
     # Try Ollama streaming
     try:
         return await handler.stream_ollama(message)
-    except:
+    except Exception:
         pass
 
     # Fallback to non-streaming with simulated effect

hanzo-0.3.24.dist-info/METADATA

@@ -0,0 +1,276 @@
+Metadata-Version: 2.4
+Name: hanzo
+Version: 0.3.24
+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
+Project-URL: Documentation, https://docs.hanzo.ai/cli
+Project-URL: Bug Tracker, https://github.com/hanzoai/python-sdk/issues
+Author-email: Hanzo AI <dev@hanzo.ai>
+Keywords: agents,ai,cli,hanzo,llm,local-ai,mcp,private-ai
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: anthropic>=0.25.0
+Requires-Dist: click>=8.1.0
+Requires-Dist: httpx>=0.23.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: prompt-toolkit>=3.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Provides-Extra: agents
+Requires-Dist: hanzo-agents>=0.1.0; extra == 'agents'
+Requires-Dist: hanzo-network>=0.1.3; extra == 'agents'
+Provides-Extra: ai
+Requires-Dist: hanzoai>=1.0.0; extra == 'ai'
+Provides-Extra: all
+Requires-Dist: hanzo-aci>=0.2.8; extra == 'all'
+Requires-Dist: hanzo-agents>=0.1.0; extra == 'all'
+Requires-Dist: hanzo-mcp>=0.7.0; extra == 'all'
+Requires-Dist: hanzo-memory>=1.0.0; extra == 'all'
+Requires-Dist: hanzo-network>=0.1.3; extra == 'all'
+Requires-Dist: hanzo-repl>=0.1.0; extra == 'all'
+Requires-Dist: hanzoai>=1.0.0; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: hanzo-aci>=0.2.8; extra == 'dev'
+Provides-Extra: mcp
+Requires-Dist: hanzo-mcp>=0.7.0; extra == 'mcp'
+Provides-Extra: repl
+Requires-Dist: hanzo-repl>=0.1.0; extra == 'repl'
+Provides-Extra: router
+Description-Content-Type: text/markdown
+
+# Hanzo CLI and Orchestration Tools
+
+[![PyPI](https://img.shields.io/pypi/v/hanzo.svg)](https://pypi.org/project/hanzo/)
+[![Python Version](https://img.shields.io/pypi/pyversions/hanzo.svg)](https://pypi.org/project/hanzo/)
+
+Core CLI and orchestration tools for the Hanzo AI platform.
+
+## Installation
+
+```bash
+pip install hanzo
+```
+
+## Features
+
+- **Interactive Chat**: Chat with AI models through CLI
+- **Node Management**: Run local AI inference nodes
+- **Router Control**: Manage LLM proxy router
+- **REPL Interface**: Interactive Python REPL with AI
+- **Batch Orchestration**: Orchestrate multiple AI tasks
+- **Memory Management**: Persistent conversation memory
+
+## Usage
+
+### CLI Commands
+
+```bash
+# Interactive chat
+hanzo chat
+
+# Use specific model
+hanzo chat --model gpt-4
+
+# Use router (local proxy)
+hanzo chat --router
+
+# Use cloud API
+hanzo chat --cloud
+```
+
+### Node Management
+
+```bash
+# Start local node
+hanzo node start
+
+# Check status
+hanzo node status
+
+# List available models
+hanzo node models
+
+# Load specific model
+hanzo node load llama2:7b
+
+# Stop node
+hanzo node stop
+```
+
+### Router Management
+
+```bash
+# Start router proxy
+hanzo router start
+
+# Check router status
+hanzo router status
+
+# List available models
+hanzo router models
+
+# View configuration
+hanzo router config
+
+# Stop router
+hanzo router stop
+```
+
+### Interactive REPL
+
+```bash
+# Start REPL
+hanzo repl
+
+# In REPL:
+> /help              # Show help
+> /models            # List models
+> /model gpt-4       # Switch model
+> /clear             # Clear context
+> What is Python?    # Ask questions
+```
+
+## Python API
+
+### Batch Orchestration
+
+```python
+from hanzo.batch_orchestrator import BatchOrchestrator
+
+orchestrator = BatchOrchestrator()
+results = await orchestrator.run_batch([
+    "Summarize quantum computing",
+    "Explain machine learning",
+    "Define artificial intelligence"
+])
+```
+
+### Memory Management
+
+```python
+from hanzo.memory_manager import MemoryManager
+
+memory = MemoryManager()
+memory.add_to_context("user", "What is Python?")
+memory.add_to_context("assistant", "Python is...")
+context = memory.get_context()
+```
+
+### Fallback Handling
+
+```python
+from hanzo.fallback_handler import FallbackHandler
+
+handler = FallbackHandler()
+result = await handler.handle_with_fallback(
+    primary_fn=api_call,
+    fallback_fn=local_inference
+)
+```
+
+## Configuration
+
+### Environment Variables
+
+```bash
+# API settings
+HANZO_API_KEY=your-api-key
+HANZO_BASE_URL=https://api.hanzo.ai
+
+# Router settings
+HANZO_ROUTER_URL=http://localhost:4000/v1
+
+# Node settings
+HANZO_NODE_URL=http://localhost:8000/v1
+HANZO_NODE_WORKERS=4
+
+# Model preferences
+HANZO_DEFAULT_MODEL=gpt-4
+HANZO_FALLBACK_MODEL=llama2:7b
+```
+
+### Configuration File
+
+Create `~/.hanzo/config.yaml`:
+
+```yaml
+api:
+  key: your-api-key
+  base_url: https://api.hanzo.ai
+
+router:
+  url: http://localhost:4000/v1
+  auto_start: true
+
+node:
+  url: http://localhost:8000/v1
+  workers: 4
+  models:
+    - llama2:7b
+    - mistral:7b
+
+models:
+  default: gpt-4
+  fallback: llama2:7b
+```
+
+## Architecture
+
+### Components
+
+- **CLI**: Command-line interface (`cli.py`)
+- **Chat**: Interactive chat interface (`commands/chat.py`)
+- **Node**: Local AI node management (`commands/node.py`)
+- **Router**: LLM proxy management (`commands/router.py`)
+- **REPL**: Interactive Python REPL (`interactive/repl.py`)
+- **Orchestrator**: Batch task orchestration (`batch_orchestrator.py`)
+- **Memory**: Conversation memory (`memory_manager.py`)
+- **Fallback**: Resilient API handling (`fallback_handler.py`)
+
+### Port Allocation
+
+- **4000**: Router (LLM proxy)
+- **8000**: Node (local AI)
+- **9550-9553**: Desktop app integration
+
+## Development
+
+### Setup
+
+```bash
+cd pkg/hanzo
+uv sync --all-extras
+```
+
+### Testing
+
+```bash
+# Run tests
+pytest tests/
+
+# With coverage
+pytest tests/ --cov=hanzo
+```
+
+### Building
+
+```bash
+uv build
+```
+
+## License
+
+Apache License 2.0