fast-agent-mcp 0.2.27__tar.gz → 0.2.28__tar.gz

{fast_agent_mcp-0.2.27 → fast_agent_mcp-0.2.28}/.gitignore

@@ -1,4 +1,4 @@
-s# Byte-compiled / optimized / DLL files
+# Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
 *$py.class

{fast_agent_mcp-0.2.27 → fast_agent_mcp-0.2.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.27
+Version: 0.2.28
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>
 License:                                  Apache License
@@ -214,11 +214,13 @@ Requires-Dist: aiohttp>=3.11.13
 Requires-Dist: anthropic>=0.49.0
 Requires-Dist: azure-identity>=1.14.0
 Requires-Dist: fastapi>=0.115.6
+Requires-Dist: google-genai
 Requires-Dist: mcp==1.9.1
 Requires-Dist: openai>=1.63.2
 Requires-Dist: opentelemetry-distro>=0.50b0
 Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.29.0
 Requires-Dist: opentelemetry-instrumentation-anthropic>=0.39.3; python_version >= '3.10' and python_version < '4.0'
+Requires-Dist: opentelemetry-instrumentation-google-genai>=0.2b0
 Requires-Dist: opentelemetry-instrumentation-mcp>=0.40.3; python_version >= '3.10' and python_version < '4.0'
 Requires-Dist: opentelemetry-instrumentation-openai>=0.39.3; python_version >= '3.10' and python_version < '4.0'
 Requires-Dist: prompt-toolkit>=3.0.50

{fast_agent_mcp-0.2.27 → fast_agent_mcp-0.2.28}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.2.27"
+version = "0.2.28"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -31,8 +31,12 @@ dependencies = [
     "a2a-types>=0.1.0",
     "opentelemetry-instrumentation-openai>=0.39.3; python_version >= '3.10' and python_version < '4.0'",
     "opentelemetry-instrumentation-anthropic>=0.39.3; python_version >= '3.10' and python_version < '4.0'",
-    "tensorzero>=2025.4.7",
     "opentelemetry-instrumentation-mcp>=0.40.3; python_version >= '3.10' and python_version < '4.0'",
+    "google-genai",
+    "opentelemetry-instrumentation-google-genai>=0.2b0",
+    "tensorzero>=2025.4.7",
+    "google-genai",
+    "opentelemetry-instrumentation-google-genai>=0.2b0",
 ]
 
 [project.optional-dependencies]

{fast_agent_mcp-0.2.27 → fast_agent_mcp-0.2.28}/src/mcp_agent/agents/agent.py

@@ -75,27 +75,11 @@ class Agent(BaseAgent):
         async def send_wrapper(message, agent_name):
             return await self.send(message)
 
-        # Define wrapper for apply_prompt function
-        async def apply_prompt_wrapper(prompt_name, args, agent_name):
-            # Just apply the prompt directly
-            return await self.apply_prompt(prompt_name, args)
-
-        # Define wrapper for list_prompts function
-        async def list_prompts_wrapper(agent_name):
-            # Always call list_prompts on this agent regardless of agent_name
-            return await self.list_prompts()
-
-        # Define wrapper for list_resources function
-        async def list_resources_wrapper(agent_name):
-            # Always call list_resources on this agent regardless of agent_name
-            return await self.list_resources()
-
         # Start the prompt loop with just this agent
         return await prompt.prompt_loop(
             send_func=send_wrapper,
             default_agent=agent_name_str,
             available_agents=[agent_name_str],  # Only this agent
-            apply_prompt_func=apply_prompt_wrapper,
-            list_prompts_func=list_prompts_wrapper,
+            prompt_provider=self,  # Pass self as the prompt provider since we implement the protocol
             default=default_prompt,
         )

{fast_agent_mcp-0.2.27 → fast_agent_mcp-0.2.28}/src/mcp_agent/agents/base_agent.py

@@ -456,6 +456,7 @@ class BaseAgent(MCPAggregator, AgentProtocol):
         self,
         prompt_name: str,
         arguments: Dict[str, str] | None = None,
+        agent_name: str | None = None,
         server_name: str | None = None,
     ) -> str:
         """
@@ -468,6 +469,7 @@ class BaseAgent(MCPAggregator, AgentProtocol):
         Args:
             prompt_name: The name of the prompt to apply
             arguments: Optional dictionary of string arguments to pass to the prompt template
+            agent_name: Optional agent name (ignored at this level, used by multi-agent apps)
             server_name: Optional name of the server to get the prompt from
 
         Returns:

{fast_agent_mcp-0.2.27 → fast_agent_mcp-0.2.28}/src/mcp_agent/config.py

@@ -291,6 +291,9 @@ class Settings(BaseSettings):
     Default model for agents. Format is provider.model_name.<reasoning_effort>, for example openai.o3-mini.low
     Aliases are provided for common models e.g. sonnet, haiku, gpt-4.1, o3-mini etc.
     """
+    
+    auto_sampling: bool = True
+    """Enable automatic sampling model selection if not explicitly configured"""
 
     anthropic: AnthropicSettings | None = None
     """Settings for using Anthropic models in the fast-agent application"""

{fast_agent_mcp-0.2.27 → fast_agent_mcp-0.2.28}/src/mcp_agent/context.py

@@ -11,6 +11,7 @@ from mcp import ServerSession
 from opentelemetry import trace
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
 from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
+from opentelemetry.instrumentation.google_genai import GoogleGenAiSdkInstrumentor
 from opentelemetry.instrumentation.mcp import McpInstrumentor
 from opentelemetry.instrumentation.openai import OpenAIInstrumentor
 from opentelemetry.propagate import set_global_textmap
@@ -112,6 +113,7 @@ async def configure_otel(config: "Settings") -> None:
     trace.set_tracer_provider(tracer_provider)
     AnthropicInstrumentor().instrument()
     OpenAIInstrumentor().instrument()
+    GoogleGenAiSdkInstrumentor().instrument()
     McpInstrumentor().instrument()
 
 

{fast_agent_mcp-0.2.27 → fast_agent_mcp-0.2.28}/src/mcp_agent/core/agent_app.py

@@ -129,6 +129,12 @@ class AgentApp:
         Returns:
             Dictionary mapping server names to lists of available prompts
         """
+        if not agent_name:
+            results = {}
+            for agent in self._agents.values():
+                curr_prompts = await agent.list_prompts(server_name=server_name)
+                results.update(curr_prompts)
+            return results
         return await self._agent(agent_name).list_prompts(server_name=server_name)
 
     async def get_prompt(
@@ -262,7 +268,6 @@ class AgentApp:
             send_func=send_wrapper,
             default_agent=target_name,  # Pass the agent name, not the agent object
             available_agents=list(self._agents.keys()),
-            apply_prompt_func=self.apply_prompt,
-            list_prompts_func=self.list_prompts,
+            prompt_provider=self,  # Pass self as the prompt provider
             default=default_prompt,
         )

{fast_agent_mcp-0.2.27 → fast_agent_mcp-0.2.28}/src/mcp_agent/core/interactive_prompt.py

@@ -10,12 +10,13 @@ Usage:
         send_func=agent_app.send,
         default_agent="default_agent",
         available_agents=["agent1", "agent2"],
-        apply_prompt_func=agent_app.apply_prompt
+        prompt_provider=agent_app
     )
 """
 
-from typing import Dict, List, Optional
+from typing import Awaitable, Callable, Dict, List, Mapping, Optional, Protocol, Union
 
+from mcp.types import Prompt, PromptMessage
 from rich import print as rich_print
 from rich.console import Console
 from rich.table import Table
@@ -28,8 +29,24 @@ from mcp_agent.core.enhanced_prompt import (
     handle_special_commands,
 )
 from mcp_agent.mcp.mcp_aggregator import SEP  # Import SEP once at the top
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 from mcp_agent.progress_display import progress_display
 
+# Type alias for the send function
+SendFunc = Callable[[Union[str, PromptMessage, PromptMessageMultipart], str], Awaitable[str]]
+
+
+class PromptProvider(Protocol):
+    """Protocol for objects that can provide prompt functionality."""
+    
+    async def list_prompts(self, server_name: Optional[str] = None, agent_name: Optional[str] = None) -> Mapping[str, List[Prompt]]:
+        """List available prompts."""
+        ...
+    
+    async def apply_prompt(self, prompt_name: str, arguments: Optional[Dict[str, str]] = None, agent_name: Optional[str] = None, **kwargs) -> str:
+        """Apply a prompt."""
+        ...
+
 
 class InteractivePrompt:
     """
@@ -48,22 +65,20 @@ class InteractivePrompt:
 
     async def prompt_loop(
         self,
-        send_func,
+        send_func: SendFunc,
         default_agent: str,
         available_agents: List[str],
-        apply_prompt_func=None,
-        list_prompts_func=None,
+        prompt_provider: Optional[PromptProvider] = None,
         default: str = "",
     ) -> str:
         """
         Start an interactive prompt session.
 
         Args:
-            send_func: Function to send messages to agents (signature: async (message, agent_name))
+            send_func: Function to send messages to agents
             default_agent: Name of the default agent to use
             available_agents: List of available agent names
-            apply_prompt_func: Optional function to apply prompts (signature: async (name, args, agent))
-            list_prompts_func: Optional function to list available prompts (signature: async (agent_name))
+            prompt_provider: Optional provider that implements list_prompts and apply_prompt
             default: Default message to use when user presses enter
 
         Returns:
@@ -110,13 +125,11 @@ class InteractivePrompt:
                             rich_print(f"[red]Agent '{new_agent}' not found[/red]")
                             continue
                     # Keep the existing list_prompts handler for backward compatibility
-                    elif "list_prompts" in command_result and list_prompts_func:
-                        # Use the list_prompts_func directly
-                        await self._list_prompts(list_prompts_func, agent)
+                    elif "list_prompts" in command_result and prompt_provider:
+                        # Use the prompt_provider directly
+                        await self._list_prompts(prompt_provider, agent)
                         continue
-                    elif "select_prompt" in command_result and (
-                        list_prompts_func and apply_prompt_func
-                    ):
+                    elif "select_prompt" in command_result and prompt_provider:
                         # Handle prompt selection, using both list_prompts and apply_prompt
                         prompt_name = command_result.get("prompt_name")
                         prompt_index = command_result.get("prompt_index")
@@ -124,7 +137,7 @@ class InteractivePrompt:
                         # If a specific index was provided (from /prompt <number>)
                         if prompt_index is not None:
                             # First get a list of all prompts to look up the index
-                            all_prompts = await self._get_all_prompts(list_prompts_func, agent)
+                            all_prompts = await self._get_all_prompts(prompt_provider, agent)
                             if not all_prompts:
                                 rich_print("[yellow]No prompts available[/yellow]")
                                 continue
@@ -135,8 +148,7 @@ class InteractivePrompt:
                                 selected_prompt = all_prompts[prompt_index - 1]
                                 # Use the already created namespaced_name to ensure consistency
                                 await self._select_prompt(
-                                    list_prompts_func,
-                                    apply_prompt_func,
+                                    prompt_provider,
                                     agent,
                                     selected_prompt["namespaced_name"],
                                 )
@@ -145,11 +157,11 @@ class InteractivePrompt:
                                     f"[red]Invalid prompt number: {prompt_index}. Valid range is 1-{len(all_prompts)}[/red]"
                                 )
                                 # Show the prompt list for convenience
-                                await self._list_prompts(list_prompts_func, agent)
+                                await self._list_prompts(prompt_provider, agent)
                         else:
                             # Use the name-based selection
                             await self._select_prompt(
-                                list_prompts_func, apply_prompt_func, agent, prompt_name
+                                prompt_provider, agent, prompt_name
                             )
                         continue
 
@@ -171,21 +183,21 @@ class InteractivePrompt:
 
         return result
 
-    async def _get_all_prompts(self, list_prompts_func, agent_name):
+    async def _get_all_prompts(self, prompt_provider: PromptProvider, agent_name: Optional[str] = None):
         """
         Get a list of all available prompts.
 
         Args:
-            list_prompts_func: Function to get available prompts
-            agent_name: Name of the agent
+            prompt_provider: Provider that implements list_prompts
+            agent_name: Optional agent name (for multi-agent apps)
 
         Returns:
             List of prompt info dictionaries, sorted by server and name
         """
         try:
-            # Pass None instead of agent_name to get prompts from all servers
-            # the agent_name parameter should never be used as a server name
-            prompt_servers = await list_prompts_func(None)
+            # Call list_prompts on the provider
+            prompt_servers = await prompt_provider.list_prompts(server_name=None, agent_name=agent_name)
+            
             all_prompts = []
 
             # Process the returned prompt servers
@@ -219,14 +231,18 @@ class InteractivePrompt:
                                     }
                                 )
                             else:
+                                # Handle Prompt objects from mcp.types
+                                prompt_name = getattr(prompt, "name", str(prompt))
+                                description = getattr(prompt, "description", "No description")
+                                arguments = getattr(prompt, "arguments", [])
                                 all_prompts.append(
                                     {
                                         "server": server_name,
-                                        "name": str(prompt),
-                                        "namespaced_name": f"{server_name}{SEP}{str(prompt)}",
-                                        "description": "No description",
-                                        "arg_count": 0,
-                                        "arguments": [],
+                                        "name": prompt_name,
+                                        "namespaced_name": f"{server_name}{SEP}{prompt_name}",
+                                        "description": description,
+                                        "arg_count": len(arguments),
+                                        "arguments": arguments,
                                     }
                                 )
 
@@ -244,27 +260,22 @@ class InteractivePrompt:
             rich_print(f"[dim]{traceback.format_exc()}[/dim]")
             return []
 
