hanzo-mcp 0.8.11__py3-none-any.whl → 0.8.14__py3-none-any.whl

hanzo_mcp/prompts/__init__.py

@@ -52,9 +52,7 @@ def create_project_system_prompt(project_path: str):
         platform, _, os_version = get_os_info()
 
         # Get directory structure
-        directory_structure = get_directory_structure(
-            working_directory, max_depth=3, include_filtered=False
-        )
+        directory_structure = get_directory_structure(working_directory, max_depth=3, include_filtered=False)
 
         # Get git information
         git_info = get_git_info(working_directory)
@@ -78,9 +76,7 @@ def create_project_system_prompt(project_path: str):
     return project_system_prompt
 
 
-def register_all_prompts(
-    mcp_server: FastMCP, projects: list[str] | None = None
-) -> None:
+def register_all_prompts(mcp_server: FastMCP, projects: list[str] | None = None) -> None:
     @mcp_server.prompt(name="Compact current conversation")
     def compact() -> str:
         """

hanzo_mcp/prompts/project_todo_reminder.py

@@ -49,13 +49,9 @@ def format_todo_list_concise(todos: list[dict[str, Any]]) -> str:
         }.get(status, "[?]")
 
         # Create priority indicator
-        priority_indicator = {"high": "🔴", "medium": "🟡", "low": "🟢"}.get(
-            priority, "⚪"
-        )
+        priority_indicator = {"high": "🔴", "medium": "🟡", "low": "🟢"}.get(priority, "⚪")
 
-        formatted_lines.append(
-            f"{status_indicator} {priority_indicator} {content} (id: {todo_id})"
-        )
+        formatted_lines.append(f"{status_indicator} {priority_indicator} {content} (id: {todo_id})")
 
     return "\n".join(formatted_lines)
 
@@ -105,6 +101,4 @@ def get_project_todo_reminder(session_id: str | None = None) -> str:
 
     # Format the todo list and return the reminder with content
     formatted_todos = format_todo_list_concise(todos)
-    return PROJECT_TODO_REMINDER.format(
-        session_id=session_id, todo_list=formatted_todos
-    )
+    return PROJECT_TODO_REMINDER.format(session_id=session_id, todo_list=formatted_todos)

hanzo_mcp/prompts/tool_explorer.py

@@ -596,9 +596,7 @@ def create_tool_category_prompt(category: str, tools: list[str]):
         "batch": BATCH_TOOL_EXAMPLES,
     }
 
-    base_prompt = tool_descriptions.get(
-        category, f"# {category.title()} Tools\n\nAvailable tools in this category:\n"
-    )
+    base_prompt = tool_descriptions.get(category, f"# {category.title()} Tools\n\nAvailable tools in this category:\n")
 
     if category not in tool_descriptions:
         base_prompt += "\n".join(f"- **{tool}**: [Tool description]" for tool in tools)

hanzo_mcp/prompts/utils.py

@@ -51,9 +51,7 @@ def get_os_info() -> tuple[str, str, str]:
     return system, release, version
 
 
-def get_directory_structure(
-    path: str, max_depth: int = 3, include_filtered: bool = False
-) -> str:
+def get_directory_structure(path: str, max_depth: int = 3, include_filtered: bool = False) -> str:
     """Get a directory structure similar to directory_tree tool.
 
     Args:
