claude-mpm 4.2.51__py3-none-any.whl → 4.3.0__py3-none-any.whl

claude_mpm/services/agents/deployment/agent_template_builder.py

@@ -30,6 +30,52 @@ class AgentTemplateBuilder:
         """Initialize the template builder."""
         self.logger = get_logger(__name__)
 
+    def normalize_tools_input(self, tools):
+        """Normalize various tool input formats to a consistent list.
+
+        Handles multiple input formats:
+        - None/empty: Returns default tools
+        - String: Splits by comma and strips whitespace
+        - List: Ensures all items are strings and strips whitespace
+        - Dict: Takes enabled tools (where value is True)
+
+        Args:
+            tools: Tools input in various formats (str, list, dict, or None)
+
+        Returns:
+            List of tool names, normalized and cleaned
+        """
+        default_tools = ["Read", "Write", "Edit", "Grep", "Glob", "Bash"]
+
+        # Handle None or empty
+        if not tools:
+            self.logger.debug("No tools provided, using defaults")
+            return default_tools
+
+        # Convert to list format
+        if isinstance(tools, str):
+            # Split by comma, strip whitespace
+            tool_list = [t.strip() for t in tools.split(",") if t.strip()]
+            self.logger.debug(f"Converted string tools '{tools}' to list: {tool_list}")
+        elif isinstance(tools, list):
+            # Ensure all items are strings and strip whitespace
+            tool_list = [str(t).strip() for t in tools if t and str(t).strip()]
+            self.logger.debug(f"Normalized list tools: {tool_list}")
+        elif isinstance(tools, dict):
+            # Handle dict format - take enabled tools
+            tool_list = [k for k, v in tools.items() if v]
+            self.logger.info(f"Converting dict tools format: {tools} -> {tool_list}")
+        else:
+            self.logger.warning(f"Unknown tools format: {type(tools)}, using defaults")
+            return default_tools
+
+        # Return processed list or defaults if empty
+        if not tool_list:
+            self.logger.debug("Tools list empty after processing, using defaults")
+            return default_tools
+
+        return tool_list
+
     def _load_base_agent_instructions(self, agent_type: str) -> str:
         """Load BASE instructions for a specific agent type.
 
@@ -138,13 +184,39 @@ class AgentTemplateBuilder:
             capabilities.get("tools") if isinstance(capabilities, dict) else None
         )
 
-        tools = (
+        # Get raw tools from various possible locations
+        raw_tools = (
             template_data.get("tools")
             or capabilities_tools
             or template_data.get("configuration_fields", {}).get("tools")
-            or ["Read", "Write", "Edit", "Grep", "Glob", "LS"]  # Default fallback
         )
 
+        # Normalize tools to a consistent list format
+        tools = self.normalize_tools_input(raw_tools)
+
+        # Log if we see non-standard tool names (info level, not warning)
+        standard_tools = {
+            "Read",
+            "Write",
+            "Edit",
+            "MultiEdit",  # File operations
+            "Grep",
+            "Glob",
+            "LS",  # Search and navigation
+            "Bash",
+            "BashOutput",
+            "KillShell",  # Command execution
+            "TodoWrite",
+            "ExitPlanMode",  # Task management
+            "WebSearch",
+            "WebFetch",  # Web operations
+            "NotebookRead",
+            "NotebookEdit",  # Jupyter notebook support
+        }
+        non_standard = [t for t in tools if t not in standard_tools]
+        if non_standard:
+            self.logger.info(f"Using non-standard tools: {non_standard}")
+
         # Extract model from template with fallback
         capabilities_model = (
             capabilities.get("model") if isinstance(capabilities, dict) else None
@@ -157,15 +229,8 @@ class AgentTemplateBuilder:
             or "sonnet"  # Default fallback
         )
 
-        # Convert tools list to comma-separated string (no spaces!)
-        tools_str = ",".join(tools) if isinstance(tools, list) else str(tools)
-
-        # Validate tools format - CRITICAL: No spaces allowed!
-        if ", " in tools_str:
-            self.logger.error(f"Tools contain spaces: '{tools_str}'")
-            raise ValueError(
-                f"Tools must be comma-separated WITHOUT spaces: {tools_str}"
-            )
+        # Convert tools list to comma-separated string (without spaces for compatibility)
+        tools_str = ",".join(tools)
 
         # Map model names to Claude Code format (as required)
         model_map = {
@@ -331,12 +396,20 @@ class AgentTemplateBuilder:
         base_instructions = self._load_base_agent_instructions(agent_type)
 
         # Get agent instructions from template data (primary) or base agent data (fallback)
-        agent_specific_instructions = (
-            template_data.get("instructions")
-            or base_agent_data.get("content")
-            or base_agent_data.get("instructions")
-            or "# Agent Instructions\n\nThis agent provides specialized assistance."
-        )
+        raw_instructions = template_data.get("instructions")
+
+        # Handle dictionary instructions format
+        if isinstance(raw_instructions, dict):
+            agent_specific_instructions = self._convert_instructions_dict_to_markdown(
+                raw_instructions
+            )
+        else:
+            agent_specific_instructions = (
+                raw_instructions
+                or base_agent_data.get("content")
+                or base_agent_data.get("instructions")
+                or "# Agent Instructions\n\nThis agent provides specialized assistance."
+            )
 
         # Combine BASE instructions with agent-specific instructions
         if base_instructions:
@@ -423,7 +496,8 @@ Only include memories that are:
         )
 
         # Get tools and model with fallbacks
-        tools = merged_config.get("tools", ["Read", "Write", "Edit"])
+        raw_tools = merged_config.get("tools")
+        tools = self.normalize_tools_input(raw_tools)
         model = merged_config.get("model", "sonnet")
 
         # Format tools as YAML list
@@ -890,3 +964,171 @@ tools:
 
         # Return as quoted string
         return f'"{escaped}"'
+
+    def _convert_instructions_dict_to_markdown(self, instructions_dict: dict) -> str:
+        """Convert complex instructions dictionary to markdown format.
+
+        Args:
+            instructions_dict: Dictionary containing structured instructions
+
+        Returns:
+            Formatted markdown string representing the instructions
+        """
+        if not instructions_dict:
+            return "# Agent Instructions\n\nThis agent provides specialized assistance."
+
+        markdown_parts = []
+
+        # Add primary role
+        if "primary_role" in instructions_dict:
+            markdown_parts.extend(["# Role", "", instructions_dict["primary_role"], ""])
+
+        # Add core identity
+        if "core_identity" in instructions_dict:
+            markdown_parts.extend(
+                ["## Core Identity", "", instructions_dict["core_identity"], ""]
+            )
+
+        # Add responsibilities
+        if "responsibilities" in instructions_dict:
+            markdown_parts.extend(["## Responsibilities", ""])
+
+            responsibilities = instructions_dict["responsibilities"]
+            if isinstance(responsibilities, list):
+                for resp in responsibilities:
+                    if isinstance(resp, dict):
+                        area = resp.get("area", "Unknown Area")
+                        tasks = resp.get("tasks", [])
+
+                        markdown_parts.extend([f"### {area}", ""])
+
+                        if isinstance(tasks, list):
+                            for task in tasks:
+                                markdown_parts.append(f"- {task}")
+
+                        markdown_parts.append("")
+                    else:
+                        markdown_parts.append(f"- {resp}")
+
+            markdown_parts.append("")
+
+        # Add analytical framework
+        if "analytical_framework" in instructions_dict:
+            framework = instructions_dict["analytical_framework"]
+            if isinstance(framework, dict):
+                markdown_parts.extend(["## Analytical Framework", ""])
+
+                for framework_area, framework_data in framework.items():
+                    markdown_parts.extend(
+                        [f"### {framework_area.replace('_', ' ').title()}", ""]
+                    )
+
+                    if isinstance(framework_data, dict):
+                        for category, items in framework_data.items():
+                            markdown_parts.extend(
+                                [f"#### {category.replace('_', ' ').title()}", ""]
+                            )
+
+                            if isinstance(items, list):
+                                for item in items:
+                                    markdown_parts.append(f"- {item}")
+                            elif isinstance(items, str):
+                                markdown_parts.append(items)
+
+                            markdown_parts.append("")
+                    elif isinstance(framework_data, list):
+                        for item in framework_data:
+                            markdown_parts.append(f"- {item}")
+                        markdown_parts.append("")
+
+        # Add methodologies
+        if "methodologies" in instructions_dict:
+            methodologies = instructions_dict["methodologies"]
+            if isinstance(methodologies, dict):
+                markdown_parts.extend(["## Methodologies", ""])
+
+                for method_name, method_data in methodologies.items():
+                    markdown_parts.extend(
+                        [f"### {method_name.replace('_', ' ').title()}", ""]
+                    )
+
+                    if isinstance(method_data, dict):
+                        for key, value in method_data.items():
+                            if isinstance(value, list):
+                                markdown_parts.extend(
+                                    [f"#### {key.replace('_', ' ').title()}", ""]
+                                )
+                                for item in value:
+                                    markdown_parts.append(f"- {item}")
+                                markdown_parts.append("")
+                            elif isinstance(value, str):
+                                markdown_parts.extend(
+                                    [
+                                        f"**{key.replace('_', ' ').title()}**: {value}",
+                                        "",
+                                    ]
+                                )
+
+        # Add quality standards
+        if "quality_standards" in instructions_dict:
+            standards = instructions_dict["quality_standards"]
+            if isinstance(standards, dict):
+                markdown_parts.extend(["## Quality Standards", ""])
+
+                for standard_area, standard_items in standards.items():
+                    markdown_parts.extend(
+                        [f"### {standard_area.replace('_', ' ').title()}", ""]
+                    )
+
+                    if isinstance(standard_items, list):
+                        for item in standard_items:
+                            markdown_parts.append(f"- {item}")
+                    elif isinstance(standard_items, str):
+                        markdown_parts.append(standard_items)
+
+                    markdown_parts.append("")
+
+        # Add communication style
+        if "communication_style" in instructions_dict:
+            comm_style = instructions_dict["communication_style"]
+            if isinstance(comm_style, dict):
+                markdown_parts.extend(["## Communication Style", ""])
+
+                for style_area, style_items in comm_style.items():
+                    markdown_parts.extend(
+                        [f"### {style_area.replace('_', ' ').title()}", ""]
+                    )
+
+                    if isinstance(style_items, list):
+                        for item in style_items:
+                            markdown_parts.append(f"- {item}")
+                    elif isinstance(style_items, str):
+                        markdown_parts.append(style_items)
+
+                    markdown_parts.append("")
+
+        # If no specific sections were found, convert as generic dict
+        if not markdown_parts:
+            markdown_parts = ["# Agent Instructions", ""]
+            for key, value in instructions_dict.items():
+                key_title = key.replace("_", " ").title()
+                if isinstance(value, str):
+                    markdown_parts.extend([f"## {key_title}", "", value, ""])
+                elif isinstance(value, list):
+                    markdown_parts.extend([f"## {key_title}", ""])
+                    for item in value:
+                        markdown_parts.append(f"- {item}")
+                    markdown_parts.append("")
+                elif isinstance(value, dict):
+                    markdown_parts.extend([f"## {key_title}", ""])
+                    # Simple dict formatting
+                    for subkey, subvalue in value.items():
+                        if isinstance(subvalue, str):
+                            markdown_parts.extend(
+                                [
+                                    f"**{subkey.replace('_', ' ').title()}**: {subvalue}",
+                                    "",
+                                ]
+                            )
+
+        return "\n".join(markdown_parts).strip()

claude_mpm/services/agents/local_template_manager.py

@@ -280,7 +280,6 @@ class LocalAgentTemplateManager:
             parent_agent=parent_agent,
         )
 
-
     def save_local_template(
         self, template: LocalAgentTemplate, tier: Optional[str] = None
     ) -> Path:

claude_mpm/services/monitor/daemon_manager.py

@@ -575,9 +575,7 @@ class DaemonManager:
                     stdout=log_file,
                     stderr=subprocess.STDOUT if self.log_file else subprocess.DEVNULL,
                     start_new_session=True,  # Create new process group
-                    close_fds=(
-                        not self.log_file
-                    ),  # Keep log file open if redirecting
+                    close_fds=(not self.log_file),  # Keep log file open if redirecting
                     env=env,  # Pass modified environment
                 )
 

claude_mpm/services/monitor/event_emitter.py

@@ -186,7 +186,11 @@ class AsyncEventEmitter:
         return False
 
     async def _emit_http(
-        self, namespace: str, event: str, data: Dict[str, Any], endpoint: Optional[str] = None
+        self,
+        namespace: str,
+        event: str,
+        data: Dict[str, Any],
+        endpoint: Optional[str] = None,
     ) -> bool:
         """Emit event via HTTP with connection pooling."""
         if not self._http_session:

claude_mpm/services/monitor/handlers/hooks.py

@@ -428,7 +428,6 @@ class HookHandler:
             "original_event": data,  # Keep original for debugging
         }
 
-
     def _process_hook_event(self, data: Dict) -> Dict:
         """Process and normalize hook event data.
 
@@ -447,7 +446,6 @@ class HookHandler:
             "processed_at": asyncio.get_event_loop().time(),
         }
 
-
     def _update_session_tracking(self, session_id: str, event: Dict):
         """Update session tracking with new event.
 

claude_mpm/tools/code_tree_analyzer.py

@@ -1756,9 +1756,7 @@ class CodeTreeAnalyzer:
             return node.name not in important_magic
 
         # Filter very generic getters/setters only if they're trivial
-        if (name_lower.startswith(("get_", "set_"))) and len(
-            node.name
-        ) <= 8:
+        if (name_lower.startswith(("get_", "set_"))) and len(node.name) <= 8:
             return True
 
         # Don't filter single underscore functions - they're often important