hanzo-mcp 0.8.8__py3-none-any.whl → 0.9.0__py3-none-any.whl

hanzo_mcp/tools/jupyter/base.py

@@ -127,9 +127,7 @@ class JupyterBaseTool(FilesystemBaseTool, ABC):
         """
         tool_ctx.set_tool_info(self.name)
 
-    async def parse_notebook(
-        self, file_path: Path
-    ) -> tuple[dict[str, Any], list[NotebookCellSource]]:
+    async def parse_notebook(self, file_path: Path) -> tuple[dict[str, Any], list[NotebookCellSource]]:
         """Parse a Jupyter notebook file.
 
         Args:
@@ -143,9 +141,7 @@ class JupyterBaseTool(FilesystemBaseTool, ABC):
             notebook = json.loads(content)
 
         # Get notebook language
-        language = (
-            notebook.get("metadata", {}).get("language_info", {}).get("name", "python")
-        )
+        language = notebook.get("metadata", {}).get("language_info", {}).get("name", "python")
         cells = notebook.get("cells", [])
         processed_cells = []
 
@@ -177,9 +173,7 @@ class JupyterBaseTool(FilesystemBaseTool, ABC):
                         text = output.get("text", "")
                         if isinstance(text, list):
                             text = "".join(text)
-                        outputs.append(
-                            NotebookCellOutput(output_type="stream", text=text)
-                        )
+                        outputs.append(NotebookCellOutput(output_type="stream", text=text))
 
                     elif output_type in ["execute_result", "display_data"]:
                         # Process text output
@@ -205,11 +199,7 @@ class JupyterBaseTool(FilesystemBaseTool, ABC):
                                     media_type="image/jpeg",
                                 )
 
-                        outputs.append(
-                            NotebookCellOutput(
-                                output_type=output_type, text=text, image=image
-                            )
-                        )
+                        outputs.append(NotebookCellOutput(output_type=output_type, text=text, image=image))
 
                     elif output_type == "error":
                         # Format error traceback
@@ -220,17 +210,13 @@ class JupyterBaseTool(FilesystemBaseTool, ABC):
                         # Handle raw text strings and lists of strings
                         if isinstance(traceback, list):
                             # Clean ANSI escape codes and join the list but preserve the formatting
-                            clean_traceback = [
-                                clean_ansi_escapes(line) for line in traceback
-                            ]
+                            clean_traceback = [clean_ansi_escapes(line) for line in traceback]
                             traceback_text = "\n".join(clean_traceback)
                         else:
                             traceback_text = clean_ansi_escapes(str(traceback))
 
                         error_text = f"{ename}: {evalue}\n{traceback_text}"
-                        outputs.append(
-                            NotebookCellOutput(output_type="error", text=error_text)
-                        )
+                        outputs.append(NotebookCellOutput(output_type="error", text=error_text))
 
             # Create cell object
             processed_cell = NotebookCellSource(

hanzo_mcp/tools/jupyter/jupyter.py

@@ -151,9 +151,7 @@ jupyter --action create "new.ipynb"
         else:
             return f"Error: Unknown action '{action}'. Valid actions: read, edit, create, delete, execute"
 
-    async def _handle_read(
-        self, notebook_path: str, params: Dict[str, Any], tool_ctx
-    ) -> str:
+    async def _handle_read(self, notebook_path: str, params: Dict[str, Any], tool_ctx) -> str:
         """Read notebook or specific cell."""
         exists, error_msg = await self.check_path_exists(notebook_path, tool_ctx)
         if not exists:
@@ -188,9 +186,7 @@ jupyter --action create "new.ipynb"
             await tool_ctx.error(f"Failed to read notebook: {str(e)}")
             return f"Error reading notebook: {str(e)}"
 
-    async def _handle_edit(
-        self, notebook_path: str, params: Dict[str, Any], tool_ctx
-    ) -> str:
+    async def _handle_edit(self, notebook_path: str, params: Dict[str, Any], tool_ctx) -> str:
         """Edit notebook cell."""
         exists, error_msg = await self.check_path_exists(notebook_path, tool_ctx)
         if not exists:
@@ -295,9 +291,7 @@ jupyter --action create "new.ipynb"
             await tool_ctx.error(f"Failed to create notebook: {str(e)}")
             return f"Error creating notebook: {str(e)}"
 
-    async def _handle_delete(
-        self, notebook_path: str, params: Dict[str, Any], tool_ctx
-    ) -> str:
+    async def _handle_delete(self, notebook_path: str, params: Dict[str, Any], tool_ctx) -> str:
         """Delete notebook or cell."""
         # If cell specified, delegate to edit with delete mode
         if params.get("cell_id") or params.get("cell_index") is not None:
@@ -316,9 +310,7 @@ jupyter --action create "new.ipynb"
             await tool_ctx.error(f"Failed to delete notebook: {str(e)}")
             return f"Error deleting notebook: {str(e)}"
 
-    async def _handle_execute(
-        self, notebook_path: str, params: Dict[str, Any], tool_ctx
-    ) -> str:
+    async def _handle_execute(self, notebook_path: str, params: Dict[str, Any], tool_ctx) -> str:
         """Execute notebook cells (placeholder for future implementation)."""
         return "Error: Cell execution not yet implemented. Use a Jupyter kernel or server for execution."
 

hanzo_mcp/tools/llm/consensus_tool.py

@@ -211,22 +211,14 @@ The tool will:
         )
 
         # Prepare summary of results
-        successful_responses = [
-            (m, r) for m, r in results.items() if not r.startswith("Error:")
-        ]
-        failed_responses = [
-            (m, r) for m, r in results.items() if r.startswith("Error:")
-        ]
+        successful_responses = [(m, r) for m, r in results.items() if not r.startswith("Error:")]
+        failed_responses = [(m, r) for m, r in results.items() if r.startswith("Error:")]
 
         if not successful_responses:
-            return "Error: All model queries failed:\n\n" + "\n".join(
-                [f"{m}: {r}" for m, r in failed_responses]
-            )
+            return "Error: All model queries failed:\n\n" + "\n".join([f"{m}: {r}" for m, r in failed_responses])
 
         # Use aggregation model to synthesize responses
-        consensus = await self._aggregate_responses(
-            successful_responses, prompt, aggregation_model
-        )
+        consensus = await self._aggregate_responses(successful_responses, prompt, aggregation_model)
 
         # Format output
         output = ["=== LLM Consensus Analysis ==="]
@@ -245,9 +237,7 @@ The tool will:
             output.append("\n=== Individual Responses ===")
             for model, response in successful_responses:
                 output.append(f"\n--- {model} ---")
-                output.append(
-                    response[:500] + "..." if len(response) > 500 else response
-                )
+                output.append(response[:500] + "..." if len(response) > 500 else response)
 
         if failed_responses:
             output.append("\n=== Failed Queries ===")
@@ -282,9 +272,7 @@ The tool will:
                 # Create a mock context for the LLM tool
                 mock_ctx = type("MockContext", (), {"client": None})()
 
-                result = await asyncio.wait_for(
-                    self.llm_tool.call(mock_ctx, **params), timeout=timeout
-                )
+                result = await asyncio.wait_for(self.llm_tool.call(mock_ctx, **params), timeout=timeout)
                 return (model, result)
             except asyncio.TimeoutError:
                 return (model, f"Error: Timeout after {timeout} seconds")
@@ -305,9 +293,7 @@ The tool will:
     ) -> str:
         """Use an LLM to aggregate and analyze responses."""
         # Prepare the aggregation prompt
-        response_summary = "\n\n".join(
-            [f"Model: {model}\nResponse: {response}" for model, response in responses]
-        )
+        response_summary = "\n\n".join([f"Model: {model}\nResponse: {response}" for model, response in responses])
 
         aggregation_prompt = f"""You are analyzing responses from multiple AI models to the following prompt:
 
@@ -360,9 +346,7 @@ Be concise but thorough. Focus on providing actionable insights."""
         for model, response in responses:
             output.append(f"- {model}: {len(response)} characters")
 
