massgen 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

massgen/__init__.py

@@ -68,7 +68,7 @@ from .chat_agent import (
 from .message_templates import MessageTemplates, get_templates
 from .orchestrator import Orchestrator, create_orchestrator
 
-__version__ = "0.1.2"
+__version__ = "0.1.4"
 __author__ = "MassGen Contributors"
 
 

massgen/agent_config.py

@@ -35,12 +35,17 @@ class CoordinationConfig:
                              Only the winning agent executes actions during final presentation.
                              If False, agents execute actions during coordination (default behavior).
         planning_mode_instruction: Custom instruction to add when planning mode is enabled.
+        max_orchestration_restarts: Maximum number of times orchestration can be restarted after
+                                   post-evaluation determines the answer is insufficient.
+                                   For example, max_orchestration_restarts=2 allows 3 total attempts
+                                   (initial + 2 restarts). Default is 0 (no restarts).
     """
 
     enable_planning_mode: bool = False
     planning_mode_instruction: str = (
         "During coordination, describe what you would do without actually executing actions. Only provide concrete implementation details without calling external APIs or tools."
     )
+    max_orchestration_restarts: int = 0
 
 
 @dataclass
@@ -87,6 +92,9 @@ class AgentConfig:
     # Debug/test mode - skip coordination rounds and go straight to final presentation
     skip_coordination_rounds: bool = False
 
+    # Debug mode for restart feature - override final answer on attempt 1 only
+    debug_final_answer: Optional[str] = None
+
     @property
     def custom_system_instruction(self) -> Optional[str]:
         """
@@ -432,7 +440,8 @@ class AgentConfig:
         import copy
 
         new_config = copy.deepcopy(self)
-        new_config.custom_system_instruction = instruction
+        # Set private attribute directly to avoid deprecation warning
+        new_config._custom_system_instruction = instruction
         return new_config
 
     def with_agent_id(self, agent_id: str) -> "AgentConfig":
@@ -538,7 +547,8 @@ class AgentConfig:
         else:
             raise ValueError(f"Domain expert configuration not available for backend: {backend}")
 
-        config.custom_system_instruction = instruction
+        # Set private attribute directly to avoid deprecation warning
+        config._custom_system_instruction = instruction
         return config
 
     # =============================================================================
@@ -567,9 +577,10 @@ class AgentConfig:
         conversation = templates.build_initial_conversation(task=task, agent_summaries=agent_summaries, valid_agent_ids=valid_agent_ids)
 
         # Add custom system instruction if provided
-        if self.custom_system_instruction:
+        # Access private attribute to avoid deprecation warning
+        if self._custom_system_instruction:
             base_system = conversation["system_message"]
-            conversation["system_message"] = f"{self.custom_system_instruction}\n\n{base_system}"
+            conversation["system_message"] = f"{self._custom_system_instruction}\n\n{base_system}"
 
         # Add backend configuration
         conversation.update(
@@ -703,7 +714,8 @@ class AgentConfig:
         result = {
             "backend_params": self.backend_params,
             "agent_id": self.agent_id,
-            "custom_system_instruction": self.custom_system_instruction,
+            # Access private attribute to avoid deprecation warning
+            "custom_system_instruction": self._custom_system_instruction,
             "voting_sensitivity": self.voting_sensitivity,
             "max_new_answers_per_agent": self.max_new_answers_per_agent,
             "answer_novelty_requirement": self.answer_novelty_requirement,
@@ -716,8 +728,12 @@ class AgentConfig:
         result["coordination_config"] = {
             "enable_planning_mode": self.coordination_config.enable_planning_mode,
             "planning_mode_instruction": self.coordination_config.planning_mode_instruction,
+            "max_orchestration_restarts": self.coordination_config.max_orchestration_restarts,
         }
 
+        # Handle debug fields
+        result["debug_final_answer"] = self.debug_final_answer
+
         # Handle message_templates serialization
         if self.message_templates is not None:
             try:
@@ -757,6 +773,9 @@ class AgentConfig:
         if coordination_data:
             coordination_config = CoordinationConfig(**coordination_data)
 
+        # Handle debug fields
+        debug_final_answer = data.get("debug_final_answer")
+
         # Handle message_templates
         message_templates = None
         template_data = data.get("message_templates")
@@ -765,17 +784,24 @@ class AgentConfig:
 
             message_templates = MessageTemplates(**template_data)
 
-        return cls(
+        config = cls(
             backend_params=backend_params,
             message_templates=message_templates,
             agent_id=agent_id,
-            custom_system_instruction=custom_system_instruction,
             voting_sensitivity=voting_sensitivity,
             max_new_answers_per_agent=max_new_answers_per_agent,
             answer_novelty_requirement=answer_novelty_requirement,
             timeout_config=timeout_config,
             coordination_config=coordination_config,
         )
+        config.debug_final_answer = debug_final_answer
+        return config
+
+        # Set custom_system_instruction separately to avoid deprecation warning
+        if custom_system_instruction is not None:
+            config._custom_system_instruction = custom_system_instruction
+
+        return config
 
 
 # =============================================================================

massgen/api_params_handler/_api_params_handler_base.py

@@ -56,8 +56,10 @@ class APIParamsHandlerBase(ABC):
             # Filesystem manager parameters (handled by base class)
             "cwd",
             "agent_temporary_workspace",
+            "agent_temporary_workspace_parent",
             "context_paths",
             "context_write_access_enabled",
+            "enforce_read_before_delete",
             "enable_image_generation",
             "enable_mcp_command_line",
             "command_line_allowed_commands",
@@ -67,6 +69,7 @@ class APIParamsHandlerBase(ABC):
             "command_line_docker_memory_limit",
             "command_line_docker_cpu_limit",
             "command_line_docker_network_mode",
+            "command_line_docker_enable_sudo",
             # Backend identification (handled by orchestrator)
             "enable_audio_generation",  # Audio generation parameter
             "type",

massgen/api_params_handler/_chat_completions_api_params_handler.py

@@ -24,6 +24,10 @@ class ChatCompletionsAPIParamsHandler(APIParamsHandlerBase):
                 "allowed_tools",
                 "exclude_tools",
                 "custom_tools",  # Custom tools configuration (processed separately)
+                "enable_file_generation",  # Internal flag for file generation (used in system messages only)
+                "enable_image_generation",  # Internal flag for image generation (used in system messages only)
+                "enable_audio_generation",  # Internal flag for audio generation (used in system messages only)
+                "enable_video_generation",  # Internal flag for video generation (used in system messages only)
             },
         )
 

massgen/api_params_handler/_claude_api_params_handler.py

@@ -24,6 +24,10 @@ class ClaudeAPIParamsHandler(APIParamsHandlerBase):
                 "exclude_tools",
                 "custom_tools",  # Custom tools configuration (processed separately)
                 "_has_files_api_files",
+                "enable_file_generation",  # Internal flag for file generation (used in system messages only)
+                "enable_image_generation",  # Internal flag for image generation (used in system messages only)
+                "enable_audio_generation",  # Internal flag for audio generation (used in system messages only)
+                "enable_video_generation",  # Internal flag for video generation (used in system messages only)
             },
         )
 

massgen/api_params_handler/_gemini_api_params_handler.py

@@ -19,6 +19,10 @@ class GeminiAPIParamsHandler(APIParamsHandlerBase):
             "allowed_tools",
             "exclude_tools",
             "custom_tools",
+            "enable_file_generation",  # Internal flag for file generation (used in system messages only)
+            "enable_image_generation",  # Internal flag for image generation (used in system messages only)
+            "enable_audio_generation",  # Internal flag for audio generation (used in system messages only)
+            "enable_video_generation",  # Internal flag for video generation (used in system messages only)
         }
         return set(base) | extra
 

massgen/api_params_handler/_response_api_params_handler.py

@@ -24,6 +24,10 @@ class ResponseAPIParamsHandler(APIParamsHandlerBase):
                 "exclude_tools",
                 "custom_tools",  # Custom tools configuration (processed separately)
                 "_has_file_search_files",  # Internal flag for file search tracking
+                "enable_file_generation",  # Internal flag for file generation (used in system messages only)
+                "enable_image_generation",  # Internal flag for image generation (used in system messages only)
+                "enable_audio_generation",  # Internal flag for audio generation (used in system messages only)
+                "enable_video_generation",  # Internal flag for video generation (used in system messages only)
             },
         )
 

massgen/backend/azure_openai.py

