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

hanzo/base_agent.py

@@ -10,13 +10,12 @@ import os
 import asyncio
 import logging
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, Protocol, TypeVar, Generic
-from dataclasses import dataclass, field
-from datetime import datetime
+from typing import Any, Dict, List, Generic, TypeVar, Optional, Protocol
 from pathlib import Path
+from datetime import datetime
+from dataclasses import field, dataclass
 
-from .model_registry import registry, ModelConfig
-
+from .model_registry import ModelConfig, registry
 
 logger = logging.getLogger(__name__)
 

hanzo/batch_orchestrator.py

@@ -5,28 +5,28 @@ consensus mechanisms, and critic chains using the unified base classes.
 """
 
 import re
+import json
 import asyncio
 import logging
-from typing import Any, Dict, List, Optional, AsyncIterator, Callable
-from dataclasses import dataclass, field
-from datetime import datetime
-from pathlib import Path
-import json
 import subprocess
+from typing import Any, Dict, List, Callable, Optional, AsyncIterator
+from pathlib import Path
+from datetime import datetime
+from dataclasses import field, dataclass
 
-from rich.console import Console
-from rich.progress import Progress, TaskID, TextColumn, SpinnerColumn, BarColumn
-from rich.table import Table
 from rich.panel import Panel
+from rich.table import Table
+from rich.console import Console
+from rich.progress import TaskID, Progress, BarColumn, TextColumn, SpinnerColumn
 
 try:
     # Try to import from hanzo-mcp if available
-    from hanzo_mcp.core.model_registry import registry
     from hanzo_mcp.core.base_agent import AgentConfig, AgentResult, AgentOrchestrator
+    from hanzo_mcp.core.model_registry import registry
 except ImportError:
     # Fall back to local imports if hanzo-mcp is not installed
-    from .model_registry import registry
     from .base_agent import AgentConfig, AgentResult, AgentOrchestrator
+    from .model_registry import registry
 
 logger = logging.getLogger(__name__)
 console = Console()
@@ -906,7 +906,7 @@ class MetaAIOrchestrator:
             )
             try:
                 return json.loads(result)
-            except:
+            except Exception:
                 pass
         
         # Fallback intent detection

hanzo/cli.py

@@ -14,12 +14,13 @@ from .commands import (
     mcp,
     auth,
     chat,
+    node,
     repl,
     agent,
     miner,
     tools,
     config,
-    cluster,
+    router,
     network,
 )
 from .utils.output import console
@@ -72,7 +73,7 @@ def cli(ctx, verbose: bool, json: bool, config: Optional[str]):
 # Register command groups
 cli.add_command(agent.agent_group)
 cli.add_command(auth.auth_group)
-cli.add_command(cluster.cluster_group)
+cli.add_command(node.cluster)
 cli.add_command(mcp.mcp_group)
 cli.add_command(miner.miner_group)
 cli.add_command(chat.chat_command)
@@ -80,6 +81,7 @@ cli.add_command(repl.repl_group)
 cli.add_command(tools.tools_group)
 cli.add_command(network.network_group)
 cli.add_command(config.config_group)
+cli.add_command(router.router_group)
 
 
 # Quick aliases
@@ -95,12 +97,12 @@ def ask(ctx, prompt: tuple, model: str, local: bool):
 
 
 @cli.command()
-@click.option("--name", "-n", default="hanzo-local", help="Cluster name")
+@click.option("--name", "-n", default="hanzo-local", help="Node name")
 @click.option("--port", "-p", default=8000, help="API port")
 @click.pass_context
 def serve(ctx, name: str, port: int):
-    """Start local AI cluster (alias for 'hanzo cluster start')."""
-    asyncio.run(cluster.start_cluster(ctx, name, port))
+    """Start local AI node (alias for 'hanzo node start')."""
+    asyncio.run(node.start_node(ctx, name, port))
 
 
 @cli.command()

hanzo/commands/chat.py

@@ -88,20 +88,32 @@ async def ask_once(
 
     try:
         if local:
-            # Use local cluster
-            base_url = "http://localhost:8000"
-
-            # Check if cluster is running
-            try:
-                async with httpx.AsyncClient() as client:
-                    await client.get(f"{base_url}/health")
-            except httpx.ConnectError:
+            # Try router first, then fall back to local node
+            base_urls = [
+                "http://localhost:4000",  # Hanzo router default port
+                "http://localhost:8000",  # Local node port
+            ]
+            
+            base_url = None
+            for url in base_urls:
+                try:
+                    async with httpx.AsyncClient() as client:
+                        await client.get(f"{url}/health", timeout=1.0)
+                        base_url = url
+                        break
+                except (httpx.ConnectError, httpx.TimeoutException):
+                    continue
+            
+            if not base_url:
                 console.print(
-                    "[yellow]Local cluster not running. Start with: hanzo serve[/yellow]"
+                    "[yellow]No local AI server running.[/yellow]\n"
+                    "Start one of:\n"
+                    "  • Hanzo router: hanzo router start\n"
+                    "  • Local node: hanzo serve"
                 )
                 return
 
-            # Make request to local cluster
+            # Make request to local node
             async with httpx.AsyncClient() as client:
                 response = await client.post(
                     f"{base_url}/v1/chat/completions",
@@ -113,16 +125,31 @@ async def ask_once(
         else:
             # Use cloud API
             try:
-                from hanzoai import completion
+                # Try different import paths
+                try:
+                    from hanzoai import completion
+                except ImportError:
+                    try:
+                        from pkg.hanzoai import completion
+                    except ImportError:
+                        # Fallback to using litellm directly
+                        import litellm
+                        def completion(**kwargs):
+                            import os
+                            api_key = os.getenv("HANZO_API_KEY")
+                            if api_key:
+                                kwargs["api_key"] = api_key
+                            kwargs["api_base"] = "https://api.hanzo.ai/v1"
+                            return litellm.completion(**kwargs)
 
                 result = completion(
                     model=f"anthropic/{model}" if "claude" in model else model,
                     messages=messages,
                 )
                 content = result.choices[0].message.content
-            except ImportError:
-                console.print("[red]Error:[/red] hanzoai not installed")
-                console.print("Install with: pip install hanzo[all]")
+            except ImportError as e:
+                console.print(f"[red]Error:[/red] Missing dependencies: {e}")
+                console.print("Install with: pip install litellm")
                 return
 
         # Display response
@@ -166,7 +193,7 @@ async def interactive_chat(ctx, model: str, local: bool, system: Optional[str]):
             console.print("AI: ", end="")
             with console.status(""):
                 if local:
-                    # Use local cluster
+                    # Use local node
                     async with httpx.AsyncClient() as client:
                         response = await client.post(
                             "http://localhost:8000/v1/chat/completions",
@@ -181,7 +208,21 @@ async def interactive_chat(ctx, model: str, local: bool, system: Optional[str]):
                         content = result["choices"][0]["message"]["content"]
                 else:
                     # Use cloud API
-                    from hanzoai import completion
+                    try:
+                        from hanzoai import completion
+                    except ImportError:
+                        try:
+                            from pkg.hanzoai import completion
+                        except ImportError:
+                            # Fallback to using litellm directly
+                            import litellm
+                            def completion(**kwargs):
+                                import os
+                                api_key = os.getenv("HANZO_API_KEY")
+                                if api_key:
+                                    kwargs["api_key"] = api_key
+                                kwargs["api_base"] = "https://api.hanzo.ai/v1"
+                                return litellm.completion(**kwargs)
 
                     result = completion(
                         model=f"anthropic/{model}" if "claude" in model else model,