-        output.append(
-            "\nNote: Advanced consensus analysis unavailable. Showing basic summary only."
-        )
+        output.append("\nNote: Advanced consensus analysis unavailable. Showing basic summary only.")
 
         return "\n".join(output)
 

hanzo_mcp/tools/llm/llm_manage.py

@@ -192,9 +192,7 @@ Providers are automatically detected based on environment variables:
             for provider in available_but_disabled:
                 env_vars = available_providers.get(provider, [])
                 output.append(f"  - {provider}: {', '.join(env_vars)}")
-                output.append(
-                    f"    Use: llm_manage --action enable --provider {provider}"
-                )
+                output.append(f"    Use: llm_manage --action enable --provider {provider}")
             output.append("")
 
         # Show providers without API keys
@@ -356,9 +354,7 @@ Providers are automatically detected based on environment variables:
         except Exception as e:
             return f"Error listing models: {str(e)}"
 
-    async def _test_model(
-        self, ctx: MCPContext, provider: Optional[str], model: Optional[str]
-    ) -> str:
+    async def _test_model(self, ctx: MCPContext, provider: Optional[str], model: Optional[str]) -> str:
         """Test a model to verify it works."""
         if not model and not provider:
             return "Error: Either model or provider is required for test action"

hanzo_mcp/tools/llm/llm_tool.py

@@ -294,9 +294,7 @@ Available: {", ".join(available) if available else "None"}"""
             # Other actions can fall through to regular path if available
 
         if not LITELLM_AVAILABLE:
-            return (
-                "Error: LiteLLM is not installed. Install it with: pip install litellm"
-            )
+            return "Error: LiteLLM is not installed. Install it with: pip install litellm"
 
         # Extract action
         action = params.get("action", "query")
@@ -315,9 +313,7 @@ Available: {", ".join(available) if available else "None"}"""
         elif action == "disable":
             return self._handle_disable(params.get("provider"))
         elif action == "test":
-            return await self._handle_test(
-                tool_ctx, params.get("model"), params.get("provider")
-            )
+            return await self._handle_test(tool_ctx, params.get("model"), params.get("provider"))
         else:
             return f"Error: Unknown action '{action}'. Valid actions: query, consensus, list, models, enable, disable, test"
 
@@ -407,9 +403,7 @@ Available: {", ".join(available) if available else "None"}"""
         models = params.get("models")
         if not models:
             # Use configured or default models
-            consensus_size = params.get("consensus_size") or self.config.get(
-                "consensus_size", 3
-            )
+            consensus_size = params.get("consensus_size") or self.config.get("consensus_size", 3)
             models = self._get_consensus_models(consensus_size)
 
         if not models:
@@ -449,11 +443,7 @@ Available: {", ".join(available) if available else "None"}"""
         if devil_model:
             # Create devil's advocate prompt
             responses_text = "\n\n".join(
-                [
-                    f"Model {i + 1}: {resp['response']}"
-                    for i, resp in enumerate(responses)
-                    if resp["response"]
-                ]
+                [f"Model {i + 1}: {resp['response']}" for i, resp in enumerate(responses) if resp["response"]]
             )
 
             devil_prompt = f"""You are a critical analyst. Review these responses to the question below and provide a devil's advocate perspective. Challenge assumptions, point out weaknesses, and suggest alternative viewpoints.
@@ -477,14 +467,10 @@ Provide your critical analysis:"""
                 }
 
         # Aggregate responses
-        judge_model = params.get("judge_model") or self.config.get(
-            "default_judge_model", "gpt-4o"
-        )
+        judge_model = params.get("judge_model") or self.config.get("default_judge_model", "gpt-4o")
         include_raw = params.get("include_raw", False)
 
