massgen 0.1.0a3__py3-none-any.whl → 0.1.2__py3-none-any.whl

massgen/configs/tools/planning/five_agents_discord_mcp_planning_mode.yaml

@@ -28,11 +28,9 @@ agents:
             DISCORD_TOKEN: "${DISCORD_TOKEN}"
           security:
             level: "high"
-    system_message: |
-      Available Discord Tools:
-      - Discord server interaction via MCP integration
-      - Message reading, sending, and management
-      - Channel and server information access
+      exclude_tools:
+        - mcp__discord__discord_send_webhook_message
+        - mcp__discord__discord_edit_webhook_message
 
   - id: "openai_discord_agent"
     backend:
@@ -50,11 +48,6 @@ agents:
       exclude_tools:
         - mcp__discord__discord_send_webhook_message
         - mcp__discord__discord_edit_webhook_message
-    system_message: |
-      Available Discord Tools:
-      - Discord server interaction via MCP integration
-      - Message reading, sending, and management
-      - Channel and server information access
 
   - id: "claude_code_discord_agent"
     backend:
@@ -68,11 +61,6 @@ agents:
           args: ["-y", "mcp-discord", "--config", "${DISCORD_TOKEN}"]
           env:
             DISCORD_TOKEN: "${DISCORD_TOKEN}"
-    system_message: |
-      Available Discord Tools:
-      - Discord server interaction via MCP integration
-      - Message reading, sending, and management
-      - Channel and server information access
 
   - id: "claude_discord_agent"
     backend:
@@ -90,11 +78,6 @@ agents:
       exclude_tools:
         - mcp__discord__discord_send_webhook_message
         - mcp__discord__discord_edit_webhook_message
-    system_message: |
-      Available Discord Tools:
-      - Discord server interaction via MCP integration
-      - Message reading, sending, and management
-      - Channel and server information access
 
   - id: "grok_discord_agent"
     backend:
@@ -112,11 +95,6 @@ agents:
       exclude_tools:
         - mcp__discord__discord_send_webhook_message
         - mcp__discord__discord_edit_webhook_message
-    system_message: |
-      Available Discord Tools:
-      - Discord server interaction via MCP integration
-      - Message reading, sending, and management
-      - Channel and server information access
 
 ui:
   display_type: "rich_terminal"
@@ -124,8 +102,8 @@ ui:
 
 # Orchestrator Settings with Coordination Configuration
 orchestrator:
-  snapshot_storage: "massgen_logs/snapshots"  # Directory for workspace snapshots
-  agent_temporary_workspace: "massgen_logs/temp_workspaces"  # Directory for temporary agent workspaces
+  snapshot_storage: "snapshots"  # Directory for workspace snapshots
+  agent_temporary_workspace: "temp_workspaces"  # Directory for temporary agent workspaces
   coordination:
     enable_planning_mode: true
     planning_mode_instruction: |
@@ -134,7 +112,7 @@ orchestrator:
       1. Describe your intended actions and reasoning
       2. Analyze other agents' proposals
       3. Use only the 'vote' or 'new_answer' tools for coordination
-      4. DO NOT execute any actual Discord commands or API calls
-      5. Save tool execution for the final presentation phase when the winning agent will implement the plan
+      4. Execute read-only actions - DO NOT execute any actions that have side effects (e.g., sending messages, modifying data)
+      5. Save actions that have side effects for the final presentation phase when the winning agent will implement the plan
 
       Focus on planning, analysis, and coordination rather than execution.

massgen/configs/tools/planning/five_agents_filesystem_mcp_planning_mode.yaml

@@ -134,8 +134,8 @@ ui:
 
 # Orchestrator Settings with Coordination Configuration
 orchestrator:
-  snapshot_storage: "massgen_logs/snapshots"  # Directory for workspace snapshots
-  agent_temporary_workspace: "massgen_logs/temp_workspaces"  # Directory for temporary agent workspaces
+  snapshot_storage: "snapshots"  # Directory for workspace snapshots
+  agent_temporary_workspace: "temp_workspaces"  # Directory for temporary agent workspaces
   coordination:
     enable_planning_mode: true
     planning_mode_instruction: |
@@ -144,8 +144,7 @@ orchestrator:
       1. Describe your intended file operations and reasoning
       2. Analyze other agents' proposals for the filesystem tasks
       3. Use only the 'vote' or 'new_answer' tools for coordination
-      4. DO NOT execute any actual filesystem operations, file creation, or directory management
-      5. Save all file operations for the final presentation phase when the winning agent will implement the plan
+      4. Execute read-only actions - DO NOT execute any actions that have side effects (e.g., sending messages, modifying data)
+      5. Save actions that have side effects for the final presentation phase when the winning agent will implement the plan
 
-      Focus on planning, analysis, and coordination rather than execution.
-      Example: "I would create a 'src' directory and write a main.py file..." rather than actually creating them.
+      Focus on planning, analysis, and coordination rather than execution.

massgen/configs/tools/planning/five_agents_notion_mcp_planning_mode.yaml

@@ -135,8 +135,8 @@ ui:
 
 # Orchestrator Settings with Coordination Configuration
 orchestrator:
-  snapshot_storage: "massgen_logs/snapshots"  # Directory for workspace snapshots
-  agent_temporary_workspace: "massgen_logs/temp_workspaces"  # Directory for temporary agent workspaces
+  snapshot_storage: "snapshots"  # Directory for workspace snapshots
+  agent_temporary_workspace: "temp_workspaces"  # Directory for temporary agent workspaces
   coordination:
     enable_planning_mode: true
     planning_mode_instruction: |
@@ -145,7 +145,7 @@ orchestrator:
       1. Describe your intended actions and reasoning
       2. Analyze other agents' proposals
       3. Use only the 'vote' or 'new_answer' tools for coordination
-      4. DO NOT execute any actual Notion commands or API calls
-      5. Save tool execution for the final presentation phase when the winning agent will implement the plan
+      4. Execute read-only actions - DO NOT execute any actions that have side effects (e.g., sending messages, modifying data)
+      5. Save actions that have side effects for the final presentation phase when the winning agent will implement the plan
 
       Focus on planning, analysis, and coordination rather than execution.

massgen/configs/tools/planning/five_agents_twitter_mcp_planning_mode.yaml

@@ -139,8 +139,8 @@ ui:
 
 # Orchestrator Settings with Coordination Configuration
 orchestrator:
-  snapshot_storage: "massgen_logs/snapshots"  # Directory for workspace snapshots
-  agent_temporary_workspace: "massgen_logs/temp_workspaces"  # Directory for temporary agent workspaces
+  snapshot_storage: "snapshots"  # Directory for workspace snapshots
+  agent_temporary_workspace: "temp_workspaces"  # Directory for temporary agent workspaces
   coordination:
     enable_planning_mode: true
     planning_mode_instruction: |
@@ -149,7 +149,7 @@ orchestrator:
       1. Describe your intended actions and reasoning
       2. Analyze other agents' proposals
       3. Use only the 'vote' or 'new_answer' tools for coordination
-      4. DO NOT execute any actual Twitter commands or API calls
-      5. Save tool execution for the final presentation phase when the winning agent will implement the plan
+      4. Execute read-only actions - DO NOT execute any actions that have side effects (e.g., sending messages, modifying data)
+      5. Save actions that have side effects for the final presentation phase when the winning agent will implement the plan
 
       Focus on planning, analysis, and coordination rather than execution.

massgen/configs/tools/planning/gpt5_mini_case_study_mcp_planning_mode.yaml

@@ -67,7 +67,7 @@ orchestrator:
       2. Analyze other agents' proposals
       3. Use only the 'vote' or 'new_answer' tools for coordination
       4. You CAN use web search for information gathering
-      5. DO NOT execute Discord operations (sending messages, reading channels, etc.) - save these for execution phase
-      6. Save tool execution for the final presentation phase when the winning agent will implement the plan
+      5. DO NOT execute any actions that have side effects (e.g., sending messages, modifying data)
+      6. Save actions that have side effects for the final presentation phase when the winning agent will implement the plan
 
       Focus on planning, analysis, and coordination rather than execution.

massgen/configs/voting/gemini_gpt_voting_sensitivity.yaml

@@ -0,0 +1,67 @@
+# MassGen Voting Sensitivity Configuration Example
+#
+# How to run:
+#   massgen --config configs/voting/gemini_gpt_voting_sensitivity.yaml "Your question here"
+#
+# Or in interactive mode:
+#   massgen --config configs/voting/gemini_gpt_voting_sensitivity.yaml
+#
+# Try different sensitivity levels by changing the voting_sensitivity value below
+
+agents:
+  - id: "gemini2.5flash"
+    backend:
+      type: "gemini"
+      model: "gemini-2.5-flash"
+      enable_web_search: true
+
+  - id: "gpt5nano"
+    backend:
+      type: "openai"
+      model: "gpt-5-nano"
+      text:
+        verbosity: "medium"
+      reasoning:
+        effort: "medium"
+        summary: "auto"
+      enable_web_search: true
+      enable_code_interpreter: true
+
+orchestrator:
+  # voting_sensitivity controls how critical agents are when evaluating answers
+  #
+  # Options:
+  #   - "lenient" (default): Agents vote for existing answers more readily, fewer new answers
+  #                          Use when you want faster convergence
+  #
+  #   - "balanced": Agents apply detailed criteria (comprehensive, accurate, complete?) before voting,
+  #                 more new answers. Use when you want thorough evaluation
+  #
+  #   - "strict": Agents apply high standards of excellence (all aspects, edge cases, reference-quality) before voting,
+  #               most new answers. Use when you need maximum quality
+  #
+  voting_sensitivity: "balanced"
+
+  # max_new_answers_per_agent controls how many new answers each agent can provide
+  # Once an agent reaches this limit, they can only vote (not provide new answers)
+  #
+  # Options:
+  #   - null (default): No limit - agents can provide unlimited new answers
+  #   - 1, 2, 3, etc.: Cap the number of new answers per agent
+  #
+  # Example: Set to 2 for thorough evaluation but bounded duration
+  max_new_answers_per_agent: 2
+
+  # answer_novelty_requirement controls how different new answers must be from existing ones
+  #
+  # Options:
+  #   - "lenient" (default): No additional checks - current behavior (fastest)
+  #   - "balanced": Reject if >70% token overlap - requires meaningful differences
+  #   - "strict": Reject if >50% token overlap - requires substantially different solutions
+  #
+  # Example: Use "balanced" to prevent agents from just rephrasing the same answer
+  answer_novelty_requirement: "balanced"
+
+ui:
+  display_type: "rich_terminal"
+  logging_enabled: true

massgen/formatter/_chat_completions_formatter.py

@@ -258,6 +258,110 @@ class ChatCompletionsFormatter(FormatterBase):
 
         return converted_tools
 
+    def format_custom_tools(self, custom_tools: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """
+        Convert custom tools from RegisteredToolEntry format to Chat Completions API format.
+
+        Custom tools are provided as a dictionary where:
+        - Keys are tool names (str)
+        - Values are RegisteredToolEntry objects with:
+          - tool_name: str
+          - schema_def: dict with structure {"type": "function", "function": {...}}
+          - get_extended_schema: property that returns the schema with extensions
+
+        Chat Completions API expects: {"type": "function", "function": {"name": ..., "description": ..., "parameters": ...}}
+
+        Args:
+            custom_tools: Dictionary of tool_name -> RegisteredToolEntry objects
+
+        Returns:
+            List of tools in Chat Completions API format
+        """
+        if not custom_tools:
+            return []
+
+        converted_tools = []
+
+        # Handle dictionary format: {tool_name: RegisteredToolEntry, ...}
+        if isinstance(custom_tools, dict):
+            for tool_name, tool_entry in custom_tools.items():
+                # Check if it's a RegisteredToolEntry object with schema_def
+                if hasattr(tool_entry, "schema_def"):
+                    tool_schema = tool_entry.schema_def
+
+                    # Schema may already be in Chat Completions format
+                    if tool_schema.get("type") == "function" and "function" in tool_schema:
+                        # Already in correct format, just append
+                        converted_tools.append(tool_schema)
+                    elif tool_schema.get("type") == "function":
+                        # Response API format, need to wrap in function object
+                        converted_tools.append(
+                            {
+                                "type": "function",
+                                "function": {
+                                    "name": tool_schema.get("name", tool_entry.tool_name if hasattr(tool_entry, "tool_name") else tool_name),
+                                    "description": tool_schema.get("description", ""),
+                                    "parameters": tool_schema.get("parameters", {}),
+                                },
+                            },
+                        )
+                # Check if it has get_extended_schema property
+                elif hasattr(tool_entry, "get_extended_schema"):
+                    tool_schema = tool_entry.get_extended_schema
+
+                    if tool_schema.get("type") == "function" and "function" in tool_schema:
+                        # Already in correct format
+                        converted_tools.append(tool_schema)
+                    elif tool_schema.get("type") == "function":
+                        # Response API format, need to wrap
+                        converted_tools.append(
+                            {
+                                "type": "function",
+                                "function": {
+                                    "name": tool_schema.get("name", tool_entry.tool_name if hasattr(tool_entry, "tool_name") else tool_name),
+                                    "description": tool_schema.get("description", ""),
+                                    "parameters": tool_schema.get("parameters", {}),
+                                },
+                            },
+                        )
+        # Handle list format for backward compatibility
+        elif isinstance(custom_tools, list):
+            for tool in custom_tools:
+                if hasattr(tool, "schema_def"):
+                    tool_schema = tool.schema_def
+
+                    if tool_schema.get("type") == "function" and "function" in tool_schema:
+                        converted_tools.append(tool_schema)
+                    elif tool_schema.get("type") == "function":
+                        converted_tools.append(
+                            {
+                                "type": "function",
+                                "function": {
+                                    "name": tool_schema.get("name", tool.tool_name),
+                                    "description": tool_schema.get("description", ""),
+                                    "parameters": tool_schema.get("parameters", {}),
+                                },
+                            },
+                        )
+                elif hasattr(tool, "get_extended_schema"):
+                    tool_schema = tool.get_extended_schema
+
+                    if tool_schema.get("type") == "function" and "function" in tool_schema:
+                        converted_tools.append(tool_schema)
+                    elif tool_schema.get("type") == "function":
+                        converted_tools.append(
+                            {
+                                "type": "function",
+                                "function": {
+                                    "name": tool_schema.get("name", tool.tool_name),
+                                    "description": tool_schema.get("description", ""),
+                                    "parameters": tool_schema.get("parameters", {}),
+                                },
+                            },
+                        )
+
+        return converted_tools
+
     def format_mcp_tools(self, mcp_functions: Dict[str, Any]) -> List[Dict[str, Any]]:
         """Convert MCP tools to Chat Completions format."""
         if not mcp_functions:

massgen/formatter/_claude_formatter.py

@@ -233,3 +233,123 @@ class ClaudeFormatter(FormatterBase):
             converted_tools.append(tool)
 
         return converted_tools
+
+    def format_custom_tools(self, custom_tools: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """
+        Convert custom tools from RegisteredToolEntry format to Claude's custom tool format.
+
+        Custom tools are provided as a dictionary where:
+        - Keys are tool names (str)
+        - Values are RegisteredToolEntry objects with:
+          - tool_name: str
+          - schema_def: dict with structure {"type": "function", "function": {...}}
+          - get_extended_schema: property that returns the schema with extensions
+
+        Claude expects: {"type": "custom", "name": ..., "description": ..., "input_schema": ...}
+
+        Args:
+            custom_tools: Dictionary of tool_name -> RegisteredToolEntry objects
+
+        Returns:
+            List of tools in Claude's custom tool format
+        """
+        if not custom_tools:
+            return []
+
+        converted_tools = []
+
+        # Handle dictionary format: {tool_name: RegisteredToolEntry, ...}
+        if isinstance(custom_tools, dict):
+            for tool_name, tool_entry in custom_tools.items():
+                # Check if it's a RegisteredToolEntry object with schema_def
+                if hasattr(tool_entry, "schema_def"):
+                    tool_schema = tool_entry.schema_def
+
+                    # Extract function details from Chat Completions format
+                    if tool_schema.get("type") == "function" and "function" in tool_schema:
+                        func = tool_schema["function"]
+                        converted_tools.append(
+                            {
+                                "type": "custom",
+                                "name": func.get("name", tool_entry.tool_name if hasattr(tool_entry, "tool_name") else tool_name),
+                                "description": func.get("description", ""),
+                                "input_schema": func.get("parameters", {}),
+                            },
+                        )
+                    elif tool_schema.get("type") == "function":
+                        # Response API format - already has name, description, parameters at top level
+                        converted_tools.append(
+                            {
+                                "type": "custom",
+                                "name": tool_schema.get("name", tool_entry.tool_name if hasattr(tool_entry, "tool_name") else tool_name),
+                                "description": tool_schema.get("description", ""),
+                                "input_schema": tool_schema.get("parameters", {}),
+                            },
+                        )
+                    else:
+                        # Unknown format, try to extract what we can
+                        converted_tools.append(
+                            {
+                                "type": "custom",
+                                "name": tool_entry.tool_name if hasattr(tool_entry, "tool_name") else tool_name,
+                                "description": tool_schema.get("description", ""),
+                                "input_schema": tool_schema.get("parameters", {}),
+                            },
+                        )
+                # Handle direct schema format (for backward compatibility)
+                elif isinstance(tool_entry, dict):
+                    if tool_entry.get("type") == "function" and "function" in tool_entry:
+                        # Chat Completions format
+                        func = tool_entry["function"]
+                        converted_tools.append(
+                            {
+                                "type": "custom",
+                                "name": func.get("name", tool_name),
+                                "description": func.get("description", ""),
+                                "input_schema": func.get("parameters", {}),
+                            },
+                        )
+                    elif tool_entry.get("type") == "function":
+                        # Response API format
+                        converted_tools.append(
+                            {
+                                "type": "custom",
+                                "name": tool_entry.get("name", tool_name),
+                                "description": tool_entry.get("description", ""),
+                                "input_schema": tool_entry.get("parameters", {}),
+                            },
+                        )
+                    else:
+                        # Already in Claude format or unknown
+                        converted_tools.append(tool_entry)
+
+        # Handle list format (if custom_tools is already a list)
+        elif isinstance(custom_tools, list):
+            for tool in custom_tools:
+                if isinstance(tool, dict):
+                    if tool.get("type") == "function" and "function" in tool:
+                        # Chat Completions format
+                        func = tool["function"]
+                        converted_tools.append(
+                            {
+                                "type": "custom",
+                                "name": func.get("name", ""),
+                                "description": func.get("description", ""),
+                                "input_schema": func.get("parameters", {}),
+                            },
+                        )
+                    elif tool.get("type") == "function":
+                        # Response API format
+                        converted_tools.append(
+                            {
+                                "type": "custom",
+                                "name": tool.get("name", ""),
+                                "description": tool.get("description", ""),
+                                "input_schema": tool.get("parameters", {}),
+                            },
+                        )
+                    else:
+                        # Already in Claude format or unknown
+                        converted_tools.append(tool)
+
+        return converted_tools