@@ -94,7 +94,7 @@ class AzureOpenAIBackend(LLMBackend):
                 raise ValueError("Azure OpenAI requires a deployment name. Pass it as the 'model' parameter.")
 
             # Check if workflow tools are present
-            workflow_tools = [t for t in tools if t.get("function", {}).get("name") in ["new_answer", "vote"]] if tools else []
+            workflow_tools = [t for t in tools if t.get("function", {}).get("name") in ["new_answer", "vote", "submit", "restart_orchestration"]] if tools else []
             has_workflow_tools = len(workflow_tools) > 0
 
             # Modify messages to include workflow tool instructions if needed
@@ -270,6 +270,14 @@ class AzureOpenAIBackend(LLMBackend):
                         system_parts.append(f'    Usage: {{"tool_name": "vote", ' f'"arguments": {{"agent_id": "agent1", ' f'"reason": "explanation"}}}} // Choose agent_id from: {agent_list}')
                     else:
                         system_parts.append('    Usage: {"tool_name": "vote", ' '"arguments": {"agent_id": "agent1", ' '"reason": "explanation"}}')
+                elif name == "submit":
+                    system_parts.append(
+                        '    Usage: {"tool_name": "submit", ' '"arguments": {"confirmed": true}}',
+                    )
+                elif name == "restart_orchestration":
+                    system_parts.append(
+                        '    Usage: {"tool_name": "restart_orchestration", ' '"arguments": {"reason": "The answer is incomplete because...", ' '"instructions": "In the next attempt, please..."}}',
+                    )
 
             system_parts.append("\n--- MassGen Workflow Instructions ---")
             system_parts.append("IMPORTANT: You must respond with a structured JSON decision at the end of your response.")

massgen/backend/base.py

@@ -112,6 +112,7 @@ class LLMBackend(ABC):
                     "command_line_docker_memory_limit": kwargs.get("command_line_docker_memory_limit"),
                     "command_line_docker_cpu_limit": kwargs.get("command_line_docker_cpu_limit"),
                     "command_line_docker_network_mode": network_mode,
+                    "command_line_docker_enable_sudo": kwargs.get("command_line_docker_enable_sudo", False),
                     "enable_audio_generation": kwargs.get("enable_audio_generation", False),
                 }
 
@@ -188,8 +189,10 @@ class LLMBackend(ABC):
             # Filesystem manager parameters (handled by base class)
             "cwd",
             "agent_temporary_workspace",
+            "agent_temporary_workspace_parent",
             "context_paths",
             "context_write_access_enabled",
+            "enforce_read_before_delete",
             "enable_image_generation",
             "enable_mcp_command_line",
             "command_line_allowed_commands",
@@ -199,6 +202,7 @@ class LLMBackend(ABC):
             "command_line_docker_memory_limit",
             "command_line_docker_cpu_limit",
             "command_line_docker_network_mode",
+            "command_line_docker_enable_sudo",
             # Backend identification (handled by orchestrator)
             "type",
             "agent_id",

massgen/backend/base_with_custom_tool_and_mcp.py

@@ -284,9 +284,19 @@ class CustomToolAndMCPBackend(LLMBackend):
 
                     # Register each function with its corresponding values
                     for i, func in enumerate(functions):
+                        # Inject agent_cwd into preset_args if filesystem_manager is available
+                        final_preset_args = preset_args_list[i].copy() if preset_args_list[i] else {}
+                        if self.filesystem_manager and self.filesystem_manager.cwd:
+                            final_preset_args["agent_cwd"] = self.filesystem_manager.cwd
+                            logger.info(f"Injecting agent_cwd for {func}: {self.filesystem_manager.cwd}")
+                        elif self.filesystem_manager:
+                            logger.warning(f"filesystem_manager exists but cwd is None for {func}")
+                        else:
+                            logger.warning(f"No filesystem_manager available for {func}")
+
                         # Load the function first if custom name is needed
                         if names[i] and names[i] != func:
-                            # Need to load function and apply custom name
+                            # Load function to apply custom name
                             if path:
                                 loaded_func = self.custom_tool_manager._load_function_from_path(path, func)
                             else:
@@ -296,7 +306,6 @@ class CustomToolAndMCPBackend(LLMBackend):
                                 logger.error(f"Could not load function '{func}' from path: {path}")
                                 continue
 
-                            # Apply custom name by modifying __name__ attribute
                             loaded_func.__name__ = names[i]
 
                             # Register with loaded function (no path needed)
@@ -304,7 +313,7 @@ class CustomToolAndMCPBackend(LLMBackend):
                                 path=None,
                                 func=loaded_func,
                                 category=category,
-                                preset_args=preset_args_list[i],
+                                preset_args=final_preset_args,
                                 description=descriptions[i],
                             )
                         else:
@@ -313,7 +322,7 @@ class CustomToolAndMCPBackend(LLMBackend):
                                 path=path,
                                 func=func,
                                 category=category,
-                                preset_args=preset_args_list[i],
+                                preset_args=final_preset_args,
                                 description=descriptions[i],
                             )
 
@@ -404,9 +413,19 @@ class CustomToolAndMCPBackend(LLMBackend):
         """
         import json
 
+        # Parse arguments
+        arguments = json.loads(call["arguments"]) if isinstance(call["arguments"], str) else call["arguments"]
+
+        # Ensure agent_cwd is always injected if filesystem_manager is available
+        # This provides a fallback in case preset_args didn't work during registration
+        if self.filesystem_manager and self.filesystem_manager.cwd:
+            if "agent_cwd" not in arguments or arguments.get("agent_cwd") is None:
+                arguments["agent_cwd"] = self.filesystem_manager.cwd
+                logger.info(f"Dynamically injected agent_cwd at execution time: {self.filesystem_manager.cwd}")
+
         tool_request = {
             "name": call["name"],
-            "input": json.loads(call["arguments"]) if isinstance(call["arguments"], str) else call["arguments"],
+            "input": arguments,
         }
 
         result_text = ""
@@ -1120,6 +1139,7 @@ class CustomToolAndMCPBackend(LLMBackend):
         **kwargs,
     ) -> AsyncGenerator[StreamChunk, None]:
         """Simple passthrough streaming without MCP processing."""
+
         agent_id = kwargs.get("agent_id", None)
         all_params = {**self.config, **kwargs}
         processed_messages = await self._process_upload_files(messages, all_params)

massgen/backend/claude_code.py

@@ -795,7 +795,7 @@ class ClaudeCodeBackend(LLMBackend):
 
         # Add workflow tools information if present
         if tools:
-            workflow_tools = [t for t in tools if t.get("function", {}).get("name") in ["new_answer", "vote"]]
+            workflow_tools = [t for t in tools if t.get("function", {}).get("name") in ["new_answer", "vote", "submit", "restart_orchestration"]]
             if workflow_tools:
                 system_parts.append("\n--- Coordination Actions ---")
                 for tool in workflow_tools:
@@ -823,6 +823,14 @@ class ClaudeCodeBackend(LLMBackend):
                             system_parts.append(f'    Usage: {{"tool_name": "vote", ' f'"arguments": {{"agent_id": "agent1", ' f'"reason": "explanation"}}}} // Choose agent_id from: {agent_list}')
                         else:
                             system_parts.append('    Usage: {"tool_name": "vote", ' '"arguments": {"agent_id": "agent1", ' '"reason": "explanation"}}')
+                    elif name == "submit":
+                        system_parts.append(
+                            '    Usage: {"tool_name": "submit", ' '"arguments": {"confirmed": true}}',
+                        )
+                    elif name == "restart_orchestration":
+                        system_parts.append(
+                            '    Usage: {"tool_name": "restart_orchestration", ' '"arguments": {"reason": "The answer is incomplete because...", ' '"instructions": "In the next attempt, please..."}}',
+                        )
 
                 system_parts.append("\n--- MassGen Coordination Instructions ---")
                 system_parts.append("IMPORTANT: You must respond with a structured JSON decision at the end of your response.")

massgen/backend/docs/permissions_and_context_files.md

@@ -1067,8 +1067,8 @@ Files delivered:
 - **Multi-Turn Design**: `docs/dev_notes/multi_turn_filesystem_design.md` - Detailed architecture for session persistence and turn-based workflows
 - **MCP Integration**: `docs/dev_notes/gemini_filesystem_mcp_design.md` - How filesystem access works through Model Context Protocol
 - **Context Sharing**: `docs/dev_notes/v0.0.14-context.md` - Original context sharing design
-- **User Context Paths**: `docs/case_studies/user-context-path-support-with-copy-mcp.md` - Case study on adding user-specified paths
-- **Claude Code Workspace**: `docs/case_studies/claude-code-workspace-management.md` - Native filesystem integration patterns
+- **User Context Paths**: `docs/source/examples/case_studies/user-context-path-support-with-copy-mcp.md` - Case study on adding user-specified paths
+- **Claude Code Workspace**: `docs/source/examples/case_studies/claude-code-workspace-management.md` - Native filesystem integration patterns
 
 ## Conclusion
 

massgen/backend/gemini.py

@@ -20,6 +20,7 @@ TECHNICAL SOLUTION:
 """
 
 import json
+import logging
 import os
 import time
 from typing import Any, AsyncGenerator, Dict, List, Optional
@@ -39,6 +40,19 @@ from .gemini_mcp_manager import GeminiMCPManager
 from .gemini_trackers import MCPCallTracker, MCPResponseExtractor, MCPResponseTracker
 from .gemini_utils import CoordinationResponse
 
+
+# Suppress Gemini SDK logger warning about non-text parts in response
+# Using custom filter per https://github.com/googleapis/python-genai/issues/850
+class NoFunctionCallWarning(logging.Filter):
+    def filter(self, record: logging.LogRecord) -> bool:
+        message = record.getMessage()
+        if "there are non-text parts in the response:" in message:
+            return False
+        return True
+
+
+logging.getLogger("google_genai.types").addFilter(NoFunctionCallWarning())
+
 try:
     from pydantic import BaseModel, Field
 except ImportError:
@@ -220,6 +234,7 @@ class GeminiBackend(CustomToolAndMCPBackend):
 
             # Analyze tool types
             is_coordination = self.formatter.has_coordination_tools(tools)
+            is_post_evaluation = self.formatter.has_post_evaluation_tools(tools)
 
             valid_agent_ids = None
 
@@ -239,6 +254,9 @@ class GeminiBackend(CustomToolAndMCPBackend):
             # For coordination requests, modify the prompt to use structured output
             if is_coordination:
                 full_content = self.formatter.build_structured_output_prompt(full_content, valid_agent_ids)
+            elif is_post_evaluation:
+                # For post-evaluation, modify prompt to use structured output
+                full_content = self.formatter.build_post_evaluation_prompt(full_content)
 
             # Use google-genai package
             client = genai.Client(api_key=self.api_key)
@@ -277,6 +295,16 @@ class GeminiBackend(CustomToolAndMCPBackend):
                 else:
                     # Tools or sessions are present; fallback to text parsing
                     pass
+            elif is_post_evaluation:
+                # For post-evaluation, use JSON response format for structured decisions
+                from .gemini_utils import PostEvaluationResponse
+
+                if (not using_sdk_mcp) and (not using_custom_tools) and (not all_tools):
+                    config["response_mime_type"] = "application/json"
+                    config["response_schema"] = PostEvaluationResponse.model_json_schema()
+                else:
+                    # Tools or sessions are present; fallback to text parsing
+                    pass
             # Log messages being sent after builtin_tools is defined
             log_backend_agent_message(
                 agent_id or "default",
@@ -1603,11 +1631,11 @@ class GeminiBackend(CustomToolAndMCPBackend):
 
             content = full_content_text
 
-            # Process tool calls - only coordination tool calls (MCP manual mode removed)
+            # Process tool calls - coordination and post-evaluation tool calls (MCP manual mode removed)
             tool_calls_detected: List[Dict[str, Any]] = []
 
-            # Then, process coordination tools if present
-            if is_coordination and content.strip() and not tool_calls_detected:
+            # Process coordination tools OR post-evaluation tools if present
+            if (is_coordination or is_post_evaluation) and content.strip() and not tool_calls_detected:
                 # For structured output mode, the entire content is JSON
                 structured_response = None
                 # Try multiple parsing strategies
@@ -1626,14 +1654,15 @@ class GeminiBackend(CustomToolAndMCPBackend):
                         # Log conversion to tool calls (summary)
                         log_stream_chunk("backend.gemini", "tool_calls", tool_calls, agent_id)
 
-                        # Log each coordination tool call for analytics/debugging
+                        # Log each tool call for analytics/debugging
+                        tool_type = "post_evaluation" if is_post_evaluation else "coordination"
                         try:
                             for tool_call in tool_calls:
                                 log_tool_call(
                                     agent_id,
-                                    tool_call.get("function", {}).get("name", "unknown_coordination_tool"),
+                                    tool_call.get("function", {}).get("name", f"unknown_{tool_type}_tool"),
                                     tool_call.get("function", {}).get("arguments", {}),
-                                    result="coordination_tool_called",
+                                    result=f"{tool_type}_tool_called",
                                     backend_name="gemini",
                                 )
                         except Exception:

massgen/backend/gemini_utils.py

@@ -20,6 +20,13 @@ class ActionType(enum.Enum):
     NEW_ANSWER = "new_answer"
 
 
+class PostEvaluationActionType(enum.Enum):
+    """Action types for post-evaluation structured output."""
+
+    SUBMIT = "submit"
+    RESTART = "restart"
+
+
 class VoteAction(BaseModel):
     """Structured output for voting action."""
 
@@ -41,3 +48,26 @@ class CoordinationResponse(BaseModel):
     action_type: ActionType = Field(description="Type of action to take")
     vote_data: Optional[VoteAction] = Field(default=None, description="Vote data if action is vote")
     answer_data: Optional[NewAnswerAction] = Field(default=None, description="Answer data if action is new_answer")
+
+
+class SubmitAction(BaseModel):
+    """Structured output for submit action (post-evaluation)."""
+
+    action: PostEvaluationActionType = Field(default=PostEvaluationActionType.SUBMIT, description="Action type")
+    confirmed: bool = Field(default=True, description="Confirmation that answer is satisfactory")
+
+
+class RestartAction(BaseModel):
+    """Structured output for restart action (post-evaluation)."""
+
+    action: PostEvaluationActionType = Field(default=PostEvaluationActionType.RESTART, description="Action type")
+    reason: str = Field(description="Clear explanation of why the answer is insufficient")
+    instructions: str = Field(description="Detailed, actionable guidance for agents on the next attempt")
+
+
+class PostEvaluationResponse(BaseModel):
+    """Structured response for post-evaluation actions."""
+
+    action_type: PostEvaluationActionType = Field(description="Type of post-evaluation action to take")
+    submit_data: Optional[SubmitAction] = Field(default=None, description="Submit data if action is submit")
+    restart_data: Optional[RestartAction] = Field(default=None, description="Restart data if action is restart")

massgen/backend/response.py

@@ -57,6 +57,7 @@ class ResponseBackend(CustomToolAndMCPBackend):
 
         Wraps parent implementation to ensure File Search cleanup happens after streaming completes.
         """
+
         try:
             async for chunk in super().stream_with_tools(messages, tools, **kwargs):
                 yield chunk
@@ -145,6 +146,7 @@ class ResponseBackend(CustomToolAndMCPBackend):
         **kwargs,
     ) -> AsyncGenerator[StreamChunk, None]:
         """Recursively stream MCP responses, executing function calls as needed."""
+
         agent_id = kwargs.get("agent_id")
 
         # Build API params for this iteration

massgen/chat_agent.py

@@ -365,10 +365,15 @@ class ConfigurableAgent(SingleAgent):
             backend: LLM backend
             session_id: Optional session identifier
         """
+        # Extract system message without triggering deprecation warning
+        system_message = None
+        if hasattr(config, "_custom_system_instruction"):
+            system_message = config._custom_system_instruction
+
         super().__init__(
             backend=backend,
             agent_id=config.agent_id,
-            system_message=config.custom_system_instruction,
+            system_message=system_message,
             session_id=session_id,
         )
         self.config = config
@@ -411,8 +416,9 @@ class ConfigurableAgent(SingleAgent):
                 return backend_params["append_system_prompt"]
 
         # Fall back to custom_system_instruction (deprecated but still supported)
-        if self.config and self.config.custom_system_instruction:
-            return self.config.custom_system_instruction
+        # Access private attribute directly to avoid deprecation warning
+        if self.config and hasattr(self.config, "_custom_system_instruction") and self.config._custom_system_instruction:
+            return self.config._custom_system_instruction
 
         # Finally fall back to parent class implementation
         return super().get_configurable_system_message()