hanzo 0.3.30__tar.gz → 0.3.31__tar.gz

{hanzo-0.3.30 → hanzo-0.3.31}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "hanzo"
-version = "0.3.30"
+version = "0.3.31"
 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.30 → hanzo-0.3.31}/src/hanzo/interactive/enhanced_repl.py

@@ -100,6 +100,7 @@ class EnhancedHanzoREPL:
         self.tool_detector = ToolDetector(console) if ToolDetector else None
         self.detected_tools = []
         self.current_tool = None
+        self.failed_tools = set()  # Track tools that have failed this session
         
         # Initialize background task manager
         self.task_manager = BackgroundTaskManager(console) if BackgroundTaskManager else None
@@ -637,31 +638,52 @@ class EnhancedHanzoREPL:
         """Chat with AI using current model or tool."""
         # Check if using a tool
         if self.current_model.startswith("tool:") and self.current_tool:
-            # Use the detected tool directly
-            self.console.print(f"[dim]Using {self.current_tool.display_name}...[/dim]")
+            # Skip if this tool has already failed this session
+            if self.current_tool.name in self.failed_tools:
+                # Automatically use the first working tool
+                for tool in self.detected_tools:
+                    if tool.name not in self.failed_tools:
+                        self.current_tool = tool
+                        self.current_model = f"tool:{tool.name}"
+                        self.console.print(f"[yellow]Switched to {tool.display_name}[/yellow]")
+                        break
             
-            success, output = self.tool_detector.execute_with_tool(self.current_tool, message)
-            
-            if success:
-                self.console.print(output)
-            else:
-                # Show error and try fallback
-                self.console.print(f"[red]Error: {output}[/red]")
-                
-                # Try to find next available tool
-                if self.tool_detector and self.tool_detector.detected_tools:
-                    for fallback_tool in self.tool_detector.detected_tools:
-                        if fallback_tool != self.current_tool:
-                            self.console.print(f"[yellow]Trying {fallback_tool.display_name}...[/yellow]")
-                            success, output = self.tool_detector.execute_with_tool(fallback_tool, message)
-                            if success:
-                                self.console.print(output)
-                                # Suggest switching to working tool
-                                self.console.print(f"\n[dim]Tip: Switch to {fallback_tool.display_name} with /model {fallback_tool.name}[/dim]")
-                                return
-                            else:
-                                self.console.print(f"[red]{fallback_tool.display_name} also failed[/red]")
+            # Try the current tool
+            if self.current_tool.name not in self.failed_tools:
+                self.console.print(f"[dim]Using {self.current_tool.display_name}...[/dim]")
+                success, output = self.tool_detector.execute_with_tool(self.current_tool, message)
                 
+                if success:
+                    self.console.print(output)
+                    return
+                else:
+                    # Mark this tool as failed for the session
+                    self.failed_tools.add(self.current_tool.name)
+                    self.console.print(f"[red]Error: {output}[/red]")
+            
+            # Try to find next available tool
+            found_working = False
+            if self.tool_detector and self.tool_detector.detected_tools:
+                for fallback_tool in self.tool_detector.detected_tools:
+                    if fallback_tool.name not in self.failed_tools:
+                        self.console.print(f"[yellow]Trying {fallback_tool.display_name}...[/yellow]")
+                        success, output = self.tool_detector.execute_with_tool(fallback_tool, message)
+                        if success:
+                            self.console.print(output)
+                            # Automatically switch to this working tool
+                            self.current_tool = fallback_tool
+                            self.current_model = f"tool:{fallback_tool.name}"
+                            self.config["default_model"] = self.current_model
+                            self.save_config()
+                            self.console.print(f"\n[green]Switched to {fallback_tool.display_name} (now default)[/green]")
+                            found_working = True
+                            return
+                        else:
+                            # Mark as failed
+                            self.failed_tools.add(fallback_tool.name)
+                            self.console.print(f"[red]{fallback_tool.display_name} also failed[/red]")
+            
+            if not found_working:
                 # Final fallback to cloud model
                 self.console.print(f"[yellow]Falling back to cloud model...[/yellow]")
                 await self.execute_command("ask", f"--cloud --model gpt-3.5-turbo {message}")

{hanzo-0.3.30 → hanzo-0.3.31}/src/hanzo/tools/detector.py

@@ -167,51 +167,56 @@ class ToolDetector:
         """Detect if a specific tool is available."""
         # Check API endpoint first (for services like hanzod)
         if tool.api_endpoint:
-            try:
-                response = httpx.get(tool.api_endpoint, timeout=1.0)
-                if response.status_code == 200:
-                    # For Hanzo Node, verify it can actually handle chat completions
-                    if tool.name == "hanzod":
+            # For Hanzo Node, directly test the chat endpoint since health may lie
+            if tool.name == "hanzod":
+                try:
+                    # Try both ports in case configuration varies
+                    for port in [3690, 8000]:
                         try:
-                            # Check if the chat completions endpoint works
+                            # Check if the chat completions endpoint actually works
                             test_response = httpx.post(
-                                "http://localhost:3690/v1/chat/completions",
+                                f"http://localhost:{port}/v1/chat/completions",
                                 json={
                                     "messages": [{"role": "user", "content": "test"}],
-                                    "model": "test",
+                                    "model": "default",
                                     "max_tokens": 1
                                 },
-                                timeout=2.0
+                                timeout=1.0
                             )
-                            # Only mark as detected if we get a valid response or specific error
-                            # 404 means the endpoint doesn't exist
-                            if test_response.status_code == 404:
-                                return False
-                            
-                            tool.detected = True
-                            tool.version = "Running (Local AI)"
-                            
-                            # Try to get model info
-                            try:
-                                models_response = httpx.get("http://localhost:3690/v1/models", timeout=1.0)
-                                if models_response.status_code == 200:
-                                    models = models_response.json().get("data", [])
-                                    if models:
-                                        tool.version = f"Running ({len(models)} models)"
-                            except:
-                                pass
-                            
-                            return True
-                        except:
-                            # If chat endpoint doesn't work, node isn't useful
-                            return False
-                    else:
-                        # For other services, just check health endpoint
+                            # Only accept if we get a proper response (not 404, not connection error)
+                            if test_response.status_code in [200, 400, 422]:  # 400/422 means endpoint exists but params wrong
+                                tool.detected = True
+                                tool.version = f"Running (Port {port})"
+                                tool.api_endpoint = f"http://localhost:{port}/health"  # Update port
+                                
+                                # Try to get model info
+                                try:
+                                    models_response = httpx.get(f"http://localhost:{port}/v1/models", timeout=0.5)
+                                    if models_response.status_code == 200:
+                                        models = models_response.json().get("data", [])
+                                        if models:
+                                            tool.version = f"Running ({len(models)} models, Port {port})"
+                                except:
+                                    pass
+                                
+                                return True
+                        except (httpx.ConnectError, httpx.TimeoutException):
+                            # Connection refused or timeout - node not available on this port
+                            continue
+                except:
+                    pass
+                # If we get here, Hanzo Node is not properly available
+                return False
+            else:
+                # For other services, check health endpoint
+                try:
+                    response = httpx.get(tool.api_endpoint, timeout=1.0)
+                    if response.status_code == 200:
                         tool.detected = True
                         tool.version = "Running"
                         return True
-            except:
-                pass
+                except:
+                    pass
         
         # Check if command exists
         if tool.command:
@@ -342,10 +347,15 @@ class ToolDetector:
         try:
             # Special handling for Hanzo services
             if tool.name == "hanzod":
-                # Use the local API directly with correct endpoint (port 3690)
+                # Use the local API directly - extract port from the detected endpoint
                 try:
+                    # Extract port from api_endpoint (e.g., "http://localhost:3690/health")
+                    import re
+                    port_match = re.search(r':(\d+)', tool.api_endpoint)
+                    port = port_match.group(1) if port_match else "3690"
+                    
                     response = httpx.post(
-                        "http://localhost:3690/v1/chat/completions",
+                        f"http://localhost:{port}/v1/chat/completions",
                         json={
                             "messages": [{"role": "user", "content": prompt}],
                             "model": "default",  # Use default model