@@ -102,9 +100,7 @@ def get_directory_structure(
 
             try:
                 # Sort entries: directories first, then files alphabetically
-                entries = sorted(
-                    current_path.iterdir(), key=lambda x: (not x.is_dir(), x.name)
-                )
+                entries = sorted(current_path.iterdir(), key=lambda x: (not x.is_dir(), x.name))
 
                 for entry in entries:
                     if entry.is_dir():
@@ -147,9 +143,7 @@ def get_directory_structure(
                 # Format based on type
                 if item["type"] == "directory":
                     if "skipped" in item:
-                        lines.append(
-                            f"{indent}{item['name']}/ [skipped - {item['skipped']}]"
-                        )
+                        lines.append(f"{indent}{item['name']}/ [skipped - {item['skipped']}]")
                     else:
                         lines.append(f"{indent}{item['name']}/")
                         # Add children with increased indentation if present
@@ -228,9 +222,7 @@ def get_git_info(path: str) -> dict[str, str | None]:
                     change_type = item.change_type
                     status_lines.append(f"{change_type[0].upper()} {item.a_path}")
                 if len(staged_files) > 25:
-                    status_lines.append(
-                        f"... and {len(staged_files) - 25} more staged files"
-                    )
+                    status_lines.append(f"... and {len(staged_files) - 25} more staged files")
 
             # Check for unstaged changes
             unstaged_files = list(repo.index.diff(None))
@@ -238,9 +230,7 @@ def get_git_info(path: str) -> dict[str, str | None]:
                 for item in unstaged_files[:25]:  # Limit to first 25
                     status_lines.append(f"M {item.a_path}")
                 if len(unstaged_files) > 25:
-                    status_lines.append(
-                        f"... and {len(unstaged_files) - 25} more modified files"
-                    )
+                    status_lines.append(f"... and {len(unstaged_files) - 25} more modified files")
 
             # Check for untracked files
             untracked_files = repo.untracked_files
@@ -248,13 +238,9 @@ def get_git_info(path: str) -> dict[str, str | None]:
                 for file in untracked_files[:25]:  # Limit to first 25
                     status_lines.append(f"?? {file}")
                 if len(untracked_files) > 25:
-                    status_lines.append(
-                        f"... and {len(untracked_files) - 25} more untracked files"
-                    )
+                    status_lines.append(f"... and {len(untracked_files) - 25} more untracked files")
 
-            git_status = (
-                "\n".join(status_lines) if status_lines else "Working tree clean"
-            )
+            git_status = "\n".join(status_lines) if status_lines else "Working tree clean"
 
         except Exception:
             git_status = "Unable to get git status"

hanzo_mcp/server.py

@@ -3,15 +3,14 @@
 import os
 import atexit
 import signal
+import secrets
 import logging
 import warnings
 import threading
 from typing import Literal, cast, final
 
 # Suppress litellm deprecation warnings about event loop
-warnings.filterwarnings(
-    "ignore", message="There is no current event loop", category=DeprecationWarning
-)
+warnings.filterwarnings("ignore", message="There is no current event loop", category=DeprecationWarning)
 
 try:
     from fastmcp import FastMCP
@@ -55,6 +54,7 @@ class HanzoMCPServer:
         port: int = 8888,
         enabled_tools: dict[str, bool] | None = None,
         disabled_tools: list[str] | None = None,
+        auth_token: str | None = None,
     ):
         """Initialize the Hanzo AI server.
 
@@ -82,6 +82,15 @@ class HanzoMCPServer:
         # Use enhanced server for automatic context normalization
         self.mcp = mcp_instance if mcp_instance is not None else EnhancedFastMCP(name)
 
+        # Initialize authentication token
+        self.auth_token = auth_token or os.environ.get('HANZO_MCP_TOKEN')
+        if not self.auth_token:
+            # Generate a secure random token if none provided
+            self.auth_token = secrets.token_urlsafe(32)
+            logger = logging.getLogger(__name__)
+            logger.warning(f"No auth token provided. Generated token: {self.auth_token}")
+            logger.warning("Set HANZO_MCP_TOKEN environment variable for persistent auth")
+
         # Initialize permissions and command executor
         self.permission_manager = PermissionManager()
 
@@ -176,9 +185,7 @@ class HanzoMCPServer:
         signal.signal(signal.SIGINT, signal_handler)
 
         # Start background cleanup thread for periodic cleanup
-        self._cleanup_thread = threading.Thread(
-            target=self._background_cleanup, daemon=True
-        )
+        self._cleanup_thread = threading.Thread(target=self._background_cleanup, daemon=True)
         self._cleanup_thread.start()
 
         self._cleanup_registered = True

hanzo_mcp/tools/__init__.py

@@ -35,6 +35,7 @@ try:  # pragma: no cover
     from hanzo_mcp.tools.todo import register_todo_tools
     from hanzo_mcp.tools.agent import register_agent_tools
     from hanzo_mcp.tools.shell import register_shell_tools
+    from hanzo_mcp.tools.common import register_batch_tool, register_critic_tool, register_thinking_tool
     from hanzo_mcp.tools.editor import (
         NeovimEditTool,
         NeovimCommandTool,
@@ -48,7 +49,6 @@ try:  # pragma: no cover
     from hanzo_mcp.tools.common.mode import activate_mode_from_env
     from hanzo_mcp.tools.common.stats import StatsTool
     from hanzo_mcp.tools.common.tool_list import ToolListTool
-    from hanzo_mcp.tools.common import register_thinking_tool, register_critic_tool, register_batch_tool
     from hanzo_mcp.tools.config.mode_tool import mode_tool
     from hanzo_mcp.tools.common.mode_loader import ModeLoader
     from hanzo_mcp.tools.common.permissions import PermissionManager
@@ -68,14 +68,17 @@ except Exception:
     # Define stub functions for required imports
     def activate_mode_from_env():
         pass
+
     class ModeLoader:
         @staticmethod
         def get_enabled_tools_from_mode(base_enabled_tools=None, force_mode=None):
             return base_enabled_tools or {}
+
         @staticmethod
         def apply_environment_from_mode():
             pass
 
+
 # Try to import LSP tool
 try:
     from hanzo_mcp.tools.lsp import LSPTool, create_lsp_tool
@@ -134,9 +137,7 @@ def register_all_tools(
 
         logger = logging.getLogger(__name__)
         if plugins:
-            logger.info(
-                f"Loaded {len(plugins)} user plugin tools: {', '.join(plugins.keys())}"
-            )
+            logger.info(f"Loaded {len(plugins)} user plugin tools: {', '.join(plugins.keys())}")
     except Exception as e:
         import logging
 
@@ -149,9 +150,7 @@ def register_all_tools(
         # First check for mode activation from environment
         activate_mode_from_env()
 
-        tool_config = ModeLoader.get_enabled_tools_from_mode(
-            base_enabled_tools=enabled_tools, force_mode=force_mode
-        )
+        tool_config = ModeLoader.get_enabled_tools_from_mode(base_enabled_tools=enabled_tools, force_mode=force_mode)
         # Apply mode environment variables
         ModeLoader.apply_environment_from_mode()
     else:
@@ -196,9 +195,7 @@ def register_all_tools(
             search_paths = [str(path) for path in permission_manager.allowed_paths]
             project_manager = ProjectVectorManager(
                 global_db_path=vector_config.get("data_path"),
-                embedding_model=vector_config.get(
-                    "embedding_model", "text-embedding-3-small"
-                ),
+                embedding_model=vector_config.get("embedding_model", "text-embedding-3-small"),
                 dimension=vector_config.get("dimension", 1536),
             )
             # Auto-detect projects from search paths
@@ -225,9 +222,7 @@ def register_all_tools(
     }
 
     if any(jupyter_enabled.values()):
-        jupyter_tools = register_jupyter_tools(
-            mcp_server, permission_manager, enabled_tools=jupyter_enabled
-        )
+        jupyter_tools = register_jupyter_tools(mcp_server, permission_manager, enabled_tools=jupyter_enabled)
         for tool in jupyter_tools:
             all_tools[tool.name] = tool
 
@@ -238,11 +233,7 @@ def register_all_tools(
             all_tools[tool.name] = tool
 
     # Register agent tools if enabled
-    agent_enabled = (
-        enable_agent_tool
-        or is_tool_enabled("agent", False)
-        or is_tool_enabled("dispatch_agent", False)
-    )
+    agent_enabled = enable_agent_tool or is_tool_enabled("agent", False) or is_tool_enabled("dispatch_agent", False)
     swarm_enabled = is_tool_enabled("swarm", False)
 
     if agent_enabled or swarm_enabled:
@@ -258,12 +249,7 @@ def register_all_tools(
         )
         # Filter based on what's enabled
         for tool in agent_tools:
-            if (
-                tool.name == "agent"
-                and agent_enabled
-                or tool.name == "swarm"
-                and swarm_enabled
-            ):
+            if tool.name == "agent" and agent_enabled or tool.name == "swarm" and swarm_enabled:
                 all_tools[tool.name] = tool
             elif tool.name in ["claude", "codex", "gemini", "grok", "code_auth"]:
                 # CLI tools and auth are always included when agent tools are enabled

hanzo_mcp/tools/agent/__init__.py

@@ -108,6 +108,7 @@ def register_agent_tools(
                 if memory_backend is not None:
                     p["memory_backend"] = memory_backend
                 return await tool_self.call(ctx, **p)
+
             return tool_self
 
     # Create auth management tool
@@ -127,6 +128,6 @@ def register_agent_tools(
 
     # Register all CLI tools (includes claude, codex, gemini, grok, etc.)
     cli_tools = register_cli_tools(mcp_server, permission_manager)
-    
+
     # Return list of registered tools
     return [agent_tool, network_tool, code_auth_tool] + cli_tools

hanzo_mcp/tools/agent/agent.py

@@ -118,23 +118,17 @@ class AgentParams(TypedDict, total=False):
 class RPCAgent:
     """Long-running RPC agent."""
 
-    def __init__(
-        self, agent_id: str, model: str, system_prompt: str, tools: List[BaseTool]
-    ):
+    def __init__(self, agent_id: str, model: str, system_prompt: str, tools: List[BaseTool]):
         self.agent_id = agent_id
         self.model = model
         self.system_prompt = system_prompt
         self.tools = tools
-        self.messages: List[ChatCompletionMessageParam] = [
-            {"role": "system", "content": system_prompt}
-        ]
+        self.messages: List[ChatCompletionMessageParam] = [{"role": "system", "content": system_prompt}]
         self.created_at = time.time()
         self.last_used = time.time()
         self.call_count = 0
 
-    async def call_method(
-        self, method: str, args: Dict[str, Any], tool_ctx: ToolContext
-    ) -> str:
+    async def call_method(self, method: str, args: Dict[str, Any], tool_ctx: ToolContext) -> str:
         """Call a method on the RPC agent."""
         self.last_used = time.time()
         self.call_count += 1
@@ -189,15 +183,9 @@ class AgentTool(BaseTool):
 
         # Available tools
         self.available_tools: list[BaseTool] = []
-        self.available_tools.extend(
-            get_read_only_filesystem_tools(self.permission_manager)
-        )
-        self.available_tools.extend(
-            get_read_only_jupyter_tools(self.permission_manager)
-        )
-        self.available_tools.append(
-            BatchTool({t.name: t for t in self.available_tools})
-        )
+        self.available_tools.extend(get_read_only_filesystem_tools(self.permission_manager))
+        self.available_tools.extend(get_read_only_jupyter_tools(self.permission_manager))
+        self.available_tools.append(BatchTool({t.name: t for t in self.available_tools}))
 
     @property
     @override
@@ -272,14 +260,10 @@ Modes:
 
         if len(prompt_list) == 1:
             await tool_ctx.info("Launching agent")
-            result = await self._execute_agent(
-                prompt_list[0], params.get("model"), tool_ctx
-            )
+            result = await self._execute_agent(prompt_list[0], params.get("model"), tool_ctx)
         else:
             await tool_ctx.info(f"Launching {len(prompt_list)} agents in parallel")
-            result = await self._execute_multiple_agents(
-                prompt_list, params.get("model"), tool_ctx
-            )
+            result = await self._execute_multiple_agents(prompt_list, params.get("model"), tool_ctx)
 
         execution_time = time.time() - start_time
 
@@ -389,17 +373,13 @@ Use 'agent --action call --agent-id {agent_id} --method <method> --args <args>'
         absolute_path_pattern = r"/(?:[^/\s]+/)*[^/\s]+"
         return bool(re.search(absolute_path_pattern, prompt))
 
-    async def _execute_agent(
-        self, prompt: str, model: Optional[str], tool_ctx: ToolContext
-    ) -> str:
+    async def _execute_agent(self, prompt: str, model: Optional[str], tool_ctx: ToolContext) -> str:
         """Execute a single agent (simplified - would use full logic from agent_tool.py)."""
         # This would integrate the full agent execution logic from agent_tool.py
         # For now, return a placeholder
         return f"Executed agent with prompt: {prompt[:100]}..."
 
-    async def _execute_multiple_agents(
-        self, prompts: List[str], model: Optional[str], tool_ctx: ToolContext
-    ) -> str:
+    async def _execute_multiple_agents(self, prompts: List[str], model: Optional[str], tool_ctx: ToolContext) -> str:
         """Execute multiple agents in parallel."""
         tasks = []
         for prompt in prompts:

hanzo_mcp/tools/agent/agent_tool.py

@@ -197,9 +197,7 @@ class MCPAgent(Agent):
             adapter = MCPToolAdapter(mcp_tool, ctx)
             self.register_tool(adapter)
 
-    async def run(
-        self, state: MCPAgentState, history: History, network: Network
-    ) -> InferenceResult:
+    async def run(self, state: MCPAgentState, history: History, network: Network) -> InferenceResult:
         """Execute the agent."""
         # Get current prompt
         if state.current_prompt_index >= len(state.prompts):
@@ -324,12 +322,8 @@ Usage notes:
 
         # Set up available tools
         self.available_tools: list[BaseTool] = []
-        self.available_tools.extend(
-            get_read_only_filesystem_tools(self.permission_manager)
-        )
-        self.available_tools.extend(
-            get_read_only_jupyter_tools(self.permission_manager)
-        )
+        self.available_tools.extend(get_read_only_filesystem_tools(self.permission_manager))
+        self.available_tools.extend(get_read_only_jupyter_tools(self.permission_manager))
 
         # Add edit tools
         self.available_tools.append(Edit(self.permission_manager))
@@ -341,9 +335,7 @@ Usage notes:
         self.available_tools.append(ReviewTool())
         self.available_tools.append(IChingTool())
 
-        self.available_tools.append(
-            BatchTool({t.name: t for t in self.available_tools})
-        )
+        self.available_tools.append(BatchTool({t.name: t for t in self.available_tools}))
 
     @override
     async def call(
@@ -399,9 +391,7 @@ Usage notes:
                 times = (concurrency + len(prompt_list) - 1) // len(prompt_list)
                 prompt_list = (prompt_list * times)[:concurrency]
 
-        await tool_ctx.info(
-            f"Launching {len(prompt_list)} agent(s) using hanzo-agents SDK"
-        )
+        await tool_ctx.info(f"Launching {len(prompt_list)} agent(s) using hanzo-agents SDK")
 
         # Determine model and agent type
         model = params.get("model", self.model_override)

hanzo_mcp/tools/agent/agent_tool_v1_deprecated.py

@@ -151,12 +151,8 @@ Usage notes:
         self.max_iterations = max_iterations
         self.max_tool_uses = max_tool_uses
         self.available_tools: list[BaseTool] = []
-        self.available_tools.extend(
-            get_read_only_filesystem_tools(self.permission_manager)
-        )
-        self.available_tools.extend(
-            get_read_only_jupyter_tools(self.permission_manager)
-        )
+        self.available_tools.extend(get_read_only_filesystem_tools(self.permission_manager))
+        self.available_tools.extend(get_read_only_jupyter_tools(self.permission_manager))
 
         # Always add edit tools - agents should have edit access
         self.available_tools.append(Edit(self.permission_manager))
@@ -174,9 +170,7 @@ Usage notes:
         # Add I Ching tool for creative guidance
         self.available_tools.append(IChingTool())
 
-        self.available_tools.append(
-            BatchTool({t.name: t for t in self.available_tools})
-        )
+        self.available_tools.append(BatchTool({t.name: t for t in self.available_tools}))
 
         # Initialize protocols
         self.critic_protocol = CriticProtocol()
@@ -239,9 +233,7 @@ Example of correct usage:
         absolute_path_pattern = r"/(?:[^/\s]+/)*[^/\s]+"
         for prompt in prompt_list:
             if not re.search(absolute_path_pattern, prompt):
-                await tool_ctx.error(
-                    f"Prompt does not contain absolute path: {prompt[:50]}..."
-                )
+                await tool_ctx.error(f"Prompt does not contain absolute path: {prompt[:50]}...")
                 return """Error: All prompts must contain at least one absolute path.
 
 IMPORTANT REMINDER FOR CLAUDE:
@@ -271,9 +263,7 @@ AGENT RESPONSE:
 
 AGENT RESPONSES:
 {result}"""
-            await tool_ctx.info(
-                f"Multi-agent execution completed in {execution_time:.2f}s"
-            )
+            await tool_ctx.info(f"Multi-agent execution completed in {execution_time:.2f}s")
             return formatted_result
 
     async def _execute_agent(self, prompt: str, tool_ctx: ToolContext) -> str:
@@ -310,9 +300,7 @@ AGENT RESPONSES:
 
             # Execute agent
             await tool_ctx.info(f"Executing agent task: {prompt[:50]}...")
-            result = await self._execute_agent_with_tools(
-                system_prompt, prompt, agent_tools, openai_tools, tool_ctx
-            )
+            result = await self._execute_agent_with_tools(system_prompt, prompt, agent_tools, openai_tools, tool_ctx)
         except Exception as e:
             # Log and return error result
             error_message = f"Error executing agent: {str(e)}"
@@ -321,9 +309,7 @@ AGENT RESPONSES:
 
         return result if result else "No results returned from agent"
 
-    async def _execute_multiple_agents(
-        self, prompts: list[str], tool_ctx: ToolContext
-    ) -> str:
+    async def _execute_multiple_agents(self, prompts: list[str], tool_ctx: ToolContext) -> str:
         """Execute multiple agents concurrently.
 
         Args:
@@ -352,9 +338,7 @@ AGENT RESPONSES:
         tasks = []
         for i, prompt in enumerate(prompts):
             await tool_ctx.info(f"Creating agent task {i + 1}: {prompt[:50]}...")
-            task = self._execute_agent_with_tools(
-                system_prompt, prompt, agent_tools, openai_tools, tool_ctx
-            )
+            task = self._execute_agent_with_tools(system_prompt, prompt, agent_tools, openai_tools, tool_ctx)
             tasks.append(task)
 
         # Execute all agents concurrently
@@ -413,9 +397,7 @@ AGENT RESPONSES:
         total_tool_use_count = 0
         iteration_count = 0
         max_tool_uses = self.max_tool_uses  # Safety limit to prevent infinite loops
-        max_iterations = (
-            self.max_iterations
-        )  # Add a maximum number of iterations for safety
+        max_iterations = self.max_iterations  # Add a maximum number of iterations for safety
 
         # Execute until the agent completes or reaches the limit
         while total_tool_use_count < max_tool_uses and iteration_count < max_iterations:
@@ -480,9 +462,7 @@ AGENT RESPONSES:
                         function_args = {}
 
                     # Find the matching tool
-                    tool = next(
-                        (t for t in available_tools if t.name == function_name), None
-                    )
+                    tool = next((t for t in available_tools if t.name == function_name), None)
                     if not tool:
                         tool_result = f"Error: Tool '{function_name}' not found"
                     # Special handling for clarification requests
@@ -505,9 +485,7 @@ AGENT RESPONSES:
                                 options=options,
                             )
 
