fast-agent-mcp 0.2.27__py3-none-any.whl → 0.2.29__py3-none-any.whl

mcp_agent/llm/model_factory.py

@@ -8,12 +8,14 @@ from mcp_agent.core.exceptions import ModelConfigError
 from mcp_agent.core.request_params import RequestParams
 from mcp_agent.llm.augmented_llm_passthrough import PassthroughLLM
 from mcp_agent.llm.augmented_llm_playback import PlaybackLLM
+from mcp_agent.llm.augmented_llm_slow import SlowLLM
 from mcp_agent.llm.provider_types import Provider
 from mcp_agent.llm.providers.augmented_llm_anthropic import AnthropicAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_azure import AzureOpenAIAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_deepseek import DeepSeekAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_generic import GenericAugmentedLLM
-from mcp_agent.llm.providers.augmented_llm_google import GoogleAugmentedLLM
+from mcp_agent.llm.providers.augmented_llm_google_native import GoogleNativeAugmentedLLM
+from mcp_agent.llm.providers.augmented_llm_google_oai import GoogleOaiAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_openai import OpenAIAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_openrouter import OpenRouterAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_tensorzero import TensorZeroAugmentedLLM
@@ -28,9 +30,13 @@ LLMClass = Union[
     Type[OpenAIAugmentedLLM],
     Type[PassthroughLLM],
     Type[PlaybackLLM],
+    Type[SlowLLM],
     Type[DeepSeekAugmentedLLM],
     Type[OpenRouterAugmentedLLM],
     Type[TensorZeroAugmentedLLM],
+    Type[GoogleNativeAugmentedLLM],
+    Type[GenericAugmentedLLM],
+    Type[AzureOpenAIAugmentedLLM],
 ]
 
 
@@ -60,13 +66,16 @@ class ModelFactory:
         "high": ReasoningEffort.HIGH,
     }
 
-    # TODO -- add context window size information for display/management
-    # TODO -- add audio supporting got-4o-audio-preview
-    # TODO -- bring model parameter configuration here
-    # Mapping of model names to their default providers
+    """
+    TODO -- add context window size information for display/management
+    TODO -- add audio supporting got-4o-audio-preview
+    TODO -- bring model parameter configuration here
+    Mapping of model names to their default providers
+    """
     DEFAULT_PROVIDERS = {
         "passthrough": Provider.FAST_AGENT,
         "playback": Provider.FAST_AGENT,
+        "slow": Provider.FAST_AGENT,
         "gpt-4o": Provider.OPENAI,
         "gpt-4o-mini": Provider.OPENAI,
         "gpt-4.1": Provider.OPENAI,
@@ -91,7 +100,9 @@ class ModelFactory:
         "claude-sonnet-4-20250514": Provider.ANTHROPIC,
         "claude-sonnet-4-0": Provider.ANTHROPIC,
         "deepseek-chat": Provider.DEEPSEEK,
-        #        "deepseek-reasoner": Provider.DEEPSEEK, reinstate on release
+        "gemini-2.0-flash": Provider.GOOGLE,
+        "gemini-2.5-flash-preview-05-20": Provider.GOOGLE,
+        "gemini-2.5-pro-preview-05-06": Provider.GOOGLE,
     }
 
     MODEL_ALIASES = {
@@ -108,6 +119,9 @@ class ModelFactory:
         "opus3": "claude-3-opus-latest",
         "deepseekv3": "deepseek-chat",
         "deepseek": "deepseek-chat",
+        "gemini2": "gemini-2.0-flash",
+        "gemini25": "gemini-2.5-flash-preview-05-20",
+        "gemini25pro": "gemini-2.5-pro-preview-05-06",
     }
 
     # Mapping of providers to their LLM classes
@@ -117,7 +131,8 @@ class ModelFactory:
         Provider.FAST_AGENT: PassthroughLLM,
         Provider.DEEPSEEK: DeepSeekAugmentedLLM,
         Provider.GENERIC: GenericAugmentedLLM,
-        Provider.GOOGLE: GoogleAugmentedLLM,  # type: ignore
+        Provider.GOOGLE_OAI: GoogleOaiAugmentedLLM,
+        Provider.GOOGLE: GoogleNativeAugmentedLLM,
         Provider.OPENROUTER: OpenRouterAugmentedLLM,
         Provider.TENSORZERO: TensorZeroAugmentedLLM,
         Provider.AZURE: AzureOpenAIAugmentedLLM,
@@ -127,48 +142,66 @@ class ModelFactory:
     # This overrides the provider-based class selection
     MODEL_SPECIFIC_CLASSES: Dict[str, LLMClass] = {
         "playback": PlaybackLLM,
+        "slow": SlowLLM,
     }
 
     @classmethod
     def parse_model_string(cls, model_string: str) -> ModelConfig:
         """Parse a model string into a ModelConfig object"""
-        # Check if model string is an alias
         model_string = cls.MODEL_ALIASES.get(model_string, model_string)
         parts = model_string.split(".")
 
-        # Start with all parts as the model name
-        model_parts = parts.copy()
+        model_name_str = model_string  # Default full string as model name initially
         provider = None
         reasoning_effort = None
+        parts_for_provider_model = []
 
-        # Check last part for reasoning effort
+        # Check for reasoning effort first (last part)
         if len(parts) > 1 and parts[-1].lower() in cls.EFFORT_MAP:
             reasoning_effort = cls.EFFORT_MAP[parts[-1].lower()]
-            model_parts = model_parts[:-1]
+            # Remove effort from parts list for provider/model name determination
+            parts_for_provider_model = parts[:-1]
+        else:
+            parts_for_provider_model = parts[:]
+
+        # Try to match longest possible provider string
+        identified_provider_parts = 0  # How many parts belong to the provider string
+
+        if len(parts_for_provider_model) >= 2:
+            potential_provider_str = f"{parts_for_provider_model[0]}.{parts_for_provider_model[1]}"
+            if any(p.value == potential_provider_str for p in Provider):
+                provider = Provider(potential_provider_str)
+                identified_provider_parts = 2
+
+        if provider is None and len(parts_for_provider_model) >= 1:
+            potential_provider_str = parts_for_provider_model[0]
+            if any(p.value == potential_provider_str for p in Provider):
+                provider = Provider(potential_provider_str)
+                identified_provider_parts = 1
+
+        # Construct model_name from remaining parts
+        if identified_provider_parts > 0:
+            model_name_str = ".".join(parts_for_provider_model[identified_provider_parts:])
+        else:
+            # If no provider prefix was matched, the whole string (after effort removal) is the model name
+            model_name_str = ".".join(parts_for_provider_model)
 
-        # Check first part for provider
-        if len(model_parts) > 1:
-            potential_provider = model_parts[0]
-            if any(provider.value == potential_provider for provider in Provider):
-                provider = Provider(potential_provider)
-                model_parts = model_parts[1:]
+        # If provider still None, try to get from DEFAULT_PROVIDERS using the model_name_str
+        if provider is None:
+            provider = cls.DEFAULT_PROVIDERS.get(model_name_str)
+            if provider is None:
+                raise ModelConfigError(
+                    f"Unknown model or provider for: {model_string}. Model name parsed as '{model_name_str}'"
+                )
 
-        if provider == Provider.TENSORZERO and not model_parts:
+        if provider == Provider.TENSORZERO and not model_name_str:
             raise ModelConfigError(
                 f"TensorZero provider requires a function name after the provider "
                 f"(e.g., tensorzero.my-function), got: {model_string}"
             )
-        # Join remaining parts as model name
-        model_name = ".".join(model_parts)
-
-        # If no provider was found in the string, look it up in defaults
-        if provider is None:
-            provider = cls.DEFAULT_PROVIDERS.get(model_name)
-            if provider is None:
-                raise ModelConfigError(f"Unknown model: {model_name}")
 
         return ModelConfig(
-            provider=provider, model_name=model_name, reasoning_effort=reasoning_effort
+            provider=provider, model_name=model_name_str, reasoning_effort=reasoning_effort
         )
 
     @classmethod
@@ -185,33 +218,37 @@ class ModelFactory:
         Returns:
             A callable that takes an agent parameter and returns an LLM instance
         """
-        # Parse configuration up front
         config = cls.parse_model_string(model_string)
+
+        # Ensure provider is valid before trying to access PROVIDER_CLASSES with it
+        if (
+            config.provider not in cls.PROVIDER_CLASSES
+            and config.model_name not in cls.MODEL_SPECIFIC_CLASSES
+        ):
+            # This check is important if a provider (like old GOOGLE) is commented out from PROVIDER_CLASSES
+            raise ModelConfigError(
+                f"Provider '{config.provider}' not configured in PROVIDER_CLASSES and model '{config.model_name}' not in MODEL_SPECIFIC_CLASSES."
+            )
+
         if config.model_name in cls.MODEL_SPECIFIC_CLASSES:
             llm_class = cls.MODEL_SPECIFIC_CLASSES[config.model_name]
         else:
+            # This line is now safer due to the check above
             llm_class = cls.PROVIDER_CLASSES[config.provider]
 
-        # Create a factory function matching the updated attach_llm protocol
         def factory(
             agent: Agent, request_params: Optional[RequestParams] = None, **kwargs
         ) -> AugmentedLLMProtocol:
-            # Create base params with parsed model name
             base_params = RequestParams()
-            base_params.model = config.model_name  # Use the parsed model name, not the alias
-
-            # Add reasoning effort if available
+            base_params.model = config.model_name
             if config.reasoning_effort:
                 kwargs["reasoning_effort"] = config.reasoning_effort.value
-
-            # Forward all arguments to LLM constructor
             llm_args = {
                 "agent": agent,
                 "model": config.model_name,
                 "request_params": request_params,
                 **kwargs,
             }
-
             llm: AugmentedLLMProtocol = llm_class(**llm_args)
             return llm
 

mcp_agent/llm/provider_types.py

@@ -9,11 +9,12 @@ class Provider(Enum):
     """Supported LLM providers"""
 
     ANTHROPIC = "anthropic"
-    OPENAI = "openai"
-    FAST_AGENT = "fast-agent"
-    GOOGLE = "google"
     DEEPSEEK = "deepseek"
+    FAST_AGENT = "fast-agent"
     GENERIC = "generic"
+    GOOGLE_OAI = "googleoai"  # For Google through OpenAI libraries
+    GOOGLE = "google"  # For Google GenAI native library
+    OPENAI = "openai"
     OPENROUTER = "openrouter"
     TENSORZERO = "tensorzero"  # For TensorZero Gateway
     AZURE = "azure"  # Azure OpenAI Service

mcp_agent/llm/providers/augmented_llm_deepseek.py

@@ -1,6 +1,10 @@
+from typing import List, Tuple, Type
+
 from mcp_agent.core.request_params import RequestParams
 from mcp_agent.llm.provider_types import Provider
 from mcp_agent.llm.providers.augmented_llm_openai import OpenAIAugmentedLLM
+from mcp_agent.mcp.interfaces import ModelT
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
 DEEPSEEK_BASE_URL = "https://api.deepseek.com"
 DEFAULT_DEEPSEEK_MODEL = "deepseekchat"  # current Deepseek only has two type models
@@ -28,3 +32,48 @@ class DeepSeekAugmentedLLM(OpenAIAugmentedLLM):
             base_url = self.context.config.deepseek.base_url
 
         return base_url if base_url else DEEPSEEK_BASE_URL
+
+    async def _apply_prompt_provider_specific_structured(
+        self,
+        multipart_messages: List[PromptMessageMultipart],
+        model: Type[ModelT],
+        request_params: RequestParams | None = None,
+    ) -> Tuple[ModelT | None, PromptMessageMultipart]:  # noqa: F821
+        request_params = self.get_request_params(request_params)
+
+        request_params.response_format = {"type": "json_object"}
+
+        # Get the full schema and extract just the properties
+        full_schema = model.model_json_schema()
+        properties = full_schema.get("properties", {})
+        required_fields = full_schema.get("required", [])
+
+        # Create a cleaner format description
+        format_description = "{\n"
+        for field_name, field_info in properties.items():
+            field_type = field_info.get("type", "string")
+            description = field_info.get("description", "")
+            format_description += f'  "{field_name}": "{field_type}"'
+            if description:
+                format_description += f"  // {description}"
+            if field_name in required_fields:
+                format_description += "  // REQUIRED"
+            format_description += "\n"
+        format_description += "}"
+
+        multipart_messages[-1].add_text(
+            f"""YOU MUST RESPOND WITH A JSON OBJECT IN EXACTLY THIS FORMAT:
+            {format_description}
+
+            IMPORTANT RULES:
+            - Respond ONLY with the JSON object, no other text
+            - Do NOT include "properties" or "schema" wrappers
+            - Do NOT use code fences or markdown
+            - The response must be valid JSON that matches the format above
+            - All required fields must be included"""
+        )
+
+        result: PromptMessageMultipart = await self._apply_prompt_provider_specific(
+            multipart_messages, request_params
+        )
+        return self._structured_from_multipart(result, model)