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

hanzo_mcp/tools/memory/knowledge_tools.py

@@ -140,15 +140,9 @@ recall_facts(queries=["company policies"], scope="global", limit=5)
             if fact.metadata and fact.metadata.get("kb_name"):
                 kb_info = f" (KB: {fact.metadata['kb_name']})"
             formatted.append(f"{i}. {fact.content}{kb_info}")
-            if (
-                fact.metadata and len(fact.metadata) > 2
-            ):  # More than just type and kb_name
+            if fact.metadata and len(fact.metadata) > 2:  # More than just type and kb_name
                 # Show other metadata
-                other_meta = {
-                    k: v
-                    for k, v in fact.metadata.items()
-                    if k not in ["type", "kb_name"]
-                }
+                other_meta = {k: v for k, v in fact.metadata.items() if k not in ["type", "kb_name"]}
                 if other_meta:
                     formatted.append(f"   Metadata: {other_meta}")
 
@@ -167,9 +161,7 @@ recall_facts(queries=["company policies"], scope="global", limit=5)
             scope: str = "project",
             limit: int = 10,
         ) -> str:
-            return await tool_self.call(
-                ctx, queries=queries, kb_name=kb_name, scope=scope, limit=limit
-            )
+            return await tool_self.call(ctx, queries=queries, kb_name=kb_name, scope=scope, limit=limit)
 
 
 @final
@@ -265,9 +257,7 @@ store_facts(facts=["Company founded in 2020"], scope="global", kb_name="company_
             scope: str = "project",
             metadata: Optional[Dict[str, Any]] = None,
         ) -> str:
-            return await tool_self.call(
-                ctx, facts=facts, kb_name=kb_name, scope=scope, metadata=metadata
-            )
+            return await tool_self.call(ctx, facts=facts, kb_name=kb_name, scope=scope, metadata=metadata)
 
 
 @final
@@ -323,11 +313,7 @@ summarize_to_memory(content="Company guidelines...", topic="Guidelines", scope="
 
         # Use the memory service to create a summary
         # This would typically use an LLM to summarize, but for now we'll store as-is
-        summary = (
-            f"Summary of {topic}:\n{content[:500]}..."
-            if len(content) > 500
-            else content
-        )
+        summary = f"Summary of {topic}:\n{content[:500]}..." if len(content) > 500 else content
 
         # Store the summary as a memory
         from hanzo_memory.services.memory import get_memory_service
@@ -358,9 +344,7 @@ summarize_to_memory(content="Company guidelines...", topic="Guidelines", scope="
         if auto_facts:
             # In a real implementation, this would use LLM to extract key facts
             # For now, we'll just note it
-            result += (
-                "\n(Auto-fact extraction would extract key facts from the summary)"
-            )
+            result += "\n(Auto-fact extraction would extract key facts from the summary)"
 
         return result
 
@@ -377,9 +361,7 @@ summarize_to_memory(content="Company guidelines...", topic="Guidelines", scope="
             scope: str = "project",
             auto_facts: bool = True,
         ) -> str:
-            return await tool_self.call(
-                ctx, content=content, topic=topic, scope=scope, auto_facts=auto_facts
-            )
+            return await tool_self.call(ctx, content=content, topic=topic, scope=scope, auto_facts=auto_facts)
 
 
 @final

hanzo_mcp/tools/memory/memory_tools.py

@@ -21,7 +21,7 @@ try:
 except ImportError:
     MEMORY_AVAILABLE = False
     raise ImportError(
-        "hanzo-memory package is required for memory tools. Install it from ~/work/hanzo/ide/pkg/memory"
+        "hanzo-memory package is required for memory tools. Install it from ~/work/hanzo/python-sdk/pkg/hanzo-memory"
     )
 
 
@@ -127,9 +127,7 @@ recall_memories(queries=["coding standards"], scope="global")
         tool_self = self
 
         @mcp_server.tool(name=self.name, description=self.description)
-        async def recall_memories(
-            ctx: MCPContext, queries: List[str], limit: int = 10, scope: str = "project"
-        ) -> str:
+        async def recall_memories(ctx: MCPContext, queries: List[str], limit: int = 10, scope: str = "project") -> str:
             return await tool_self.call(ctx, queries=queries, limit=limit, scope=scope)
 
 
@@ -247,9 +245,7 @@ update_memories(updates=[
                 # The hanzo-memory service doesn't have update implemented yet
                 # When it's implemented, we would call:
                 # success = self.service.update_memory(self.user_id, memory_id, content=statement)
-                await tool_ctx.warning(
-                    f"Memory update not fully implemented in hanzo-memory yet: {memory_id}"
-                )
+                await tool_ctx.warning(f"Memory update not fully implemented in hanzo-memory yet: {memory_id}")
                 success_count += 1
 
         return f"Would update {success_count} of {len(updates)} memories (update not fully implemented in hanzo-memory yet)."
@@ -260,9 +256,7 @@ update_memories(updates=[
         tool_self = self
 
         @mcp_server.tool(name=self.name, description=self.description)
-        async def update_memories(
-            ctx: MCPContext, updates: List[Dict[str, str]]
-        ) -> str:
+        async def update_memories(ctx: MCPContext, updates: List[Dict[str, str]]) -> str:
             return await tool_self.call(ctx, updates=updates)
 
 
@@ -398,13 +392,9 @@ manage_memories(
 
                 if memory_id and statement:
                     # Update not fully implemented in hanzo-memory yet
-                    await tool_ctx.warning(
-                        f"Memory update not fully implemented: {memory_id}"
-                    )
+                    await tool_ctx.warning(f"Memory update not fully implemented: {memory_id}")
                     success_count += 1
-            results.append(
-                f"Would update {success_count} memories (update pending implementation)"
-            )
+            results.append(f"Would update {success_count} memories (update pending implementation)")
 
         # Delete memories
         if deletions:
@@ -433,6 +423,4 @@ manage_memories(
             updates: Optional[List[Dict[str, str]]] = None,
             deletions: Optional[List[str]] = None,
         ) -> str:
-            return await tool_self.call(
-                ctx, creations=creations, updates=updates, deletions=deletions
-            )
+            return await tool_self.call(ctx, creations=creations, updates=updates, deletions=deletions)

hanzo_mcp/tools/search/find_tool.py

@@ -75,8 +75,8 @@ class FindTool(BaseTool):
     reading or searching within files.
     """
 
-    def __init__(self):
-        super().__init__()
+    def __init__(self, permission_manager=None):
+        super().__init__(permission_manager=permission_manager)
         self._cache = {}
         self._gitignore_cache = {}
 
@@ -257,9 +257,7 @@ class FindTool(BaseTool):
         # Resolve path
         root_path = Path(path).resolve()
         if not root_path.exists():
-            return MCPResourceDocument(
-                data={"error": f"Path does not exist: {path}", "results": []}
-            )
+            return MCPResourceDocument(data={"error": f"Path does not exist: {path}", "results": []})
 
         # Get ignore patterns
         ignore_patterns = set()
@@ -270,9 +268,7 @@ class FindTool(BaseTool):
         min_size_bytes = self._parse_size(min_size) if min_size else None
         max_size_bytes = self._parse_size(max_size) if max_size else None
         modified_after_ts = self._parse_time(modified_after) if modified_after else None
-        modified_before_ts = (
-            self._parse_time(modified_before) if modified_before else None
-        )
+        modified_before_ts = self._parse_time(modified_before) if modified_before else None
 
         # Collect matches
         matches = []
@@ -350,20 +346,14 @@ class FindTool(BaseTool):
         stats = {
             "total_found": total_results,
             "search_time_ms": int((time.time() - start_time) * 1000),
-            "search_method": (
-                "ffind" if FFIND_AVAILABLE and not in_content else "python"
-            ),
+            "search_method": ("ffind" if FFIND_AVAILABLE and not in_content else "python"),
             "root_path": str(root_path),
             "filters_applied": {
                 "pattern": pattern,
                 "type": type,
-                "size": (
-                    {"min": min_size, "max": max_size} if min_size or max_size else None
-                ),
+                "size": ({"min": min_size, "max": max_size} if min_size or max_size else None),
                 "modified": (
-                    {"after": modified_after, "before": modified_before}
-                    if modified_after or modified_before
-                    else None
+                    {"after": modified_after, "before": modified_before} if modified_after or modified_before else None
                 ),
                 "max_depth": max_depth,
                 "gitignore": respect_gitignore,
@@ -594,9 +584,7 @@ class FindTool(BaseTool):
         elif fuzzy:
             pattern_lower = pattern.lower() if not case_sensitive else pattern
             matcher = (
-                lambda name: SequenceMatcher(
-                    None, pattern_lower, name.lower() if not case_sensitive else name
-                ).ratio()
+                lambda name: SequenceMatcher(None, pattern_lower, name.lower() if not case_sensitive else name).ratio()
                 > 0.6
             )
         else:
@@ -608,9 +596,7 @@ class FindTool(BaseTool):
                 matcher = lambda name: fnmatch.fnmatch(name, pattern)
 
         # Walk directory tree
-        for dirpath, dirnames, filenames in os.walk(
-            str(root), followlinks=follow_symlinks
-        ):
+        for dirpath, dirnames, filenames in os.walk(str(root), followlinks=follow_symlinks):
             # Check depth
             if max_depth is not None:
                 depth = len(Path(dirpath).relative_to(root).parts)
@@ -621,11 +607,7 @@ class FindTool(BaseTool):
             # Filter directories to skip
             if respect_gitignore:
                 dirnames[:] = [
-                    d
-                    for d in dirnames
-                    if not self._should_ignore(
-                        os.path.join(dirpath, d), ignore_patterns
-                    )
+                    d for d in dirnames if not self._should_ignore(os.path.join(dirpath, d), ignore_patterns)
                 ]
 
             # Check directories
@@ -662,9 +644,7 @@ class FindTool(BaseTool):
                         match_found = True
                     elif in_content:
                         # Search in file content
-                        match_found = await self._search_in_file(
-                            full_path, pattern, case_sensitive
-                        )
+                        match_found = await self._search_in_file(full_path, pattern, case_sensitive)
                     else:
                         match_found = False
 
@@ -686,9 +666,7 @@ class FindTool(BaseTool):
 
         return matches
 
-    async def _search_in_file(
-        self, file_path: str, pattern: str, case_sensitive: bool
-    ) -> bool:
+    async def _search_in_file(self, file_path: str, pattern: str, case_sensitive: bool) -> bool:
         """Search for pattern in file content."""
         try:
             with open(file_path, "r", encoding="utf-8", errors="ignore") as f:

hanzo_mcp/tools/search/unified_search.py

@@ -93,7 +93,7 @@ class UnifiedSearch(BaseTool):
 
     1. Find code patterns:
        search("error handling")  # Finds all error handling code
-       search("TASK|FIX")       # Regex search for task markers
+       search("TODO|FIXME")     # Regex search for TODOs
        search("async function") # Find async functions
 
     2. Find symbols/definitions:
@@ -171,9 +171,7 @@ class UnifiedSearch(BaseTool):
         # Use vector search for natural language queries
         indicators = [
             len(query.split()) > 2,  # Multi-word queries
-            not any(
-                c in query for c in ["(", ")", "{", "}", "[", "]"]
-            ),  # Not code syntax
+            not any(c in query for c in ["(", ")", "{", "}", "[", "]"]),  # Not code syntax
             " " in query,  # Has spaces (natural language)
             not query.startswith("^") and not query.endswith("$"),  # Not regex anchors
         ]
@@ -185,10 +183,7 @@ class UnifiedSearch(BaseTool):
         indicators = [
             "class " in query or "function " in query or "def " in query,
             "import " in query or "from " in query,
-            any(
-                kw in query.lower()
-                for kw in ["method", "function", "class", "interface", "struct"]
-            ),
+            any(kw in query.lower() for kw in ["method", "function", "class", "interface", "struct"]),
             "::" in query or "->" in query or "." in query,  # Member access
         ]
         return any(indicators)
@@ -198,9 +193,7 @@ class UnifiedSearch(BaseTool):
         # Use symbol search for identifiers
         return (
             len(query.split()) <= 2  # Short queries
-            and query.replace("_", "")
-            .replace("-", "")
-            .isalnum()  # Looks like identifier
+            and query.replace("_", "").replace("-", "").isalnum()  # Looks like identifier
             and not " " in query.strip()  # Single token
         )
 
@@ -243,19 +236,14 @@ class UnifiedSearch(BaseTool):
             # Search memory for natural language queries or specific references
             search_memory = MEMORY_AVAILABLE and (
                 self._should_use_vector_search(pattern)
-                or any(
-                    word in pattern.lower()
-                    for word in ["previous", "discussion", "remember", "last"]
-                )
+                or any(word in pattern.lower() for word in ["previous", "discussion", "remember", "last"])
             )
 
         if enable_text is None:
             enable_text = True  # Always use text search as baseline
 
         if enable_vector is None:
-            enable_vector = (
-                self._should_use_vector_search(pattern) and VECTOR_SEARCH_AVAILABLE
-            )
+            enable_vector = self._should_use_vector_search(pattern) and VECTOR_SEARCH_AVAILABLE
 
         if enable_ast is None:
             enable_ast = self._should_use_ast_search(pattern) and TREESITTER_AVAILABLE
@@ -277,9 +265,7 @@ class UnifiedSearch(BaseTool):
         # 1. Text search (ripgrep) - always fast, do first
         if enable_text:
             start = time.time()
-            text_results = await self._text_search(
-                pattern, path, include, exclude, max_results_per_type, context_lines
-            )
+            text_results = await self._text_search(pattern, path, include, exclude, max_results_per_type, context_lines)
             search_stats["time_ms"]["text"] = int((time.time() - start) * 1000)
             search_stats["search_types_used"].append("text")
             all_results.extend(text_results)
@@ -287,9 +273,7 @@ class UnifiedSearch(BaseTool):
         # 2. AST search - for code structure
         if enable_ast and TREESITTER_AVAILABLE:
             start = time.time()
-            ast_results = await self._ast_search(
-                pattern, path, include, exclude, max_results_per_type, context_lines
-            )
+            ast_results = await self._ast_search(pattern, path, include, exclude, max_results_per_type, context_lines)
             search_stats["time_ms"]["ast"] = int((time.time() - start) * 1000)
             search_stats["search_types_used"].append("ast")
             all_results.extend(ast_results)
@@ -297,9 +281,7 @@ class UnifiedSearch(BaseTool):
         # 3. Symbol search - for definitions
         if enable_symbol:
             start = time.time()
-            symbol_results = await self._symbol_search(
-                pattern, path, include, exclude, max_results_per_type
-            )
+            symbol_results = await self._symbol_search(pattern, path, include, exclude, max_results_per_type)
             search_stats["time_ms"]["symbol"] = int((time.time() - start) * 1000)
             search_stats["search_types_used"].append("symbol")
             all_results.extend(symbol_results)
@@ -317,9 +299,7 @@ class UnifiedSearch(BaseTool):
         # 5. File search - for finding files by name/pattern
         if search_files:
             start = time.time()
-            file_results = await self._file_search(
-                pattern, path, include, exclude, max_results_per_type
-            )
+            file_results = await self._file_search(pattern, path, include, exclude, max_results_per_type)
             search_stats["time_ms"]["files"] = int((time.time() - start) * 1000)
             search_stats["search_types_used"].append("files")
             all_results.extend(file_results)
@@ -327,9 +307,7 @@ class UnifiedSearch(BaseTool):
         # 6. Memory search - for knowledge base and previous discussions
         if search_memory:
             start = time.time()
-            memory_results = await self._memory_search(
-                pattern, max_results_per_type, context_lines
-            )
+            memory_results = await self._memory_search(pattern, max_results_per_type, context_lines)
             search_stats["time_ms"]["memory"] = int((time.time() - start) * 1000)
             search_stats["search_types_used"].append("memory")
             all_results.extend(memory_results)
@@ -428,9 +406,7 @@ class UnifiedSearch(BaseTool):
 
         if not self.ripgrep_available:
             # Fallback to Python implementation
-            return await self._python_text_search(
-                pattern, path, include, exclude, max_results, context_lines
-            )
+            return await self._python_text_search(pattern, path, include, exclude, max_results, context_lines)
 
         # Build ripgrep command
         cmd = ["rg", "--json", "--max-count", str(max_results)]
@@ -547,17 +523,9 @@ class UnifiedSearch(BaseTool):
                             file_path=str(file_path),
                             line_number=line_num,
                             column=0,
-                            match_text=(
-                                lines[line_num - 1]
-                                if 0 < line_num <= len(lines)
-                                else ""
-                            ),
-                            context_before=lines[
-                                max(0, line_num - context_lines - 1) : line_num - 1
-                            ],
-                            context_after=lines[
-                                line_num : min(len(lines), line_num + context_lines)
-                            ],
+                            match_text=(lines[line_num - 1] if 0 < line_num <= len(lines) else ""),
+                            context_before=lines[max(0, line_num - context_lines - 1) : line_num - 1],
+                            context_after=lines[line_num : min(len(lines), line_num + context_lines)],
                             match_type="ast",
                             score=0.9,
                             node_type="ast_match",
@@ -650,10 +618,7 @@ class UnifiedSearch(BaseTool):
                         context_before=[],
                         context_after=[],
                         match_type="vector",
-                        score=1.0
-                        - search_results["distances"][0][
-                            i
-                        ],  # Convert distance to similarity
+                        score=1.0 - search_results["distances"][0][i],  # Convert distance to similarity
                         semantic_context=metadata.get("context", ""),
                     )
                     results.append(result)
@@ -712,9 +677,7 @@ class UnifiedSearch(BaseTool):
 
         return results
 
-    async def _memory_search(
-        self, query: str, max_results: int, context_lines: int
-    ) -> List[SearchResult]:
+    async def _memory_search(self, query: str, max_results: int, context_lines: int) -> List[SearchResult]:
         """Search in memory/knowledge base."""
         results = []
 
@@ -748,9 +711,7 @@ class UnifiedSearch(BaseTool):
                         file_path=virtual_path,
                         line_number=1,
                         column=0,
-                        match_text=(
-                            content[:200] + "..." if len(content) > 200 else content
-                        ),
+                        match_text=(content[:200] + "..." if len(content) > 200 else content),
                         context_before=[],
                         context_after=[],
                         match_type="memory",
@@ -793,9 +754,7 @@ class UnifiedSearch(BaseTool):
 
         return unique
 
-    def _rank_results(
-        self, results: List[SearchResult], query: str
-    ) -> List[SearchResult]:
+    def _rank_results(self, results: List[SearchResult], query: str) -> List[SearchResult]:
         """Rank results by relevance."""
         # Simple ranking based on:
         # 1. Match type score
@@ -808,16 +767,11 @@ class UnifiedSearch(BaseTool):
                 result.score *= 1.2
 
             # Path relevance (prefer non-test, non-vendor files)
-            if any(
-                skip in result.file_path for skip in ["test", "vendor", "node_modules"]
-            ):
+            if any(skip in result.file_path for skip in ["test", "vendor", "node_modules"]):
                 result.score *= 0.8
 
             # Prefer definition files
-            if any(
-                pattern in result.file_path
-                for pattern in ["index.", "main.", "api.", "types."]
-            ):
+            if any(pattern in result.file_path for pattern in ["index.", "main.", "api.", "types."]):
                 result.score *= 1.1
 
         # Sort by score descending, then by file path
@@ -955,16 +909,12 @@ class CodeIndexer:
         # Batch embed and store
         if documents:
             embeddings = self.embedder.encode(documents).tolist()
-            self.collection.add(
-                embeddings=embeddings, documents=documents, metadatas=metadatas, ids=ids
-            )
+            self.collection.add(embeddings=embeddings, documents=documents, metadatas=metadatas, ids=ids)
 
-    def _split_code_intelligently(
-        self, content: str, file_path: Path
-    ) -> List[Dict[str, Any]]:
+    def _split_code_intelligently(self, content: str, file_path: Path) -> List[Dict[str, Any]]:
         """Split code into meaningful chunks."""
-        # Using line-based splitting for compatibility with all file types
-        # AST parsing would only work for specific languages
+        # Simple line-based splitting for now
+        # TODO: Use AST for better splitting
         chunks = []
         lines = content.split("\n")
 
@@ -976,9 +926,7 @@ class CodeIndexer:
             current_chunk.append(line)
 
             # Split on function/class definitions or every 50 lines
-            if len(current_chunk) >= 50 or any(
-                kw in line for kw in ["def ", "function ", "class ", "interface "]
-            ):
+            if len(current_chunk) >= 50 or any(kw in line for kw in ["def ", "function ", "class ", "interface "]):
                 if current_chunk:
                     chunks.append(
                         {
@@ -992,9 +940,7 @@ class CodeIndexer:
 
         # Add remaining
         if current_chunk:
-            chunks.append(
-                {"text": "\n".join(current_chunk), "line": current_line, "type": "code"}
-            )
+            chunks.append({"text": "\n".join(current_chunk), "line": current_line, "type": "code"})
 
         return chunks
 

hanzo_mcp/tools/shell/__init__.py

@@ -13,6 +13,7 @@ from hanzo_mcp.tools.shell.zsh_tool import zsh_tool, shell_tool
 
 # Import tools
 from hanzo_mcp.tools.shell.bash_tool import bash_tool
+from hanzo_mcp.tools.shell.run_tool import run_tool
 from hanzo_mcp.tools.common.permissions import PermissionManager
 from hanzo_mcp.tools.shell.process_tool import process_tool
 
@@ -40,17 +41,19 @@ def get_shell_tools(
     bash_tool.permission_manager = permission_manager
     zsh_tool.permission_manager = permission_manager
     shell_tool.permission_manager = permission_manager
+    run_tool.permission_manager = permission_manager
     npx_tool.permission_manager = permission_manager
     uvx_tool.permission_manager = permission_manager
 
     # Note: StreamingCommandTool is abstract and shouldn't be instantiated directly
     # It's used as a base class for other streaming tools
 
-    # Return shell_tool first (smart default), then specific shells
+    # Return run_tool first (simplified command execution), then shell_tool (smart default), then specific shells
     return [
+        run_tool,    # Simplified run command with auto-backgrounding
         shell_tool,  # Smart shell (prefers zsh if available)
-        zsh_tool,    # Explicit zsh
-        bash_tool,   # Explicit bash
+        zsh_tool,  # Explicit zsh
+        bash_tool,  # Explicit bash
         npx_tool,
         uvx_tool,
         process_tool,
@@ -62,16 +65,25 @@ def get_shell_tools(
 def register_shell_tools(
     mcp_server: FastMCP,
     permission_manager: PermissionManager,
+    enabled_tools: dict[str, bool] | None = None,
 ) -> list[BaseTool]:
     """Register all shell tools with the MCP server.
 
     Args:
         mcp_server: The FastMCP server instance
         permission_manager: Permission manager for access control
+        enabled_tools: Optional dict of tool names to enable/disable
 
     Returns:
         List of registered tools
     """
-    tools = get_shell_tools(permission_manager)
+    all_tools = get_shell_tools(permission_manager)
+    
+    # Filter tools based on enabled_tools if provided
+    if enabled_tools is not None:
+        tools = [tool for tool in all_tools if enabled_tools.get(tool.name, True)]
+    else:
+        tools = all_tools
+    
     ToolRegistry.register_tools(mcp_server, tools)
     return tools

hanzo_mcp/tools/shell/auto_background.py

@@ -19,9 +19,7 @@ class AutoBackgroundExecutor:
     # Default timeout before auto-backgrounding (2 minutes)
     DEFAULT_TIMEOUT = 120.0
 
-    def __init__(
-        self, process_manager: ProcessManager, timeout: float = DEFAULT_TIMEOUT
-    ):
+    def __init__(self, process_manager: ProcessManager, timeout: float = DEFAULT_TIMEOUT):
         """Initialize the auto-background executor.
 
         Args:
@@ -148,9 +146,7 @@ class AutoBackgroundExecutor:
                     task.cancel()
 
                 # Continue reading output in background
-                asyncio.create_task(
-                    self._background_reader(process, process_id, log_file)
-                )
+                asyncio.create_task(self._background_reader(process, process_id, log_file))
 
                 # Return status message
                 elapsed = time.time() - start_time

hanzo_mcp/tools/shell/base.py

@@ -63,11 +63,7 @@ class CommandResult:
         Returns:
             True if the command succeeded, False otherwise
         """
-        return (
-            self.return_code == 0
-            and self.status == BashCommandStatus.COMPLETED
-            and not self.error_message
-        )
+        return self.return_code == 0 and self.status == BashCommandStatus.COMPLETED and not self.error_message
 
     @property
     def is_running(self) -> bool:

hanzo_mcp/tools/shell/base_process.py

@@ -171,13 +171,11 @@ class BaseProcessTool(BaseTool):
             process_env.update(env)
 
         # Execute with auto-backgrounding
-        output, was_backgrounded, process_id = (
-            await self.auto_background_executor.execute_with_auto_background(
-                cmd_args=cmd_args,
-                tool_name=self.get_tool_name(),
-                cwd=cwd,
-                env=process_env,
-            )
+        output, was_backgrounded, process_id = await self.auto_background_executor.execute_with_auto_background(
+            cmd_args=cmd_args,
+            tool_name=self.get_tool_name(),
+            cwd=cwd,
+            env=process_env,
         )
 
         if was_backgrounded: