mcp-mesh 0.7.20__py3-none-any.whl → 0.8.0__py3-none-any.whl

_mcp_mesh/engine/provider_handlers/claude_handler.py

@@ -17,11 +17,16 @@ Features:
 
 import json
 import logging
-from typing import Any, Optional, get_args, get_origin
+from typing import Any, Optional
 
 from pydantic import BaseModel
 
-from .base_provider_handler import BaseProviderHandler
+from .base_provider_handler import (
+    BASE_TOOL_INSTRUCTIONS,
+    BaseProviderHandler,
+    CLAUDE_ANTI_XML_INSTRUCTION,
+    make_schema_strict,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -141,51 +146,6 @@ class ClaudeHandler(BaseProviderHandler):
         # Default to strict for unknown types
         return OUTPUT_MODE_STRICT
 
-    def _make_schema_strict(self, schema: dict[str, Any]) -> dict[str, Any]:
-        """
-        Make a JSON schema strict for Claude's structured output.
-
-        Claude requires additionalProperties: false on all object types.
-        This recursively processes the schema to add this constraint.
-
-        Args:
-            schema: JSON schema dict
-
-        Returns:
-            Schema with additionalProperties: false on all objects
-        """
-        if not isinstance(schema, dict):
-            return schema
-
-        result = schema.copy()
-
-        # If this is an object type, add additionalProperties: false
-        if result.get("type") == "object":
-            result["additionalProperties"] = False
-
-        # Recursively process nested schemas
-        if "properties" in result:
-            result["properties"] = {
-                k: self._make_schema_strict(v) for k, v in result["properties"].items()
-            }
-
-        # Process $defs (Pydantic uses this for nested models)
-        if "$defs" in result:
-            result["$defs"] = {
-                k: self._make_schema_strict(v) for k, v in result["$defs"].items()
-            }
-
-        # Process items for arrays
-        if "items" in result:
-            result["items"] = self._make_schema_strict(result["items"])
-
-        # Process anyOf, oneOf, allOf
-        for key in ["anyOf", "oneOf", "allOf"]:
-            if key in result:
-                result[key] = [self._make_schema_strict(s) for s in result[key]]
-
-        return result
-
     def _apply_prompt_caching(
         self, messages: list[dict[str, Any]]
     ) -> list[dict[str, Any]]:
@@ -302,9 +262,10 @@ class ClaudeHandler(BaseProviderHandler):
         # Only add response_format in "strict" mode
         if determined_mode == OUTPUT_MODE_STRICT:
             # Claude requires additionalProperties: false on all object types
+            # Unlike OpenAI/Gemini, Claude doesn't require all properties in 'required'
             if isinstance(output_type, type) and issubclass(output_type, BaseModel):
                 schema = output_type.model_json_schema()
-                strict_schema = self._make_schema_strict(schema)
+                strict_schema = make_schema_strict(schema, add_all_required=False)
                 request_params["response_format"] = {
                     "type": "json_schema",
                     "json_schema": {
@@ -346,15 +307,12 @@ class ClaudeHandler(BaseProviderHandler):
         # Add tool calling instructions if tools available
         # These prevent Claude from using XML-style <invoke> syntax
         if tool_schemas:
-            system_content += """
-
-IMPORTANT TOOL CALLING RULES:
-- You have access to tools that you can call to gather information
-- Make ONE tool call at a time
-- NEVER use XML-style syntax like <invoke name="tool_name"/>
-- After receiving tool results, you can make additional calls if needed
-- Once you have all needed information, provide your final response
-"""
+            # Use base instructions but insert anti-XML rule for Claude
+            instructions = BASE_TOOL_INSTRUCTIONS.replace(
+                "- Make ONE tool call at a time",
+                f"- Make ONE tool call at a time\n{CLAUDE_ANTI_XML_INSTRUCTION}",
+            )
+            system_content += instructions
 
         # Add output format instructions based on mode
         if determined_mode == OUTPUT_MODE_TEXT:

_mcp_mesh/engine/provider_handlers/gemini_handler.py

@@ -0,0 +1,181 @@
+"""
+Gemini/Google provider handler.
+
+Optimized for Gemini models (Gemini 2.0 Flash, Gemini 1.5 Pro, etc.)
+using Google's best practices for tool calling and structured output.
+
+Features:
+- Native structured output via response_format (similar to OpenAI)
+- Native function calling support
+- Support for Gemini 2.x and 3.x models
+- Large context windows (up to 2M tokens)
+
+Reference:
+- https://docs.litellm.ai/docs/providers/gemini
+- https://ai.google.dev/gemini-api/docs
+"""
+
+import logging
+from typing import Any, Optional
+
+from pydantic import BaseModel
+
+from .base_provider_handler import (
+    BASE_TOOL_INSTRUCTIONS,
+    BaseProviderHandler,
+    make_schema_strict,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class GeminiHandler(BaseProviderHandler):
+    """
+    Provider handler for Google Gemini models.
+
+    Gemini Characteristics:
+    - Native structured output via response_format parameter (LiteLLM translates)
+    - Native function calling support
+    - Large context windows (1M-2M tokens)
+    - Multimodal support (text, images, video, audio)
+    - Works well with concise, focused prompts
+
+    Key Similarities with OpenAI:
+    - Uses response_format for structured output (via LiteLLM translation)
+    - Native function calling format
+    - Similar schema enforcement requirements
+
+    Supported Models (via LiteLLM):
+    - gemini/gemini-2.0-flash (fast, efficient)
+    - gemini/gemini-2.0-flash-lite (fastest, most efficient)
+    - gemini/gemini-1.5-pro (high capability)
+    - gemini/gemini-1.5-flash (balanced)
+    - gemini/gemini-3-flash-preview (reasoning support)
+    - gemini/gemini-3-pro-preview (advanced reasoning)
+
+    Reference:
+    https://docs.litellm.ai/docs/providers/gemini
+    """
+
+    def __init__(self):
+        """Initialize Gemini handler."""
+        super().__init__(vendor="gemini")
+
+    def prepare_request(
+        self,
+        messages: list[dict[str, Any]],
+        tools: Optional[list[dict[str, Any]]],
+        output_type: type,
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        """
+        Prepare request parameters for Gemini API via LiteLLM.
+
+        Gemini Strategy:
+        - Use response_format parameter for structured JSON output
+        - LiteLLM handles translation to Gemini's native format
+        - Skip structured output for str return types (text mode)
+
+        Args:
+            messages: List of message dicts
+            tools: Optional list of tool schemas
+            output_type: Return type (str or Pydantic model)
+            **kwargs: Additional model parameters
+
+        Returns:
+            Dictionary of parameters for litellm.completion()
+        """
+        # Build base request
+        request_params = {
+            "messages": messages,
+            **kwargs,  # Pass through temperature, max_tokens, etc.
+        }
+
+        # Add tools if provided
+        # LiteLLM will convert OpenAI tool format to Gemini's function_declarations
+        if tools:
+            request_params["tools"] = tools
+
+        # Skip structured output for str return type (text mode)
+        if output_type is str:
+            return request_params
+
+        # Only add response_format for Pydantic models
+        if not (isinstance(output_type, type) and issubclass(output_type, BaseModel)):
+            return request_params
+
+        # Add response_format for structured output
+        # LiteLLM translates this to Gemini's native format
+        schema = output_type.model_json_schema()
+
+        # Transform schema for strict mode compliance
+        # Gemini requires additionalProperties: false and all properties in required
+        schema = make_schema_strict(schema, add_all_required=True)
+
+        # Gemini structured output format (via LiteLLM)
+        request_params["response_format"] = {
+            "type": "json_schema",
+            "json_schema": {
+                "name": output_type.__name__,
+                "schema": schema,
+                "strict": True,  # Enforce schema compliance
+            },
+        }
+
+        return request_params
+
+    def format_system_prompt(
+        self,
+        base_prompt: str,
+        tool_schemas: Optional[list[dict[str, Any]]],
+        output_type: type,
+    ) -> str:
+        """
+        Format system prompt for Gemini (concise approach).
+
+        Gemini Strategy:
+        1. Use base prompt as-is
+        2. Add tool calling instructions if tools present
+        3. Minimal JSON instructions (response_format handles structure)
+        4. Keep prompt concise - Gemini works well with clear, direct prompts
+
+        Args:
+            base_prompt: Base system prompt
+            tool_schemas: Optional tool schemas
+            output_type: Expected response type (str or Pydantic model)
+
+        Returns:
+            Formatted system prompt optimized for Gemini
+        """
+        system_content = base_prompt
+
+        # Add tool calling instructions if tools available
+        if tool_schemas:
+            system_content += BASE_TOOL_INSTRUCTIONS
+
+        # Skip JSON note for str return type (text mode)
+        if output_type is str:
+            return system_content
+
+        # Add brief JSON note (response_format handles enforcement)
+        if isinstance(output_type, type) and issubclass(output_type, BaseModel):
+            system_content += f"\n\nYour final response will be structured as JSON matching the {output_type.__name__} format."
+
+        return system_content
+
+    def get_vendor_capabilities(self) -> dict[str, bool]:
+        """
+        Return Gemini-specific capabilities.
+
+        Returns:
+            Capability flags for Gemini
+        """
+        return {
+            "native_tool_calling": True,  # Gemini has native function calling
+            "structured_output": True,  # Supports structured output via response_format
+            "streaming": True,  # Supports streaming
+            "vision": True,  # Gemini supports multimodal (images, video, audio)
+            "json_mode": True,  # Native JSON mode via response_format
+            "large_context": True,  # Up to 2M tokens context window
+        }
+

_mcp_mesh/engine/provider_handlers/openai_handler.py

@@ -5,12 +5,15 @@ Optimized for OpenAI models (GPT-4, GPT-4 Turbo, GPT-3.5-turbo)
 using OpenAI's native structured output capabilities.
 """
 
-import json
 from typing import Any, Optional
 
 from pydantic import BaseModel
 
-from .base_provider_handler import BaseProviderHandler
+from .base_provider_handler import (
+    BASE_TOOL_INSTRUCTIONS,
+    BaseProviderHandler,
+    make_schema_strict,
+)
 
 
 class OpenAIHandler(BaseProviderHandler):
@@ -94,8 +97,8 @@ class OpenAIHandler(BaseProviderHandler):
             schema = output_type.model_json_schema()
 
             # Transform schema for OpenAI strict mode
-            # OpenAI requires additionalProperties: false on all object schemas
-            schema = self._add_additional_properties_false(schema)
+            # OpenAI requires additionalProperties: false and all properties in required
+            schema = make_schema_strict(schema, add_all_required=True)
 
             # OpenAI structured output format
             # See: https://platform.openai.com/docs/guides/structured-outputs
@@ -143,14 +146,7 @@ class OpenAIHandler(BaseProviderHandler):
 
         # Add tool calling instructions if tools available
         if tool_schemas:
-            system_content += """
-
-IMPORTANT TOOL CALLING RULES:
-- You have access to tools that you can call to gather information
-- Make ONE tool call at a time
-- After receiving tool results, you can make additional calls if needed
-- Once you have all needed information, provide your final response
-"""
+            system_content += BASE_TOOL_INSTRUCTIONS
 
         # Skip JSON note for str return type (text mode)
         if output_type is str:
@@ -181,54 +177,3 @@ IMPORTANT TOOL CALLING RULES:
             "json_mode": True,  # Has dedicated JSON mode via response_format
         }
 
-    def _add_additional_properties_false(
-        self, schema: dict[str, Any]
-    ) -> dict[str, Any]:
-        """
-        Recursively add additionalProperties: false to all object schemas.
-
-        OpenAI strict mode requires this for all object schemas.
-        See: https://platform.openai.com/docs/guides/structured-outputs
-
-        Args:
-            schema: JSON schema from Pydantic model
-
-        Returns:
-            Modified schema with additionalProperties: false on all objects
-        """
-        import copy
-
-        schema = copy.deepcopy(schema)
-        self._add_additional_properties_recursive(schema)
-        return schema
-
-    def _add_additional_properties_recursive(self, obj: Any) -> None:
-        """Recursively process schema for OpenAI strict mode compliance."""
-        if isinstance(obj, dict):
-            # If this is an object type, add additionalProperties: false
-            # and ensure required includes all properties
-            if obj.get("type") == "object":
-                obj["additionalProperties"] = False
-                # OpenAI strict mode: required must include ALL property keys
-                if "properties" in obj:
-                    obj["required"] = list(obj["properties"].keys())
-
-            # Process $defs (Pydantic uses this for nested models)
-            if "$defs" in obj:
-                for def_schema in obj["$defs"].values():
-                    self._add_additional_properties_recursive(def_schema)
-
-            # Process properties
-            if "properties" in obj:
-                for prop_schema in obj["properties"].values():
-                    self._add_additional_properties_recursive(prop_schema)
-
-            # Process items (for arrays)
-            if "items" in obj:
-                self._add_additional_properties_recursive(obj["items"])
-
-            # Process anyOf, oneOf, allOf
-            for key in ("anyOf", "oneOf", "allOf"):
-                if key in obj:
-                    for item in obj[key]:
-                        self._add_additional_properties_recursive(item)

_mcp_mesh/engine/provider_handlers/provider_handler_registry.py

@@ -5,10 +5,11 @@ Manages selection and instantiation of provider handlers based on vendor name.
 """
 
 import logging
-from typing import Dict, Optional, Type
+from typing import Optional
 
 from .base_provider_handler import BaseProviderHandler
 from .claude_handler import ClaudeHandler
+from .gemini_handler import GeminiHandler
 from .generic_handler import GenericHandler
 from .openai_handler import OpenAIHandler
 
@@ -39,16 +40,17 @@ class ProviderHandlerRegistry:
     """
 
     # Built-in vendor mappings
-    _handlers: Dict[str, Type[BaseProviderHandler]] = {
+    _handlers: dict[str, type[BaseProviderHandler]] = {
         "anthropic": ClaudeHandler,
         "openai": OpenAIHandler,
+        "gemini": GeminiHandler,
     }
 
     # Cache of instantiated handlers (singleton per vendor)
-    _instances: Dict[str, BaseProviderHandler] = {}
+    _instances: dict[str, BaseProviderHandler] = {}
 
     @classmethod
-    def register(cls, vendor: str, handler_class: Type[BaseProviderHandler]) -> None:
+    def register(cls, vendor: str, handler_class: type[BaseProviderHandler]) -> None:
         """
         Register a custom provider handler.
 
@@ -73,7 +75,9 @@ class ProviderHandlerRegistry:
             )
 
         cls._handlers[vendor] = handler_class
-        logger.info(f"📝 Registered provider handler: {vendor} -> {handler_class.__name__}")
+        logger.info(
+            f"📝 Registered provider handler: {vendor} -> {handler_class.__name__}"
+        )
 
         # Clear cached instance if it exists (force re-instantiation)
         if vendor in cls._instances:
@@ -119,9 +123,7 @@ class ProviderHandlerRegistry:
         # Get handler class (or fallback to Generic)
         if vendor in cls._handlers:
             handler_class = cls._handlers[vendor]
-            logger.info(
-                f"✅ Selected {handler_class.__name__} for vendor: {vendor}"
-            )
+            logger.info(f"✅ Selected {handler_class.__name__} for vendor: {vendor}")
         else:
             handler_class = GenericHandler
             if vendor != "unknown":
@@ -132,14 +134,18 @@ class ProviderHandlerRegistry:
                 logger.debug("Using GenericHandler for unknown vendor")
 
         # Instantiate and cache
-        handler = handler_class() if handler_class != GenericHandler else GenericHandler(vendor)
+        handler = (
+            handler_class()
+            if handler_class != GenericHandler
+            else GenericHandler(vendor)
+        )
         cls._instances[vendor] = handler
 
         logger.debug(f"🆕 Instantiated handler: {handler}")
         return handler
 
     @classmethod
-    def list_vendors(cls) -> Dict[str, str]:
+    def list_vendors(cls) -> dict[str, str]:
         """
         List all registered vendors and their handlers.
 

_mcp_mesh/engine/response_parser.py

@@ -94,8 +94,9 @@ class ResponseParser:
 
         Tries multiple strategies to find JSON in mixed responses:
         1. Find ```json ... ``` code fence blocks
-        2. Find any JSON object {...} in the content
-        3. Return original content if no extraction needed
+        2. Find any JSON object {...} using progressive json.loads
+        3. Find any JSON array [...] using progressive json.loads
+        4. Return original content if no extraction needed
 
         Args:
             content: Raw content that may contain narrative, XML, and JSON
@@ -109,25 +110,70 @@ class ResponseParser:
             extracted = json_match.group(1).strip()
             return extracted
 
-        # Strategy 2: Try to find any JSON object {...} in content
-        # Look for balanced braces starting with { and ending with }
+        # Strategy 2: Try to find JSON object using progressive json.loads
+        # This correctly handles braces inside string values
         brace_start = content.find("{")
         if brace_start != -1:
-            # Find matching closing brace
-            brace_count = 0
-            for i in range(brace_start, len(content)):
-                if content[i] == "{":
-                    brace_count += 1
-                elif content[i] == "}":
-                    brace_count -= 1
-                    if brace_count == 0:
-                        # Found matching brace
-                        extracted = content[brace_start : i + 1]
-                        return extracted
+            result = ResponseParser._try_progressive_parse(
+                content, brace_start, "{", "}"
+            )
+            if result:
+                return result
+
+        # Strategy 3: Try to find JSON array using progressive json.loads
+        bracket_start = content.find("[")
+        if bracket_start != -1:
+            result = ResponseParser._try_progressive_parse(
+                content, bracket_start, "[", "]"
+            )
+            if result:
+                return result
 
         # No JSON found, return original
         return content
 
+    @staticmethod
+    def _try_progressive_parse(
+        content: str, start: int, open_char: str, close_char: str
+    ) -> str | None:
+        """
+        Try to extract valid JSON by progressively extending the end position.
+        This correctly handles braces/brackets inside string values.
+
+        Args:
+            content: The full content string
+            start: Starting index of the JSON
+            open_char: Opening character ('{' or '[')
+            close_char: Closing character ('}' or ']')
+
+        Returns:
+            Extracted JSON string or None if not found
+        """
+        # Find potential end positions based on depth counting
+        depth = 0
+        potential_ends: list[int] = []
+
+        for i in range(start, len(content)):
+            char = content[i]
+            if char == open_char:
+                depth += 1
+            elif char == close_char:
+                depth -= 1
+                if depth == 0:
+                    potential_ends.append(i)
+
+        # Try each potential end position (shortest first for efficiency)
+        for end in potential_ends:
+            candidate = content[start : end + 1]
+            try:
+                json.loads(candidate)
+                return candidate
+            except json.JSONDecodeError:
+                # Not valid JSON, try next potential end
+                continue
+
+        return None
+
     @staticmethod
     def _strip_markdown_fences(content: str) -> str:
         """