-        return await self._aggregate_consensus(
-            responses, prompt, judge_model, include_raw, devil_response, tool_ctx
-        )
+        return await self._aggregate_consensus(responses, prompt, judge_model, include_raw, devil_response, tool_ctx)
 
     def _handle_list(self) -> str:
         """List available providers."""
@@ -518,9 +504,7 @@ Provide your critical analysis:"""
             output.append(f"{provider}: {status}")
             output.append(f"  Environment variables: {', '.join(env_vars)}")
 
-        output.append(
-            "\nUse 'llm --action enable/disable --provider <name>' to manage providers"
-        )
+        output.append("\nUse 'llm --action enable/disable --provider <name>' to manage providers")
 
         return "\n".join(output)
 
@@ -560,16 +544,10 @@ Provide your critical analysis:"""
                 # Show providers with counts
                 for provider_name, models in sorted(all_models.items()):
                     if models:
-                        available = (
-                            "✅" if provider_name in self.available_providers else "❌"
-                        )
-                        output.append(
-                            f"{available} {provider_name}: {len(models)} models"
-                        )
+                        available = "✅" if provider_name in self.available_providers else "❌"
+                        output.append(f"{available} {provider_name}: {len(models)} models")
 
-                output.append(
-                    "\nUse 'llm --action models --provider <name>' to see specific models"
-                )
+                output.append("\nUse 'llm --action models --provider <name>' to see specific models")
 
             return "\n".join(output)
 
@@ -608,9 +586,7 @@ Provide your critical analysis:"""
         else:
             return f"{provider} is already disabled"
 
-    async def _handle_test(
-        self, tool_ctx, model: Optional[str], provider: Optional[str]
-    ) -> str:
+    async def _handle_test(self, tool_ctx, model: Optional[str], provider: Optional[str]) -> str:
         """Test a model or provider."""
         if not model and not provider:
             return "Error: Either model or provider is required for test action"
@@ -666,11 +642,7 @@ Provide your critical analysis:"""
                 break
 
             provider = self._get_provider_for_model(model)
-            if (
-                provider
-                and provider in self.available_providers
-                and provider not in disabled
-            ):
+            if provider and provider in self.available_providers and provider not in disabled:
                 models.append(model)
 
         # If still need more, add from available providers
@@ -703,9 +675,7 @@ Provide your critical analysis:"""
         """Query multiple models in parallel."""
 
         async def query_with_info(model: str) -> Dict[str, Any]:
-            result = await self._query_single_model(
-                model, prompt, system_prompt, temperature, max_tokens
-            )
+            result = await self._query_single_model(model, prompt, system_prompt, temperature, max_tokens)
             return {
                 "model": model,
                 "response": result.get("response"),
@@ -784,12 +754,7 @@ Provide your critical analysis:"""
             return "Error: All models failed to respond"
 
         # Format responses for aggregation
-        responses_text = "\n\n".join(
-            [
-                f"Model: {r['model']}\nResponse: {r['response']}"
-                for r in successful_responses
-            ]
-        )
+        responses_text = "\n\n".join([f"Model: {r['model']}\nResponse: {r['response']}" for r in successful_responses])
 
         if devil_response:
             responses_text += f"\n\nDevil's Advocate ({devil_response['model']}):\n{devil_response['response']}"
@@ -818,23 +783,17 @@ Be concise and highlight the most important findings."""
             if tool_ctx:
                 await tool_ctx.info(f"Aggregating responses with {judge_model}...")
 
-            judge_result = await self._query_single_model(
-                judge_model, aggregation_prompt, None, 0.3, None
-            )
+            judge_result = await self._query_single_model(judge_model, aggregation_prompt, None, 0.3, None)
 
             if not judge_result["success"]:
                 return f"Error: Judge model failed: {judge_result.get('error', 'Unknown error')}"
 
             # Format output
-            output = [
-                f"=== Consensus Analysis ({len(successful_responses)} models) ===\n"
-            ]
+            output = [f"=== Consensus Analysis ({len(successful_responses)} models) ===\n"]
             output.append(judge_result["response"])
 
             # Add model list
-            output.append(
-                f"\nModels consulted: {', '.join([r['model'] for r in successful_responses])}"
-            )
+            output.append(f"\nModels consulted: {', '.join([r['model'] for r in successful_responses])}")
             if devil_response:
                 output.append(f"Devil's Advocate: {devil_response['model']}")
 

hanzo_mcp/tools/llm/llm_unified.py

@@ -260,7 +260,7 @@ llm "Explain this code" --model gpt-4o
 llm --action consensus "Is this approach correct?" --devils-advocate
 llm --action models --provider openai
 
-Available: {', '.join(available) if available else 'None'}"""
+Available: {", ".join(available) if available else "None"}"""
 
     @override
     async def call(
@@ -281,9 +281,7 @@ Available: {', '.join(available) if available else 'None'}"""
             pass
 
         if not LITELLM_AVAILABLE:
-            return (
-                "Error: LiteLLM is not installed. Install it with: pip install litellm"
-            )
+            return "Error: LiteLLM is not installed. Install it with: pip install litellm"
 
         # Extract action
         action = params.get("action", "query")
@@ -302,9 +300,7 @@ Available: {', '.join(available) if available else 'None'}"""
         elif action == "disable":
             return self._handle_disable(params.get("provider"))
         elif action == "test":
-            return await self._handle_test(
-                tool_ctx, params.get("model"), params.get("provider")
-            )
+            return await self._handle_test(tool_ctx, params.get("model"), params.get("provider"))
         else:
             return f"Error: Unknown action '{action}'. Valid actions: query, consensus, list, models, enable, disable, test"
 
@@ -394,9 +390,7 @@ Available: {', '.join(available) if available else 'None'}"""
         models = params.get("models")
         if not models:
             # Use configured or default models
-            consensus_size = params.get("consensus_size") or self.config.get(
-                "consensus_size", 3
-            )
+            consensus_size = params.get("consensus_size") or self.config.get("consensus_size", 3)
             models = self._get_consensus_models(consensus_size)
 
         if not models:
@@ -436,11 +430,7 @@ Available: {', '.join(available) if available else 'None'}"""
         if devil_model:
             # Create devil's advocate prompt
             responses_text = "\n\n".join(
-                [
-                    f"Model {i+1}: {resp['response']}"
-                    for i, resp in enumerate(responses)
-                    if resp["response"]
-                ]
+                [f"Model {i + 1}: {resp['response']}" for i, resp in enumerate(responses) if resp["response"]]
             )
 
             devil_prompt = f"""You are a critical analyst. Review these responses to the question below and provide a devil's advocate perspective. Challenge assumptions, point out weaknesses, and suggest alternative viewpoints.
@@ -464,14 +454,10 @@ Provide your critical analysis:"""
                 }
 
         # Aggregate responses
-        judge_model = params.get("judge_model") or self.config.get(
-            "default_judge_model", "gpt-4o"
-        )
+        judge_model = params.get("judge_model") or self.config.get("default_judge_model", "gpt-4o")
         include_raw = params.get("include_raw", False)
 
-        return await self._aggregate_consensus(
-            responses, prompt, judge_model, include_raw, devil_response, tool_ctx
-        )
+        return await self._aggregate_consensus(responses, prompt, judge_model, include_raw, devil_response, tool_ctx)
 
     def _handle_list(self) -> str:
         """List available providers."""
@@ -505,9 +491,7 @@ Provide your critical analysis:"""
             output.append(f"{provider}: {status}")
             output.append(f"  Environment variables: {', '.join(env_vars)}")
 
-        output.append(
-            "\nUse 'llm --action enable/disable --provider <name>' to manage providers"
-        )
+        output.append("\nUse 'llm --action enable/disable --provider <name>' to manage providers")
 
         return "\n".join(output)
 
@@ -547,16 +531,10 @@ Provide your critical analysis:"""
                 # Show providers with counts
                 for provider_name, models in sorted(all_models.items()):
                     if models:
-                        available = (
-                            "✅" if provider_name in self.available_providers else "❌"
-                        )
-                        output.append(
-                            f"{available} {provider_name}: {len(models)} models"
-                        )
+                        available = "✅" if provider_name in self.available_providers else "❌"
+                        output.append(f"{available} {provider_name}: {len(models)} models")
 
-                output.append(
-                    "\nUse 'llm --action models --provider <name>' to see specific models"
-                )
+                output.append("\nUse 'llm --action models --provider <name>' to see specific models")
 
             return "\n".join(output)
 
@@ -595,9 +573,7 @@ Provide your critical analysis:"""
         else:
             return f"{provider} is already disabled"
 
-    async def _handle_test(
-        self, tool_ctx, model: Optional[str], provider: Optional[str]
-    ) -> str:
+    async def _handle_test(self, tool_ctx, model: Optional[str], provider: Optional[str]) -> str:
         """Test a model or provider."""
         if not model and not provider:
             return "Error: Either model or provider is required for test action"
@@ -653,11 +629,7 @@ Provide your critical analysis:"""
                 break
 
             provider = self._get_provider_for_model(model)
-            if (
-                provider
-                and provider in self.available_providers
-                and provider not in disabled
-            ):
+            if provider and provider in self.available_providers and provider not in disabled:
                 models.append(model)
 
         # If still need more, add from available providers
@@ -690,9 +662,7 @@ Provide your critical analysis:"""
         """Query multiple models in parallel."""
 
         async def query_with_info(model: str) -> Dict[str, Any]:
-            result = await self._query_single_model(
-                model, prompt, system_prompt, temperature, max_tokens
-            )
+            result = await self._query_single_model(model, prompt, system_prompt, temperature, max_tokens)
             return {
                 "model": model,
                 "response": result.get("response"),
@@ -771,12 +741,7 @@ Provide your critical analysis:"""
             return "Error: All models failed to respond"
 
         # Format responses for aggregation
-        responses_text = "\n\n".join(
-            [
-                f"Model: {r['model']}\nResponse: {r['response']}"
-                for r in successful_responses
-            ]
-        )
+        responses_text = "\n\n".join([f"Model: {r['model']}\nResponse: {r['response']}" for r in successful_responses])
 
         if devil_response:
             responses_text += f"\n\nDevil's Advocate ({devil_response['model']}):\n{devil_response['response']}"
@@ -805,23 +770,17 @@ Be concise and highlight the most important findings."""
             if tool_ctx:
                 await tool_ctx.info(f"Aggregating responses with {judge_model}...")
 
-            judge_result = await self._query_single_model(
-                judge_model, aggregation_prompt, None, 0.3, None
-            )
+            judge_result = await self._query_single_model(judge_model, aggregation_prompt, None, 0.3, None)
 
             if not judge_result["success"]:
                 return f"Error: Judge model failed: {judge_result.get('error', 'Unknown error')}"
 
             # Format output
-            output = [
-                f"=== Consensus Analysis ({len(successful_responses)} models) ===\n"
-            ]
+            output = [f"=== Consensus Analysis ({len(successful_responses)} models) ===\n"]
             output.append(judge_result["response"])
 
             # Add model list
-            output.append(
-                f"\nModels consulted: {', '.join([r['model'] for r in successful_responses])}"
-            )
+            output.append(f"\nModels consulted: {', '.join([r['model'] for r in successful_responses])}")
             if devil_response:
                 output.append(f"Devil's Advocate: {devil_response['model']}")
 

hanzo_mcp/tools/llm/provider_tools.py

@@ -71,9 +71,7 @@ class ProviderToolParams(TypedDict, total=False):
 class BaseProviderTool(BaseTool):
     """Base class for provider-specific LLM tools."""
 
-    def __init__(
-        self, provider: str, default_model: str, model_variants: Dict[str, str]
-    ):
+    def __init__(self, provider: str, default_model: str, model_variants: Dict[str, str]):
         """Initialize provider tool.
 
         Args: