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

massgen/message_templates.py

@@ -302,6 +302,8 @@ IMPORTANT: You are responding to the latest message in an ongoing conversation.
         original_system_message: Optional[str] = None,
         enable_image_generation: bool = False,
         enable_audio_generation: bool = False,
+        enable_file_generation: bool = False,
+        enable_video_generation: bool = False,
         has_irreversible_actions: bool = False,
         enable_command_execution: bool = False,
     ) -> str:
@@ -311,6 +313,8 @@ IMPORTANT: You are responding to the latest message in an ongoing conversation.
             original_system_message: The agent's original system message to preserve
             enable_image_generation: Whether image generation is enabled
             enable_audio_generation: Whether audio generation is enabled
+            enable_file_generation: Whether file generation is enabled
+            enable_video_generation: Whether video generation is enabled
             has_irreversible_actions: Whether agent has write access to context paths (requires actual file delivery)
             enable_command_execution: Whether command execution is enabled for this agent
         """
@@ -335,21 +339,165 @@ Present the best possible coordinated answer by combining the strengths from all
         # Add image generation instructions only if enabled
         if enable_image_generation:
             presentation_instructions += """For image generation tasks:
-- Extract image paths from the existing answer and resolve them in the shared reference.
-- Gather all agent-produced images (ignore non-existent files).
-- MUST call the generate-image tool with these input images to synthesize one final image combining their strengths.
-- MUST save the final outputand output the saved path.
-"""
+
+  **MANDATORY WORKFLOW - You MUST follow these steps in order:**
+
+  Step 1: **Check for existing images (REQUIRED)**
+  - First, list all files in the Shared Reference directory (temp_workspaces) to find ALL images from EVERY agent
+  - Look for image files (.png, .jpg, .jpeg, .gif, .webp, etc.) in each agent's workspace subdirectory
+
+  Step 2: **Understand ALL existing images (REQUIRED if images exist)**
+  - For EACH image file you found, you MUST call the **understand_image** tool to extract its key visual elements, composition, style, and quality
+  - Do this for images from yourself AND from other agents - analyze ALL images found
+  - DO NOT skip this step even if you think you know the content
+
+  Step 3: **Synthesize and generate final image (REQUIRED)**
+  - If existing images were found and analyzed:
+    * Synthesize ALL image analyses into a single, detailed, combined prompt
+    * The combined prompt should capture the best visual elements, composition, style, and quality from all analyzed images
+    * Call **image_to_image_generation** with this synthesized prompt and ALL images to create the final unified image
+  - If NO existing images were found:
+    * Generate a new image based directly on the original task requirements
+    * Call **text_to_image_generation** with a prompt derived from the original task
+
+  Step 4: **Save and report (REQUIRED)**
+  - Save the final generated image in your workspace
+  - Report the saved path in your final answer
+
+  **CRITICAL**: You MUST complete Steps 1-4 in order. Do not skip checking for existing images. Do not skip calling
+  understand_image on found images. This is a mandatory synthesis workflow.
+  """
+        #             presentation_instructions += """For image generation tasks:
+        # - Extract image paths from the existing answer and resolve them in the shared reference.
+        # - Gather all agent-produced images (ignore non-existent files).
+        # - IMPORTANT: If you find ANY existing images (from yourself or other agents), you MUST call the understand_image tool
+        #   to analyze EACH image and extract their key visual elements, composition, style, and quality.
+        # - IMPORTANT: Synthesize insights from all analyzed images into a detailed, combined prompt that captures the best elements.
+        # - IMPORTANT: Call text_to_image_generation with this synthesized prompt to generate the final image.
+        # - IMPORTANT: Save the final output in your workspace and output the saved path.
+        # - If no existing images are found, generate based on the original task requirements.
+        # """
         # Add audio generation instructions only if enabled
         if enable_audio_generation:
             presentation_instructions += """For audio generation tasks:
-- Extract audio paths from the existing answer and resolve them in the shared reference.
-- Gather ALL audio files produced by EVERY agent (ignore non-existent files).
-  IMPORTANT: You MUST call the generate_text_with_input_audio tool to obtain transcriptions
-  for EACH AND EVERY audio file from ALL agents - no audio should be skipped or overlooked.
-- MUST combine the strengths of all transcriptions into one final detailed transcription that captures the best elements from each.
-- MUST use the convert_text_to_audio tool to convert this final transcription to a new audio file and save it, then output the saved path.
-"""
+
+  **MANDATORY WORKFLOW - You MUST follow these steps in order:**
+
+  Step 1: **Check for existing audios (REQUIRED)**
+  - First, list all files in the Shared Reference directory (temp_workspaces) to find ALL audio files from EVERY agent
+  - Look for audio files (.mp3, .wav, .flac, etc.) in each agent's workspace subdirectory
+
+  Step 2: **Understand ALL existing audios (REQUIRED if audios exist)**
+  - For EACH audio file you found, you MUST call the **understand_audio** tool to extract its transcription
+  - Do this for audios from yourself AND from other agents - analyze ALL audios found
+  - DO NOT skip this step even if you think you know the content
+
+  Step 3: **Synthesize and generate final audio (REQUIRED)**
+  - If existing audios were found and analyzed:
+    * Synthesize ALL audio transcriptions into a single, detailed, combined transcription
+    * The combined transcription should capture the best content from all analyzed audios
+    * Call **text_to_speech_transcription_generation** with this synthesized transcription to create the final unified audio
+  - If NO existing audios were found:
+    * Generate a new audio based directly on the original task requirements
+    * Call **text_to_speech_transcription_generation** with a transcription derived from the original task
+
+  Step 4: **Save and report (REQUIRED)**
+  - Save the final generated audio in your workspace
+  - Report the saved path in your final answer
+
+  **CRITICAL**: You MUST complete Steps 1-4 in order. Do not skip checking for existing audios. Do not skip calling
+  understand_audio on found audios. This is a mandatory synthesis workflow.
+  """
+        #                         presentation_instructions += """For audio generation tasks:
+        # - Extract audio paths from the existing answer and resolve them in the shared reference.
+        # - Gather ALL audio files produced by EVERY agent (ignore non-existent files).
+        # - IMPORTANT: If you find ANY existing audios (from yourself or other agents), you MUST call the **understand_audio** tool to extract each audio's transcription.
+        # - IMPORTANT: Synthesize transcriptions from all audios into a detailed, combined transcription.
+        # - IMPORTANT: You MUST call the **text_to_speech_transcription_generation** tool with this synthesized transcription to generate the final audio.
+        # - IMPORTANT: Save the final output in your workspace and output the saved path.
+        # - If no existing audios are found, generate based on the original task requirements.
+        # """
+        # Add file generation instructions only if enabled
+        if enable_file_generation:
+            presentation_instructions += """For file generation tasks:
+
+  **MANDATORY WORKFLOW - You MUST follow these steps in order:**
+
+  Step 1: **Check for existing files (REQUIRED)**
+  - First, list all files in the Shared Reference directory (temp_workspaces) to find ALL files from EVERY agent
+  - Look for files of the requested type in each agent's workspace subdirectory
+
+  Step 2: **Understand ALL existing files (REQUIRED if files exist)**
+  - For EACH file you found, you MUST call the **understand_file** tool to extract its content, structure, and key elements
+  - Do this for files from yourself AND from other agents - analyze ALL files found
+  - DO NOT skip this step even if you think you know the content
+
+  Step 3: **Synthesize and generate final file (REQUIRED)**
+  - If existing files were found and analyzed:
+    * Synthesize ALL file contents into a single, detailed, combined content
+    * The combined content should capture the best elements, structure, and information from all analyzed files
+    * Call **text_to_file_generation** with this synthesized content to generate the final unified file
+  - If NO existing files were found:
+    * Generate a new file based directly on the original task requirements
+    * Call **text_to_file_generation** with content derived from the original task
+
+  Step 4: **Save and report (REQUIRED)**
+  - Save the final generated file in your workspace
+  - Report the saved path in your final answer
+
+  **CRITICAL**: You MUST complete Steps 1-4 in order. Do not skip checking for existing files. Do not skip calling
+  understand_file on found files. This is a mandatory synthesis workflow.
+  """
+        #             presentation_instructions += """For file generation tasks:
+        # - Extract file paths from the existing answer and resolve them in the shared reference.
+        # - Gather ALL files produced by EVERY agent (ignore non-existent files).
+        # - IMPORTANT: If you find ANY existing files (from yourself or other agents), you MUST call the **understand_file** tool to extract each file's content.
+        # - IMPORTANT: Synthesize contents from all files into a detailed, combined content.
+        # - IMPORTANT: You MUST call the **text_to_file_generation** tool with this synthesized content to generate the final file.
+        # - IMPORTANT: Save the final output in your workspace and output the saved path.
+        # - If no existing files are found, generate based on the original task requirements.
+        # """
+        # Add video generation instructions only if enabled
+        if enable_video_generation:
+            presentation_instructions += """For video generation tasks:
+
+  **MANDATORY WORKFLOW - You MUST follow these steps in order:**
+
+  Step 1: **Check for existing videos (REQUIRED)**
+  - First, list all files in the Shared Reference directory (temp_workspaces) to find ALL videos from EVERY agent
+  - Look for video files (.mp4, .avi, .mov, etc.) in each agent's workspace subdirectory
+
+  Step 2: **Understand ALL existing videos (REQUIRED if videos exist)**
+  - For EACH video file you found, you MUST call the **understand_video** tool to extract its description, visual features, and
+  key elements
+  - Do this for videos from yourself AND from other agents - analyze ALL videos found
+  - DO NOT skip this step even if you think you know the content
+
+  Step 3: **Synthesize and generate final video (REQUIRED)**
+  - If existing videos were found and analyzed:
+    * Synthesize ALL video descriptions into a single, detailed, combined prompt
+    * The combined prompt should capture the best visual elements, composition, motion, and style from all analyzed videos
+    * Call **text_to_video_generation** with this synthesized prompt to create the final unified video
+  - If NO existing videos were found:
+    * Generate a new video based directly on the original task requirements
+    * Call **text_to_video_generation** with a prompt derived from the original task
+
+  Step 4: **Save and report (REQUIRED)**
+  - Save the final generated video in your workspace
+  - Report the saved path in your final answer
+
+  **CRITICAL**: You MUST complete Steps 1-4 in order. Do not skip checking for existing videos. Do not skip calling
+  understand_video on found videos. This is a mandatory synthesis workflow.
+  """
+        #             presentation_instructions += """For video generation tasks:
+        # - Extract video paths from the existing answer and resolve them in the shared reference.
+        # - Gather ALL videos produced by EVERY agent (ignore non-existent files).
+        # - IMPORTANT: If you find ANY existing videos (from yourself or other agents), you MUST call the **understand_video** tool to extract each video's description and key features.
+        # - IMPORTANT: Synthesize descriptions from all videos into a detailed, combined prompt capturing the best elements.
+        # - IMPORTANT: You MUST call the **text_to_video_generation** tool with this synthesized prompt to generate the final video.
+        # - IMPORTANT: Save the final output in your workspace and output the saved path.
+        # - If no existing videos are found, generate based on the original task requirements.
+        # """
 
         # Add irreversible actions reminder if needed
         # TODO: Integrate more general irreversible actions handling in future (i.e., not just for context file delivery)
@@ -378,6 +526,93 @@ Present the best possible coordinated answer by combining the strengths from all
         else:
             return presentation_instructions
 
+    def post_evaluation_system_message(
+        self,
+        original_system_message: Optional[str] = None,
+    ) -> str:
+        """System message for post-evaluation phase after final presentation.
+
+        The winning agent evaluates its own answer with a fresh perspective and decides
+        whether to submit or restart with specific improvement instructions.
+
+        Args:
+            original_system_message: The agent's original system message to preserve
+        """
+        if "post_evaluation_system_message" in self._template_overrides:
+            return str(self._template_overrides["post_evaluation_system_message"])
+
+        evaluation_instructions = """## Post-Presentation Evaluation
+
+You have just presented a final answer to the user. Now you must evaluate whether your answer fully addresses the original task.
+
+**Your Task:**
+Review the final answer that was presented and determine if it completely and accurately addresses the original task requirements.
+
+**Available Tools:**
+You have access to the same filesystem and MCP tools that were available during presentation. Use these tools to:
+- Verify that claimed files actually exist in the workspace
+- Check file contents to confirm they match what was described
+- Validate any technical claims or implementations
+
+**Decision:**
+You must call ONE of these tools:
+
+1. **submit(confirmed=True)** - Use this when:
+   - The answer fully addresses ALL parts of the original task
+   - All claims in the answer are accurate and verified
+   - The work is complete and ready for the user
+
+2. **restart_orchestration(reason, instructions)** - Use this when:
+   - The answer is incomplete (missing required elements)
+   - The answer contains errors or inaccuracies
+   - Important aspects of the task were not addressed
+
+   Provide:
+   - **reason**: Clear explanation of what's wrong (e.g., "The task required descriptions of two Beatles, but only John Lennon was described")
+   - **instructions**: Detailed, actionable guidance for the next attempt (e.g.,
+     "Provide two descriptions (John Lennon AND Paul McCartney). Each should include:
+     birth year, role in band, notable songs, impact on music. Use 4-6 sentences per person.")
+
+**Important Notes:**
+- Be honest and thorough in your evaluation
+- You are evaluating your own work with a fresh perspective
+- If you find problems, restarting with clear instructions will lead to a better result
+- The restart process gives you another opportunity to get it right
+"""
+
+        # Combine with original system message if provided
+        if original_system_message:
+            return f"""{original_system_message}
+
+{evaluation_instructions}"""
+        else:
+            return evaluation_instructions
+
+    def format_restart_context(self, reason: str, instructions: str) -> str:
+        """Format restart context for subsequent orchestration attempts.
+
+        This context is added to agent messages (like multi-turn context) on restart attempts.
+
+        Args:
+            reason: Why the previous attempt was insufficient
+            instructions: Detailed guidance for improvement
+        """
+        if "format_restart_context" in self._template_overrides:
+            override = self._template_overrides["format_restart_context"]
+            if callable(override):
+                return override(reason, instructions)
+            return str(override).format(reason=reason, instructions=instructions)
+
+        return f"""<PREVIOUS ATTEMPT FEEDBACK>
+The previous orchestration attempt was restarted because:
+{reason}
+
+**Instructions for this attempt:**
+{instructions}
+
+Please address these specific issues in your coordination and final answer.
+<END OF PREVIOUS ATTEMPT FEEDBACK>"""
+
     # =============================================================================
     # COMPLETE MESSAGE BUILDERS
     # =============================================================================
@@ -509,10 +744,36 @@ Based on the coordination process above, present your final answer:"""
         messages.append({"role": "user", "content": self.enforcement_message()})
         return messages
 
-    def command_execution_system_message(self) -> str:
-        """Generate concise command execution instructions when command line execution is enabled."""
+    def command_execution_system_message(
+        self,
+        docker_mode: bool = False,
+        enable_sudo: bool = False,
+    ) -> str:
+        """Generate concise command execution instructions when command line execution is enabled.
+
+        Args:
+            docker_mode: Whether commands execute in Docker containers
+            enable_sudo: Whether sudo is available in Docker containers
+        """
         parts = ["## Command Execution"]
         parts.append("You can run command line commands using the `execute_command` tool.\n")
+
+        if docker_mode:
+            parts.append("**IMPORTANT: Docker Execution Environment**")
+            parts.append("- You are running in a Linux Docker container (Debian-based)")
+            parts.append("- Base image: Python 3.11-slim with Node.js 20.x")
+            parts.append("- Pre-installed: git, curl, build-essential, pytest, requests, numpy, pandas")
+            parts.append("- Use `apt-get` for system packages (NOT brew, dnf, yum, etc.)")
+
+            if enable_sudo:
+                parts.append("- **Sudo is available**: You can install packages with `sudo apt-get install <package>`")
+                parts.append("- Example: `sudo apt-get update && sudo apt-get install -y ffmpeg`")
+            else:
+                parts.append("- Sudo is NOT available - use pip/npm for user-level packages only")
+                parts.append("- For system packages, ask the user to rebuild the Docker image with needed packages")
+
+            parts.append("")
+
         parts.append("If a `.venv` directory exists in your workspace, it will be automatically used.")
 
         return "\n".join(parts)
@@ -527,6 +788,8 @@ Based on the coordination process above, present your final answer:"""
         enable_image_generation: bool = False,
         agent_answers: Optional[Dict[str, str]] = None,
         enable_command_execution: bool = False,
+        docker_mode: bool = False,
+        enable_sudo: bool = False,
     ) -> str:
         """Generate filesystem access instructions for agents with filesystem support.
 
@@ -539,6 +802,8 @@ Based on the coordination process above, present your final answer:"""
             enable_image_generation: Whether image generation is enabled
             agent_answers: Dict of agent answers (keys are agent IDs) to show workspace structure
             enable_command_execution: Whether command line execution is enabled
+            docker_mode: Whether commands execute in Docker containers
+            enable_sudo: Whether sudo is available in Docker containers
         """
         if "filesystem_system_message" in self._template_overrides:
             return str(self._template_overrides["filesystem_system_message"])
@@ -704,7 +969,10 @@ Based on the coordination process above, present your final answer:"""
 
         # Add command execution instructions if enabled
         if enable_command_execution:
-            command_exec_message = self.command_execution_system_message()
+            command_exec_message = self.command_execution_system_message(
+                docker_mode=docker_mode,
+                enable_sudo=enable_sudo,
+            )
             parts.append(f"\n{command_exec_message}")
 
         return "\n".join(parts)