-    async def _list_prompts(self, list_prompts_func, agent_name) -> None:
+    async def _list_prompts(self, prompt_provider: PromptProvider, agent_name: str) -> None:
         """
         List available prompts for an agent.
 
         Args:
-            list_prompts_func: Function to get available prompts
+            prompt_provider: Provider that implements list_prompts
             agent_name: Name of the agent
         """
-        from rich import print as rich_print
-        from rich.console import Console
-        from rich.table import Table
-
         console = Console()
 
         try:
             # Directly call the list_prompts function for this agent
             rich_print(f"\n[bold]Fetching prompts for agent [cyan]{agent_name}[/cyan]...[/bold]")
 
-            # Get all prompts using the helper function - pass None as server name
-            # to get prompts from all available servers
-            all_prompts = await self._get_all_prompts(list_prompts_func, None)
+            # Get all prompts using the helper function
+            all_prompts = await self._get_all_prompts(prompt_provider, agent_name)
 
             if all_prompts:
                 # Create a table for better display
@@ -300,28 +311,24 @@ class InteractivePrompt:
             rich_print(f"[dim]{traceback.format_exc()}[/dim]")
 
     async def _select_prompt(
-        self, list_prompts_func, apply_prompt_func, agent_name, requested_name=None
+        self, prompt_provider: PromptProvider, agent_name: str, requested_name: Optional[str] = None
     ) -> None:
         """
         Select and apply a prompt.
 
         Args:
-            list_prompts_func: Function to get available prompts
-            apply_prompt_func: Function to apply prompts
+            prompt_provider: Provider that implements list_prompts and apply_prompt
             agent_name: Name of the agent
             requested_name: Optional name of the prompt to apply
         """
-        # We already imported these at the top
-        from rich import print as rich_print
-
         console = Console()
 
         try:
-            # Get all available prompts directly from the list_prompts function
+            # Get all available prompts directly from the prompt provider
             rich_print(f"\n[bold]Fetching prompts for agent [cyan]{agent_name}[/cyan]...[/bold]")
-            # IMPORTANT: list_prompts_func gets MCP server prompts, not agent prompts
-            # So we pass None to get prompts from all servers, not using agent_name as server name
-            prompt_servers = await list_prompts_func(None)
+            
+            # Call list_prompts on the provider
+            prompt_servers = await prompt_provider.list_prompts(server_name=None, agent_name=agent_name)
 
             if not prompt_servers:
                 rich_print("[yellow]No prompts available for this agent[/yellow]")
@@ -542,8 +549,8 @@ class InteractivePrompt:
             namespaced_name = selected_prompt["namespaced_name"]
             rich_print(f"\n[bold]Applying prompt [cyan]{namespaced_name}[/cyan]...[/bold]")
 
-            # Call apply_prompt function with the prompt name and arguments
-            await apply_prompt_func(namespaced_name, arg_values, agent_name)
+            # Call apply_prompt on the provider with the prompt name and arguments
+            await prompt_provider.apply_prompt(namespaced_name, arg_values, agent_name)
 
         except Exception as e:
             import traceback

fast_agent_mcp-0.2.28/src/mcp_agent/llm/augmented_llm_slow.py

@@ -0,0 +1,42 @@
+import asyncio
+from typing import Any, List, Optional, Union
+
+from mcp_agent.llm.augmented_llm import (
+    MessageParamT,
+    RequestParams,
+)
+from mcp_agent.llm.augmented_llm_passthrough import PassthroughLLM
+from mcp_agent.llm.provider_types import Provider
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+
+
+class SlowLLM(PassthroughLLM):
+    """
+    A specialized LLM implementation that sleeps for 3 seconds before responding like PassthroughLLM.
+
+    This is useful for testing scenarios where you want to simulate slow responses
+    or for debugging timing-related issues in parallel workflows.
+    """
+
+    def __init__(
+        self, provider=Provider.FAST_AGENT, name: str = "Slow", **kwargs: dict[str, Any]
+    ) -> None:
+        super().__init__(name=name, provider=provider, **kwargs)
+
+    async def generate_str(
+        self,
+        message: Union[str, MessageParamT, List[MessageParamT]],
+        request_params: Optional[RequestParams] = None,
+    ) -> str:
+        """Sleep for 3 seconds then return the input message as a string."""
+        await asyncio.sleep(3)
+        return await super().generate_str(message, request_params)
+
+    async def _apply_prompt_provider_specific(
+        self,
+        multipart_messages: List["PromptMessageMultipart"],
+        request_params: RequestParams | None = None,
+    ) -> PromptMessageMultipart:
+        """Sleep for 3 seconds then apply prompt like PassthroughLLM."""
+        await asyncio.sleep(3)
+        return await super()._apply_prompt_provider_specific(multipart_messages, request_params)

{fast_agent_mcp-0.2.27 → fast_agent_mcp-0.2.28}/src/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