massgen 0.1.0a3__py3-none-any.whl → 0.1.2__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.0a3"
+__version__ = "0.1.2"
 __author__ = "MassGen Contributors"
 
 

massgen/agent_config.py

@@ -58,6 +58,9 @@ class AgentConfig:
         timeout_config: Timeout and resource limit configuration
         coordination_config: Coordination behavior configuration (e.g., planning mode)
         skip_coordination_rounds: Debug/test mode - skip voting rounds and go straight to final presentation (default: False)
+        voting_sensitivity: Controls how critical agents are when voting ("lenient", "balanced", "strict")
+        max_new_answers_per_agent: Maximum number of new answers each agent can provide (None = unlimited)
+        answer_novelty_requirement: How different new answers must be from existing ones ("lenient", "balanced", "strict")
     """
 
     # Core backend configuration (includes tool enablement)
@@ -66,6 +69,11 @@ class AgentConfig:
     # Framework configuration
     message_templates: Optional["MessageTemplates"] = None
 
+    # Voting behavior configuration
+    voting_sensitivity: str = "lenient"
+    max_new_answers_per_agent: Optional[int] = None
+    answer_novelty_requirement: str = "lenient"
+
     # Agent customization
     agent_id: Optional[str] = None
     _custom_system_instruction: Optional[str] = field(default=None, init=False)
@@ -696,6 +704,9 @@ class AgentConfig:
             "backend_params": self.backend_params,
             "agent_id": self.agent_id,
             "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,
             "timeout_config": {
                 "orchestrator_timeout_seconds": self.timeout_config.orchestrator_timeout_seconds,
             },
@@ -730,6 +741,9 @@ class AgentConfig:
         backend_params = data.get("backend_params", {})
         agent_id = data.get("agent_id")
         custom_system_instruction = data.get("custom_system_instruction")
+        voting_sensitivity = data.get("voting_sensitivity", "lenient")
+        max_new_answers_per_agent = data.get("max_new_answers_per_agent")
+        answer_novelty_requirement = data.get("answer_novelty_requirement", "lenient")
 
         # Handle timeout_config
         timeout_config = TimeoutConfig()
@@ -756,6 +770,9 @@ class AgentConfig:
             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,
         )

massgen/api_params_handler/_api_params_handler_base.py

@@ -21,6 +21,7 @@ class APIParamsHandlerBase(ABC):
         """
         self.backend = backend_instance
         self.formatter = backend_instance.formatter
+        self.custom_tool_manager = backend_instance.custom_tool_manager
 
     @abstractmethod
     async def build_api_params(

massgen/api_params_handler/_chat_completions_api_params_handler.py

@@ -23,6 +23,7 @@ class ChatCompletionsAPIParamsHandler(APIParamsHandlerBase):
                 "enable_code_interpreter",
                 "allowed_tools",
                 "exclude_tools",
+                "custom_tools",  # Custom tools configuration (processed separately)
             },
         )
 
@@ -30,7 +31,13 @@ class ChatCompletionsAPIParamsHandler(APIParamsHandlerBase):
         """Get provider tools for Chat Completions format."""
         provider_tools = []
 
-        if all_params.get("enable_web_search", False):
+        # Check if this is Grok backend - Grok uses extra_body.search_parameters instead of function tools
+        backend_provider = getattr(self.backend, "get_provider_name", lambda: "")()
+        is_grok = backend_provider.lower() == "grok"
+
+        # Add web_search function tool for non-Grok backends
+        # Grok handles web search via extra_body.search_parameters (set in grok.py)
+        if all_params.get("enable_web_search", False) and not is_grok:
             provider_tools.append(
                 {
                     "type": "function",
@@ -114,11 +121,17 @@ class ChatCompletionsAPIParamsHandler(APIParamsHandlerBase):
         if provider_tools:
             combined_tools.extend(provider_tools)
 
-        # User-defined tools
+        # Workflow tools
         if tools:
             converted_tools = self.formatter.format_tools(tools)
             combined_tools.extend(converted_tools)
 
+        # Add custom tools
+        custom_tools = self.custom_tool_manager.registered_tools
+        if custom_tools:
+            converted_custom_tools = self.formatter.format_custom_tools(custom_tools)
+            combined_tools.extend(converted_custom_tools)
+
         # MCP tools
         mcp_tools = self.get_mcp_tools()
         if mcp_tools:

massgen/api_params_handler/_claude_api_params_handler.py

@@ -22,6 +22,7 @@ class ClaudeAPIParamsHandler(APIParamsHandlerBase):
                 "enable_code_execution",
                 "allowed_tools",
                 "exclude_tools",
+                "custom_tools",  # Custom tools configuration (processed separately)
                 "_has_files_api_files",
             },
         )
@@ -97,11 +98,17 @@ class ClaudeAPIParamsHandler(APIParamsHandlerBase):
         if provider_tools:
             combined_tools.extend(provider_tools)
 
-        # User-defined tools
+        # Workflow tools
         if tools:
             converted_tools = self.formatter.format_tools(tools)
             combined_tools.extend(converted_tools)
 
+        # Add custom tools
+        custom_tools = self.custom_tool_manager.registered_tools
+        if custom_tools:
+            converted_custom_tools = self.formatter.format_custom_tools(custom_tools)
+            combined_tools.extend(converted_custom_tools)
+
         # MCP tools
         mcp_tools = self.get_mcp_tools()
         if mcp_tools:

massgen/api_params_handler/_gemini_api_params_handler.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+"""
+Gemini API parameters handler building SDK config with parameter mapping and exclusions.
+"""
+
+from typing import Any, Dict, List, Set
+
+from ._api_params_handler_base import APIParamsHandlerBase
+
+
+class GeminiAPIParamsHandler(APIParamsHandlerBase):
+    def get_excluded_params(self) -> Set[str]:
+        base = self.get_base_excluded_params()
+        extra = {
+            "enable_web_search",
+            "enable_code_execution",
+            "use_multi_mcp",
+            "mcp_sdk_auto",
+            "allowed_tools",
+            "exclude_tools",
+            "custom_tools",
+        }
+        return set(base) | extra
+
+    def get_provider_tools(self, all_params: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """
+        These are SDK Tool objects (from google.genai.types), not JSON tool declarations.
+        """
+        tools: List[Any] = []
+
+        if all_params.get("enable_web_search", False):
+            try:
+                from google.genai.types import GoogleSearch, Tool
+
+                tools.append(Tool(google_search=GoogleSearch()))
+            except Exception:
+                # Gracefully ignore if SDK not available
+                pass
+
+        if all_params.get("enable_code_execution", False):
+            try:
+                from google.genai.types import Tool, ToolCodeExecution
+
+                tools.append(Tool(code_execution=ToolCodeExecution()))
+            except Exception:
+                # Gracefully ignore if SDK not available
+                pass
+
+        return tools
+
+    async def build_api_params(self, messages: List[Dict[str, Any]], tools: List[Dict[str, Any]], all_params: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Build a config dict for google-genai Client.generate_content_stream.
+        - Map max_tokens -> max_output_tokens
+        - Do not include 'model' here; caller extracts it
+        - Do not add builtin tools; stream logic handles them
+        - Do not handle MCP tools or coordination schema here
+        """
+        excluded = self.get_excluded_params()
+        config: Dict[str, Any] = {}
+
+        for key, value in all_params.items():
+            if key in excluded or value is None:
+                continue
+            if key == "max_tokens":
+                config["max_output_tokens"] = value
+            elif key == "model":
+                # Caller will extract model separately
+                continue
+            else:
+                config[key] = value
+
+        return config

massgen/api_params_handler/_response_api_params_handler.py

@@ -22,6 +22,7 @@ class ResponseAPIParamsHandler(APIParamsHandlerBase):
                 "enable_code_interpreter",
                 "allowed_tools",
                 "exclude_tools",
+                "custom_tools",  # Custom tools configuration (processed separately)
                 "_has_file_search_files",  # Internal flag for file search tracking
             },
         )
@@ -88,11 +89,17 @@ class ResponseAPIParamsHandler(APIParamsHandlerBase):
         if provider_tools:
             combined_tools.extend(provider_tools)
 
-        # Add framework tools
+        # Add workflow tools
         if tools:
             converted_tools = self.formatter.format_tools(tools)
             combined_tools.extend(converted_tools)
 
+        # Add custom tools
+        custom_tools = self.custom_tool_manager.registered_tools
+        if custom_tools:
+            converted_custom_tools = self.formatter.format_custom_tools(custom_tools)
+            combined_tools.extend(converted_custom_tools)
+
         # Add MCP tools (use OpenAI format)
         mcp_tools = self._convert_mcp_tools_to_openai_format()
         if mcp_tools:

massgen/backend/base.py

@@ -59,9 +59,22 @@ class LLMBackend(ABC):
         # Initialize utility classes
         self.token_usage = TokenUsage()
 
+        # # Initialize tool manager
+        # self.custom_tool_manager = ToolManager()
+
+        # # Register custom tools if specified
+        # custom_tools = kwargs.get("custom_tools", [])
+        # if custom_tools:
+        #     self._register_custom_tools(custom_tools)
+
         # Planning mode flag - when True, MCP tools should be blocked during coordination
         self._planning_mode_enabled: bool = False
 
+        # Selective tool blocking - list of specific MCP tools to block during planning mode
+        # When planning_mode is enabled, only these specific tools are blocked
+        # If empty, ALL MCP tools are blocked (backward compatible behavior)
+        self._planning_mode_blocked_tools: set = set()
+
         self.token_calculator = TokenCostCalculator()
 
         # Filesystem manager integration
@@ -125,6 +138,29 @@ class LLMBackend(ABC):
         self.api_params_handler = None
         self.coordination_stage = None
 
+    # def _register_custom_tools(self, tool_names: list[str]) -> None:
+    #     """Register custom tool functions.
+
+    #     Args:
+    #         tool_names: List of tool names to register
+    #     """
+    #     import importlib
+
+    #     for tool_name in tool_names:
+    #         try:
+    #             # Try to import from tool module
+    #             module = importlib.import_module("massgen.tool")
+    #             if hasattr(module, tool_name):
+    #                 tool_func = getattr(module, tool_name)
+    #                 self.custom_tool_manager.add_tool_function(tool_func)
+    #                 print(f"Successfully registered custom tool: {tool_name}")
+    #             else:
+    #                 print(f"Warning: Tool '{tool_name}' not found in massgen.tool")
+    #         except ImportError as e:
+    #             print(f"Warning: Could not import tool module: {e}")
+    #         except Exception as e:
+    #             print(f"Error registering tool '{tool_name}': {e}")
+
     def _setup_permission_hooks(self):
         """Setup permission hooks for function-based backends (default behavior)."""
         # Create per-agent hook manager
@@ -434,6 +470,53 @@ class LLMBackend(ABC):
         """
         return self._planning_mode_enabled
 
+    def set_planning_mode_blocked_tools(self, tool_names: set) -> None:
+        """
+        Set specific MCP tools to block during planning mode.
+
+        This enables selective tool blocking - only the specified tools will be blocked
+        when planning mode is enabled, allowing other MCP tools to be used.
+
+        Args:
+            tool_names: Set of MCP tool names to block (e.g., {'mcp__discord__discord_send'})
+                       If empty set, ALL MCP tools are blocked (backward compatible)
+        """
+        self._planning_mode_blocked_tools = set(tool_names)
+
+    def get_planning_mode_blocked_tools(self) -> set:
+        """
+        Get the set of MCP tools currently blocked in planning mode.
+
+        Returns:
+            Set of blocked MCP tool names. Empty set means ALL MCP tools are blocked.
+        """
+        return self._planning_mode_blocked_tools.copy()
+
+    def is_mcp_tool_blocked(self, tool_name: str) -> bool:
+        """
+        Check if a specific MCP tool is blocked in planning mode.
+
+        Args:
+            tool_name: Name of the MCP tool to check (e.g., 'mcp__discord__discord_send')
+
+        Returns:
+            True if the tool should be blocked, False otherwise
+
+        Note:
+            - If planning mode is disabled, returns False (no blocking)
+            - If planning mode is enabled and blocked_tools is empty, returns True (block ALL)
+            - If planning mode is enabled and blocked_tools is set, returns True only if tool is in the set
+        """
+        if not self._planning_mode_enabled:
+            return False
+
+        # Empty set means block ALL MCP tools (backward compatible behavior)
+        if not self._planning_mode_blocked_tools:
+            return True
+
+        # Otherwise, block only if tool is in the blocked set
+        return tool_name in self._planning_mode_blocked_tools
+
     async def _cleanup_client(self, client: Any) -> None:
         """Clean up OpenAI client resources."""
         try: