massgen 0.0.3__py3-none-any.whl → 0.1.0__py3-none-any.whl

massgen/api_params_handler/_chat_completions_api_params_handler.py

@@ -0,0 +1,176 @@
+# -*- coding: utf-8 -*-
+"""
+Chat Completions API parameters handler.
+Handles parameter building for OpenAI Chat Completions API format.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Set
+
+from ._api_params_handler_base import APIParamsHandlerBase
+
+
+class ChatCompletionsAPIParamsHandler(APIParamsHandlerBase):
+    """Handler for Chat Completions API parameters."""
+
+    def get_excluded_params(self) -> Set[str]:
+        """Get parameters to exclude from Chat Completions API calls."""
+        return self.get_base_excluded_params().union(
+            {
+                "base_url",  # Used for client initialization, not API calls
+                "enable_web_search",
+                "enable_code_interpreter",
+                "allowed_tools",
+                "exclude_tools",
+            },
+        )
+
+    def get_provider_tools(self, all_params: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Get provider tools for Chat Completions format."""
+        provider_tools = []
+
+        if all_params.get("enable_web_search", False):
+            provider_tools.append(
+                {
+                    "type": "function",
+                    "function": {
+                        "name": "web_search",
+                        "description": "Search the web for current or factual information",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "query": {
+                                    "type": "string",
+                                    "description": "The search query to send to the web",
+                                },
+                            },
+                            "required": ["query"],
+                        },
+                    },
+                },
+            )
+
+        if all_params.get("enable_code_interpreter", False):
+            provider_tools.append(
+                {
+                    "type": "code_interpreter",
+                    "container": {"type": "auto"},
+                },
+            )
+
+        return provider_tools
+
+    def build_base_api_params(self, messages: List[Dict[str, Any]], all_params: Dict[str, Any]) -> Dict[str, Any]:
+        """Build base API parameters for Chat Completions requests."""
+        # Sanitize: remove trailing assistant tool_calls without corresponding tool results
+        sanitized_messages = self._sanitize_messages_for_api(messages)
+        # Convert messages to ensure tool call arguments are properly serialized
+        converted_messages = self.formatter.format_messages(sanitized_messages)
+
+        api_params = {
+            "messages": converted_messages,
+            "stream": True,
+        }
+
+        # Direct passthrough of all parameters except those handled separately
+        for key, value in all_params.items():
+            if key not in self.get_excluded_params() and value is not None:
+                api_params[key] = value
+
+        return api_params
+
+    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 Chat Completions API parameters."""
+        # Sanitize messages if needed
+        if hasattr(self.backend, "_sanitize_messages_for_api"):
+            messages = self._sanitize_messages_for_api(messages)
+
+        # Convert messages to Chat Completions format
+        converted_messages = self.formatter.format_messages(messages)
+
+        # Build base parameters
+        api_params = {
+            "messages": converted_messages,
+            "stream": True,
+        }
+
+        # Add filtered parameters
+        excluded = self.get_excluded_params()
+        for key, value in all_params.items():
+            if key not in excluded and value is not None:
+                api_params[key] = value
+
+        # Combine all tools
+        combined_tools = []
+
+        # Server-side tools (provider tools) go first
+        provider_tools = self.get_provider_tools(all_params)
+        if provider_tools:
+            combined_tools.extend(provider_tools)
+
+        # User-defined tools
+        if tools:
+            converted_tools = self.formatter.format_tools(tools)
+            combined_tools.extend(converted_tools)
+
+        # MCP tools
+        mcp_tools = self.get_mcp_tools()
+        if mcp_tools:
+            combined_tools.extend(mcp_tools)
+
+        if combined_tools:
+            api_params["tools"] = combined_tools
+
+        return api_params
+
+    def _sanitize_messages_for_api(self, messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """
+        Ensure assistant tool_calls are valid per OpenAI Chat Completions rules:
+        - For any assistant message with tool_calls, each tool_call.id must have a following
+          tool message with matching tool_call_id in the subsequent history.
+        - Remove any tool_calls lacking matching tool results; drop the whole assistant message
+          if no valid tool_calls remain and it has no useful content.
+        This prevents 400 wrong_api_format errors.
+        """
+        try:
+            sanitized: List[Dict[str, Any]] = []
+            len(messages)
+            for i, msg in enumerate(messages):
+                if msg.get("role") == "assistant" and "tool_calls" in msg:
+                    tool_calls = msg.get("tool_calls") or []
+                    valid_tool_calls = []
+                    for tc in tool_calls:
+                        tc_id = tc.get("id")
+                        if not tc_id:
+                            continue
+                        # Does a later tool message reference this id?
+                        has_match = any((m.get("role") == "tool" and m.get("tool_call_id") == tc_id) for m in messages[i + 1 :])
+                        if has_match:
+                            # Normalize arguments to string
+                            fn = dict(tc.get("function", {}))
+                            fn["arguments"] = self.formatter._serialize_tool_arguments(fn.get("arguments"))
+                            valid_tc = dict(tc)
+                            valid_tc["function"] = fn
+                            valid_tool_calls.append(valid_tc)
+                    if valid_tool_calls:
+                        new_msg = dict(msg)
+                        new_msg["tool_calls"] = valid_tool_calls
+                        sanitized.append(new_msg)
+                    else:
+                        # Keep as plain assistant if it has content; otherwise drop
+                        if msg.get("content"):
+                            new_msg = {k: v for k, v in msg.items() if k != "tool_calls"}
+                            sanitized.append(new_msg)
+                        else:
+                            continue
+                else:
+                    sanitized.append(msg)
+            return sanitized
+        except Exception:
+            return messages

massgen/api_params_handler/_claude_api_params_handler.py

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*-
+"""
+Claude API parameters handler.
+Handles parameter building for Anthropic Claude Messages API format.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Set
+
+from ._api_params_handler_base import APIParamsHandlerBase
+
+
+class ClaudeAPIParamsHandler(APIParamsHandlerBase):
+    """Handler for Claude API parameters."""
+
+    def get_excluded_params(self) -> Set[str]:
+        """Get parameters to exclude from Claude API calls."""
+        return self.get_base_excluded_params().union(
+            {
+                "enable_web_search",
+                "enable_code_execution",
+                "allowed_tools",
+                "exclude_tools",
+                "_has_files_api_files",
+            },
+        )
+
+    def get_provider_tools(self, all_params: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Get provider tools for Claude format (server-side tools)."""
+        provider_tools = []
+
+        if all_params.get("enable_web_search", False):
+            provider_tools.append(
+                {
+                    "type": "web_search_20250305",
+                    "name": "web_search",
+                },
+            )
+
+        if all_params.get("enable_code_execution", False):
+            provider_tools.append(
+                {
+                    "type": "code_execution_20250522",
+                    "name": "code_execution",
+                },
+            )
+
+        return provider_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 Claude API parameters."""
+        # Convert messages to Claude format and extract system message
+        converted_messages, system_message = self.formatter.format_messages_and_system(messages)
+
+        # Build base parameters
+        api_params: Dict[str, Any] = {
+            "messages": converted_messages,
+            "stream": True,
+        }
+
+        # Add filtered parameters
+        excluded = self.get_excluded_params()
+        for key, value in all_params.items():
+            if key not in excluded and value is not None:
+                api_params[key] = value
+
+        # Claude API requires max_tokens - add default if not provided
+        if "max_tokens" not in api_params:
+            api_params["max_tokens"] = 4096
+
+        # Handle multiple betas (code execution and files API)
+        betas_list = []
+        if all_params.get("enable_code_execution"):
+            betas_list.append("code-execution-2025-05-22")
+        if all_params.get("_has_files_api_files"):
+            betas_list.append("files-api-2025-04-14")
+        if betas_list:
+            api_params["betas"] = betas_list
+
+        # Remove internal flag so it doesn't leak
+        all_params.pop("_has_files_api_files", None)
+
+        # Add system message if present
+        if system_message:
+            api_params["system"] = system_message
+
+        combined_tools = []
+
+        # Server-side tools (provider tools) go first
+        provider_tools = self.get_provider_tools(all_params)
+        if provider_tools:
+            combined_tools.extend(provider_tools)
+
+        # User-defined tools
+        if tools:
+            converted_tools = self.formatter.format_tools(tools)
+            combined_tools.extend(converted_tools)
+
+        # MCP tools
+        mcp_tools = self.get_mcp_tools()
+        if mcp_tools:
+            combined_tools.extend(mcp_tools)
+
+        if combined_tools:
+            api_params["tools"] = combined_tools
+
+        return api_params

massgen/api_params_handler/_response_api_params_handler.py

@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*-
+"""
+Response API parameters handler.
+Handles parameter building for OpenAI Response API format.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Set
+
+from ._api_params_handler_base import APIParamsHandlerBase
+
+
+class ResponseAPIParamsHandler(APIParamsHandlerBase):
+    """Handler for Response API parameters."""
+
+    def get_excluded_params(self) -> Set[str]:
+        """Get parameters to exclude from Response API calls."""
+        return self.get_base_excluded_params().union(
+            {
+                "enable_web_search",
+                "enable_code_interpreter",
+                "allowed_tools",
+                "exclude_tools",
+                "_has_file_search_files",  # Internal flag for file search tracking
+            },
+        )
+
+    def get_provider_tools(self, all_params: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Get provider tools for Response API format."""
+        provider_tools = []
+
+        if all_params.get("enable_web_search", False):
+            provider_tools.append({"type": "web_search"})
+
+        if all_params.get("enable_code_interpreter", False):
+            provider_tools.append(
+                {
+                    "type": "code_interpreter",
+                    "container": {"type": "auto"},
+                },
+            )
+
+        return provider_tools
+
+    def _convert_mcp_tools_to_openai_format(self) -> List[Dict[str, Any]]:
+        """Convert MCP tools to OpenAI function format for Response API."""
+        if not hasattr(self.backend, "_mcp_functions") or not self.backend._mcp_functions:
+            return []
+
+        converted_tools = []
+        for function in self.backend._mcp_functions.values():
+            converted_tools.append(function.to_openai_format())
+
+        return converted_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 Response API parameters."""
+        # Convert messages to Response API format
+        converted_messages = self.formatter.format_messages(messages)
+
+        # Response API uses 'input' instead of 'messages'
+        api_params = {
+            "input": converted_messages,
+            "stream": True,
+        }
+
+        # Add filtered parameters with parameter mapping
+        excluded = self.get_excluded_params()
+        for key, value in all_params.items():
+            if key not in excluded and value is not None:
+                # Handle Response API parameter name differences
+                if key == "max_tokens":
+                    api_params["max_output_tokens"] = value
+                else:
+                    api_params[key] = value
+
+        # Combine all tools
+        combined_tools = api_params.setdefault("tools", [])
+
+        # Add provider tools first
+        provider_tools = self.get_provider_tools(all_params)
+        if provider_tools:
+            combined_tools.extend(provider_tools)
+
+        # Add framework tools
+        if tools:
+            converted_tools = self.formatter.format_tools(tools)
+            combined_tools.extend(converted_tools)
+
+        # Add MCP tools (use OpenAI format)
+        mcp_tools = self._convert_mcp_tools_to_openai_format()
+        if mcp_tools:
+            combined_tools.extend(mcp_tools)
+
+        if combined_tools:
+            api_params["tools"] = combined_tools
+        # File Search integration
+        vector_store_ids = all_params.get("_file_search_vector_store_ids")
+        if vector_store_ids:
+            # Ensure vector_store_ids is a list
+            if not isinstance(vector_store_ids, list):
+                vector_store_ids = [vector_store_ids]
+
+            # Check if file_search tool already exists
+            file_search_tool_index = None
+            for i, tool in enumerate(combined_tools):
+                if tool.get("type") == "file_search":
+                    file_search_tool_index = i
+                    break
+
+            # Add or update file_search tool with embedded vector_store_ids
+            if file_search_tool_index is not None:
+                # Update existing file_search tool
+                combined_tools[file_search_tool_index]["vector_store_ids"] = vector_store_ids
+            else:
+                # Add new file_search tool with vector_store_ids
+                combined_tools.append(
+                    {
+                        "type": "file_search",
+                        "vector_store_ids": vector_store_ids,
+                    },
+                )
+
+        return api_params

massgen/backend/__init__.py

@@ -1,25 +1,60 @@
+# -*- coding: utf-8 -*-
 """
 MassGen Backend System - Multi-Provider LLM Integration
 
 Supports multiple LLM providers with standardized StreamChunk interface:
-- Response API (standard format with tool support)
-- Grok/xAI (Chat Completions API compatible)
+- ChatCompletions (OpenAI-compatible for Cerebras AI, etc.)
+- Response API (OpenAI Response API with reasoning support)
+- Grok (xAI API with live search capabilities)
 - Claude (Messages API with multi-tool support)
 - Gemini (structured output for coordination)
+- Claude Code (claude-code-sdk streaming integration)
+
+TODO:
+
+- Gemini CLI (command-line interface integration)
+- Clean up StreamChunk design (too many optional fields for reasoning/provider features)
+- Check if we indeed need to pass agent_id & session_id to backends
 """
 
 from .base import LLMBackend, StreamChunk, TokenUsage
-from .response import ResponseBackend
-from .grok import GrokBackend
+from .chat_completions import ChatCompletionsBackend
 from .claude import ClaudeBackend
+
+# from .claude_code_cli import ClaudeCodeCLIBackend  # File removed
+from .claude_code import ClaudeCodeBackend
+from .cli_base import CLIBackend
 from .gemini import GeminiBackend
+from .grok import GrokBackend
+from .lmstudio import LMStudioBackend
+from .response import ResponseBackend
+
+# from .gemini_cli import GeminiCLIBackend
+
+# Azure OpenAI backend (optional)
+try:
+    from .azure_openai import AzureOpenAIBackend
+
+    AZURE_OPENAI_AVAILABLE = True
+except ImportError:
+    AZURE_OPENAI_AVAILABLE = False
+    AzureOpenAIBackend = None
 
 __all__ = [
     "LLMBackend",
     "StreamChunk",
     "TokenUsage",
+    "ChatCompletionsBackend",
     "ResponseBackend",
     "GrokBackend",
+    "LMStudioBackend",
     "ClaudeBackend",
     "GeminiBackend",
+    "CLIBackend",
+    "ClaudeCodeBackend",
+    # "GeminiCLIBackend",
 ]
+
+# Add Azure OpenAI if available
+if AZURE_OPENAI_AVAILABLE:
+    __all__.append("AzureOpenAIBackend")