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

{fast_agent_mcp-0.2.26 → 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.26 → fast_agent_mcp-0.2.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.26
+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: mcp==1.8.0
+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.26 → fast_agent_mcp-0.2.28}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.2.26"
+version = "0.2.28"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -15,7 +15,7 @@ classifiers = [
 requires-python = ">=3.10"
 dependencies = [
     "fastapi>=0.115.6",
-    "mcp==1.8.0",
+    "mcp==1.9.1",
     "opentelemetry-distro>=0.50b0",
     "opentelemetry-exporter-otlp-proto-http>=1.29.0",
     "pydantic-settings>=2.7.0",
@@ -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.26 → 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.26 → 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.26 → 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.26 → 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.26 → 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.26 → 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)