-                            tool_result = self.format_clarification_in_output(
-                                question, answer
-                            )
+                            tool_result = self.format_clarification_in_output(question, answer)
                         except Exception as e:
                             tool_result = f"Error processing clarification: {str(e)}"
                     # Special handling for critic requests
@@ -552,9 +530,7 @@ AGENT RESPONSES:
                             tool_result = f"Error processing review: {str(e)}"
                     else:
                         try:
-                            tool_result = await tool.call(
-                                ctx=tool_ctx.mcp_context, **function_args
-                            )
+                            tool_result = await tool.call(ctx=tool_ctx.mcp_context, **function_args)
                         except Exception as e:
                             tool_result = f"Error executing {function_name}: {str(e)}"
 
@@ -572,9 +548,7 @@ AGENT RESPONSES:
                     )
 
                 # Log progress
-                await tool_ctx.info(
-                    f"Processed {len(message.tool_calls)} tool calls. Total: {total_tool_use_count}"
-                )
+                await tool_ctx.info(f"Processed {len(message.tool_calls)} tool calls. Total: {total_tool_use_count}")
 
             except Exception as e:
                 await tool_ctx.error(f"Error in model call: {str(e)}")
@@ -602,8 +576,7 @@ AGENT RESPONSES:
                 )
 
                 return (
-                    final_response.choices[0].message.content
-                    or "Agent reached max iteration limit without a response."
+                    final_response.choices[0].message.content or "Agent reached max iteration limit without a response."
                 )  # pyright: ignore
             except Exception as e:
                 await tool_ctx.error(f"Error in final model call: {str(e)}")

hanzo_mcp/tools/agent/claude_desktop_auth.py

@@ -96,9 +96,7 @@ class ClaudeDesktopAuth:
         except Exception:
             return None
 
-    async def login_interactive(
-        self, account: Optional[str] = None, headless: bool = False
-    ) -> Tuple[bool, str]:
+    async def login_interactive(self, account: Optional[str] = None, headless: bool = False) -> Tuple[bool, str]:
         """Login to Claude Desktop interactively.
 
         Args:
@@ -192,9 +190,7 @@ class ClaudeDesktopAuth:
         # For now, return a placeholder
         return False, "Headless login not yet implemented"
 
-    async def _exchange_code_for_session(
-        self, code: str, account: Optional[str]
-    ) -> bool:
+    async def _exchange_code_for_session(self, code: str, account: Optional[str]) -> bool:
         """Exchange auth code for session token."""
         # This would make API calls to exchange the code
         # For now, create a mock session
@@ -357,9 +353,7 @@ class ClaudeDesktopAuth:
         # Generate agent-specific account
         return f"agent_{agent_id}@claude.local"
 
-    async def ensure_agent_auth(
-        self, agent_id: str, force_new: bool = False
-    ) -> Tuple[bool, str]:
+    async def ensure_agent_auth(self, agent_id: str, force_new: bool = False) -> Tuple[bool, str]:
         """Ensure an agent is authenticated with its own account.
 
         Args: