fast-agent-mcp 0.2.40__tar.gz → 0.2.42__tar.gz

{fast_agent_mcp-0.2.40 → fast_agent_mcp-0.2.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.40
+Version: 0.2.42
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>
 License:                                  Apache License
@@ -213,6 +213,7 @@ Requires-Dist: a2a-sdk>=0.2.9
 Requires-Dist: aiohttp>=3.11.13
 Requires-Dist: anthropic>=0.55.0
 Requires-Dist: azure-identity>=1.14.0
+Requires-Dist: boto3>=1.35.0
 Requires-Dist: deprecated>=1.2.18
 Requires-Dist: email-validator>=2.2.0
 Requires-Dist: fastapi>=0.115.6

fast_agent_mcp-0.2.42/examples/bedrock/fast-agent.config.yaml

@@ -0,0 +1,13 @@
+# Example minimalfast-agent.config.yaml for Bedrock
+
+# List of supported models: https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
+default_model: bedrock.amazon.nova-lite-v1:0
+
+# Bedrock uses the AWS credentials provider chain to authenticate.
+# This can be accomplished with aws sso login on local machines,
+# or by IAM roles within AWS.
+# see https://docs.aws.amazon.com/res/latest/ug/sso-idc.html
+bedrock:
+  region: "us-east-1" # required
+  profile: "default"  # optional, defaults to "default" - only needed if you have multiple profiles. 
+                      # Only needed on local machines, not on AWS.

{fast_agent_mcp-0.2.40 → fast_agent_mcp-0.2.42}/examples/mcp/elicitations/forms_demo.py

@@ -51,8 +51,6 @@ async def main():
         else:
             console.print("[red]No registration data received[/red]")
 
-        console.print("\n" + "─" * 50 + "\n")
-
         # Example 2: Product Review
         console.print("[bold yellow]Example 2: Product Review Form[/bold yellow]")
         console.print(
@@ -66,8 +64,6 @@ async def main():
             )
             console.print(review_panel)
 
-        console.print("\n" + "─" * 50 + "\n")
-
         # Example 3: Account Settings
         console.print("[bold yellow]Example 3: Account Settings Form[/bold yellow]")
         console.print(
@@ -81,8 +77,6 @@ async def main():
             )
             console.print(settings_panel)
 
-        console.print("\n" + "─" * 50 + "\n")
-
         # Example 4: Service Appointment
         console.print("[bold yellow]Example 4: Service Appointment Booking[/bold yellow]")
         console.print(

fast_agent_mcp-0.2.42/examples/mcp/mcp-filtering/fastagent.config.yaml

@@ -0,0 +1,6 @@
+mcp:
+  servers:
+    # name used in agent servers array
+    creativity:
+      command: "uv"
+      args: ["run", "mcp_server.py"]

fast_agent_mcp-0.2.42/examples/mcp/mcp-filtering/fastagent.secrets.yaml.example

@@ -0,0 +1,16 @@
+# FastAgent Secrets Configuration
+# WARNING: Keep this file secure and never commit to version control
+
+# Alternatively set OPENAI_API_KEY, ANTHROPIC_API_KEY or other environment variables.
+# Keys in the configuration file override environment variables.
+
+openai:
+  api_key: <your-api-key-here>
+anthropic:
+  api_key: <your-api-key-here>
+deepseek:
+  api_key: <your-api-key-here>
+openrouter:
+  api_key: <your-api-key-here>
+
+default_model: <choose a default model for your provider>

fast_agent_mcp-0.2.42/examples/mcp/mcp-filtering/mcp_server.py

@@ -0,0 +1,127 @@
+import random
+import string
+
+from mcp.server.fastmcp import FastMCP
+
+app = FastMCP(name="Creative Writing Server")
+
+# String manipulation tools
+@app.tool(
+    name="reverse_string",
+    description="Reverses a string",
+)
+def reverse_string(text: str) -> str:
+    return text[::-1]
+
+@app.tool(
+    name="capitalize_string",
+    description="Capitalizes a string",
+)
+def capitalize_string(text: str) -> str:
+    return text.upper()
+
+@app.tool(
+    name="lowercase_string",
+    description="Converts a string to lowercase",
+)
+def lowercase_string(text: str) -> str:
+    return text.lower()
+
+@app.tool(
+    name="random_string",
+    description="Generates a random string of a given length",
+)
+def random_string(length: int) -> str:
+    return ''.join(random.choices(string.ascii_letters + string.digits, k=length))
+
+@app.tool(
+    name="random_case_string",
+    description="Randomly capitalizes or lowercase each letter in a string",
+)
+def random_case_string(text: str) -> str:
+    return ''.join(random.choice([str.upper, str.lower])(c) for c in text)
+
+# Code formatting tools
+@app.tool(
+    name="coding_camel_case",
+    description="Converts a string to camel case",
+)
+def coding_camel_case(text: str) -> str:
+    return text.title().replace(" ", "")
+
+@app.tool(
+    name="coding_snake_case",
+    description="Converts a string to snake case",
+)
+def coding_snake_case(text: str) -> str:
+    return text.lower().replace(" ", "_")
+
+@app.tool(
+    name="coding_kebab_case",
+    description="Converts a string to kebab case",
+)
+def coding_kebab_case(text: str) -> str:
+    return text.lower().replace(" ", "-")
+
+# Resources
+@app.resource("resource://writing/style_guide")
+def writing_style_guide() -> str:
+    return """Writing Style Guide:
+1. Use active voice when possible
+2. Keep sentences concise and clear
+3. Vary sentence structure for rhythm
+4. Use strong, specific verbs
+5. Avoid excessive adverbs"""
+
+@app.resource("resource://writing/character_names")
+def character_names() -> str:
+    return """Character Name Ideas:
+Fantasy: Eldara, Thorne, Zephyr, Lyanna
+Modern: Alex, Jordan, Riley, Cameron
+Historical: Eleanor, Benedict, Cordelia, Jasper
+Sci-fi: Zara, Kai, Nova, Orion"""
+
+@app.resource("resource://coding/conventions")
+def coding_conventions() -> str:
+    return """Coding Conventions:
+- Variables: snake_case
+- Functions: snake_case
+- Classes: PascalCase
+- Constants: UPPER_CASE
+- Files: lowercase with hyphens"""
+
+@app.resource("resource://creativity/prompts")
+def creativity_prompts() -> str:
+    return """Creative Writing Prompts:
+1. A character discovers they can hear colors
+2. The last person on Earth receives a phone call
+3. A library where books come to life at night
+4. Time moves backwards for one day only
+5. A world where lies become physical objects"""
+
+# Prompts
+@app.prompt("writing_assistant")
+def writing_assistant(genre: str = "general") -> str:
+    """Creative writing assistant for different genres"""
+    return f"I am a creative writing assistant specialized in {genre} writing. I can help you with story structure, character development, dialogue, and prose improvement."
+
+@app.prompt("writing_feedback")
+def writing_feedback(focus: str = "overall") -> str:
+    """Provides feedback on written work"""
+    return f"I am a writing coach focused on {focus} feedback. I'll provide constructive criticism and suggestions to improve your writing."
+
+@app.prompt("coding_helper")
+def coding_helper(language: str = "python") -> str:
+    """Coding assistant for formatting and conventions"""
+    return f"I am a coding assistant specialized in {language}. I can help you with code formatting, naming conventions, and best practices."
+
+@app.prompt("creative_brainstorm")
+def creative_brainstorm(topic: str = "general") -> str:
+    """Brainstorming assistant for creative projects"""
+    return f"I am a creative brainstorming assistant focused on {topic}. I can help you generate ideas, explore concepts, and overcome creative blocks."
+
+
+
+if __name__ == "__main__":
+    # Run in stdio mode
+    app.run()

fast_agent_mcp-0.2.42/examples/mcp/mcp-filtering/test_mcp_filtering.py

@@ -0,0 +1,96 @@
+import asyncio
+import sys
+
+from mcp_agent.core.fastagent import FastAgent, PromptExitError
+
+fast_agent = FastAgent(
+    name="MCP Filtering Demo",
+    parse_cli_args=False,
+    quiet=False
+)
+
+@fast_agent.agent(
+    name="filtered_agent",    
+    model="gpt-4o-mini",
+    instruction="You are a creative writer with filtered access to tools, resources, and prompts.",
+    servers=["creativity"],
+    # Tool filtering: only string manipulation tools and coding tools
+    tools={"creativity": ["reverse_string", "capitalize_string", "coding_*"]},
+    # Resource filtering: only writing resources (not coding resources)
+    resources={"creativity": ["resource://writing/*"]},
+    # Prompt filtering: only writing prompts (not coding prompts)
+    prompts={"creativity": ["writing_*"]}
+)
+async def filtered_agent():
+    return "Filtered agent ready"
+
+@fast_agent.agent(
+    name="unfiltered_agent",
+    model="gpt-4o-mini", 
+    instruction="You are a creative writer with access to all tools, resources, and prompts.",
+    servers=["creativity"]
+    # No filtering - gets everything
+)
+async def unfiltered_agent():
+    return "Unfiltered agent ready"
+
+async def main():
+    try:
+        async with fast_agent.run() as agent:
+            try:
+                print("🎯 MCP Filtering Demo")
+                print("=" * 50)
+                
+                # Show filtered agent capabilities
+                print("\n📦 FILTERED AGENT:")
+                filtered = agent._agent("filtered_agent")
+                
+                tools = await filtered.list_tools()
+                print(f"✅ Available tools ({len(tools.tools)}): {[tool.name for tool in tools.tools]}")
+                
+                resources = await filtered.list_resources()
+                resource_list = resources.get("creativity", [])
+                print(f"📚 Available resources ({len(resource_list)}): {resource_list}")
+                
+                prompts = await filtered.list_prompts()
+                prompt_list = prompts.get("creativity", [])
+                prompt_names = [p.name for p in prompt_list]
+                print(f"💬 Available prompts ({len(prompt_names)}): {prompt_names}")
+                
+                # Show unfiltered agent capabilities
+                print("\n🌐 UNFILTERED AGENT:")
+                unfiltered = agent._agent("unfiltered_agent")
+                
+                tools = await unfiltered.list_tools()
+                print(f"✅ Available tools ({len(tools.tools)}): {[tool.name for tool in tools.tools]}")
+                
+                resources = await unfiltered.list_resources()
+                resource_list = resources.get("creativity", [])
+                print(f"📚 Available resources ({len(resource_list)}): {resource_list}")
+                
+                prompts = await unfiltered.list_prompts()
+                prompt_list = prompts.get("creativity", [])
+                prompt_names = [p.name for p in prompt_list]
+                print(f"💬 Available prompts ({len(prompt_names)}): {prompt_names}")
+                
+                print("\n" + "=" * 50)
+                print("🚀 Starting interactive session with filtered agent...")
+                print("Type 'exit' to quit")
+                
+                await agent.interactive(agent_name="filtered_agent")
+
+            except PromptExitError:
+                print("👋 Goodbye!")
+                
+    except KeyboardInterrupt:
+        print("\nExiting...")
+        sys.exit(0)
+    except Exception as e:
+        print(f"Error: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{fast_agent_mcp-0.2.40/src/mcp_agent/resources → fast_agent_mcp-0.2.42}/examples/workflows/router.py

@@ -7,6 +7,8 @@ Demonstrates router's ability to either:
 
 import asyncio
 
+from rich.console import Console
+
 from mcp_agent.core.fastagent import FastAgent
 
 # Create the application
@@ -45,7 +47,14 @@ SAMPLE_REQUESTS = [
     agents=["code_expert", "general_assistant", "fetcher"],
 )
 async def main() -> None:
+    console = Console()
+    console.print(
+        "\n[bright_red]Router Workflow Demo[/bright_red]\n\n"
+        "Enter a request to route it to the appropriate agent.\nEnter [bright_red]STOP[/bright_red] to run the demo, [bright_red]EXIT[/bright_red] to leave"
+    )
+
     async with fast.run() as agent:
+        await agent.interactive(agent_name="route")
         for request in SAMPLE_REQUESTS:
             await agent.route(request)
 

{fast_agent_mcp-0.2.40 → fast_agent_mcp-0.2.42}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.2.40"
+version = "0.2.42"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -26,6 +26,7 @@ dependencies = [
     "anthropic>=0.55.0",
     "openai>=1.93.0",
     "azure-identity>=1.14.0",
+    "boto3>=1.35.0",
     "prompt-toolkit>=3.0.50",
     "aiohttp>=3.11.13",
     "opentelemetry-instrumentation-openai>=0.40.14; python_version >= '3.10' and python_version < '4.0'",
@@ -108,8 +109,8 @@ dev = [
 ]
 
 [project.scripts]
-fast-agent = "mcp_agent.cli.__main__:app"
-fast-agent-mcp = "mcp_agent.cli.__main__:app"
+fast-agent = "mcp_agent.cli.__main__:main"
+fast-agent-mcp = "mcp_agent.cli.__main__:main"
 fastagent = "mcp_agent.cli.__main__:app"
 silsila = "mcp_agent.cli.__main__:app"
 prompt-server = "mcp_agent.mcp.prompts.__main__:main"

{fast_agent_mcp-0.2.40 → fast_agent_mcp-0.2.42}/src/mcp_agent/agents/base_agent.py

@@ -6,6 +6,7 @@ and delegates operations to an attached AugmentedLLMProtocol instance.
 """
 
 import asyncio
+import fnmatch
 import uuid
 from typing import (
     TYPE_CHECKING,
@@ -13,6 +14,7 @@ from typing import (
     Callable,
     Dict,
     List,
+    Mapping,
     Optional,
     Tuple,
     Type,
@@ -325,9 +327,29 @@ class BaseAgent(MCPAggregator, AgentProtocol):
         self.logger.debug("Received human input signal", data=result)
         return result
 
+    def _matches_pattern(self, name: str, pattern: str, server_name: str) -> bool:
+        """
+        Check if a name matches a pattern for a specific server.
+        
+        Args:
+            name: The name to match (could be tool name, resource URI, or prompt name)
+            pattern: The pattern to match against (e.g., "add", "math*", "resource://math/*")
+            server_name: The server name (used for tool name prefixing)
+            
+        Returns:
+            True if the name matches the pattern
+        """
+        # For tools, build the full pattern with server prefix: server_name-pattern
+        if name.startswith(f"{server_name}-"):
+            full_pattern = f"{server_name}-{pattern}"
+            return fnmatch.fnmatch(name, full_pattern)
+        
+        # For resources and prompts, match directly against the pattern
+        return fnmatch.fnmatch(name, pattern)
+
     async def list_tools(self) -> ListToolsResult:
         """
-        List all tools available to this agent.
+        List all tools available to this agent, filtered by configuration.
 
         Returns:
             ListToolsResult with available tools
@@ -335,8 +357,26 @@ class BaseAgent(MCPAggregator, AgentProtocol):
         if not self.initialized:
             await self.initialize()
 
+        # Get all tools from the parent class
         result = await super().list_tools()
 
+        # Apply filtering if tools are specified in config
+        if self.config.tools is not None:
+            filtered_tools = []
+            for tool in result.tools:
+                # Extract server name from tool name (e.g., "mathematics-add" -> "mathematics")
+                if '-' in tool.name:
+                    server_name = tool.name.split('-', 1)[0]
+                    
+                    # Check if this server has tool filters
+                    if server_name in self.config.tools:
+                        # Check if tool matches any pattern for this server
+                        for pattern in self.config.tools[server_name]:
+                            if self._matches_pattern(tool.name, pattern, server_name):
+                                filtered_tools.append(tool)
+                                break
+            result.tools = filtered_tools
+
         if not self.human_input_callback:
             return result
 
@@ -635,6 +675,76 @@ class BaseAgent(MCPAggregator, AgentProtocol):
         response = await self.generate(prompts, request_params)
         return response.first_text()
 
+    async def list_prompts(self, server_name: str | None = None) -> Mapping[str, List[Prompt]]:
+        """
+        List all prompts available to this agent, filtered by configuration.
+
+        Args:
+            server_name: Optional server name to list prompts from
+
+        Returns:
+            Dictionary mapping server names to lists of Prompt objects
+        """
+        if not self.initialized:
+            await self.initialize()
+
+        # Get all prompts from the parent class
+        result = await super().list_prompts(server_name)
+
+        # Apply filtering if prompts are specified in config
+        if self.config.prompts is not None:
+            filtered_result = {}
+            for server, prompts in result.items():
+                # Check if this server has prompt filters
+                if server in self.config.prompts:
+                    filtered_prompts = []
+                    for prompt in prompts:
+                        # Check if prompt matches any pattern for this server
+                        for pattern in self.config.prompts[server]:
+                            if self._matches_pattern(prompt.name, pattern, server):
+                                filtered_prompts.append(prompt)
+                                break
+                    if filtered_prompts:
+                        filtered_result[server] = filtered_prompts
+            result = filtered_result
+
+        return result
+
+    async def list_resources(self, server_name: str | None = None) -> Dict[str, List[str]]:
+        """
+        List all resources available to this agent, filtered by configuration.
+
+        Args:
+            server_name: Optional server name to list resources from
+
+        Returns:
+            Dictionary mapping server names to lists of resource URIs
+        """
+        if not self.initialized:
+            await self.initialize()
+
+        # Get all resources from the parent class
+        result = await super().list_resources(server_name)
+
+        # Apply filtering if resources are specified in config
+        if self.config.resources is not None:
+            filtered_result = {}
+            for server, resources in result.items():
+                # Check if this server has resource filters
+                if server in self.config.resources:
+                    filtered_resources = []
+                    for resource in resources:
+                        # Check if resource matches any pattern for this server
+                        for pattern in self.config.resources[server]:
+                            if self._matches_pattern(resource, pattern, server):
+                                filtered_resources.append(resource)
+                                break
+                    if filtered_resources:
+                        filtered_result[server] = filtered_resources
+            result = filtered_result
+
+        return result
+
     @property
     def agent_type(self) -> AgentType:
         """

fast_agent_mcp-0.2.42/src/mcp_agent/cli/__main__.py

@@ -0,0 +1,33 @@
+import sys
+
+from mcp_agent.cli.constants import GO_SPECIFIC_OPTIONS, KNOWN_SUBCOMMANDS
+from mcp_agent.cli.main import app
+
+# if the arguments would work with "go" we'll just route to it
+
+
+def main():
+    """Main entry point that handles auto-routing to 'go' command."""
+    # Check if we should auto-route to 'go'
+    if len(sys.argv) > 1:
+        # Check if first arg is not already a subcommand
+        first_arg = sys.argv[1]
+
+        if first_arg not in KNOWN_SUBCOMMANDS and any(
+            arg in sys.argv or any(arg.startswith(opt + "=") for opt in GO_SPECIFIC_OPTIONS)
+            for arg in sys.argv
+        ):
+            # Find where to insert 'go' - before the first go-specific option
+            insert_pos = 1
+            for i, arg in enumerate(sys.argv[1:], 1):
+                if arg in GO_SPECIFIC_OPTIONS or any(arg.startswith(opt + "=") for opt in GO_SPECIFIC_OPTIONS):
+                    insert_pos = i
+                    break
+            # Auto-route to go command
+            sys.argv.insert(insert_pos, "go")
+
+    app()
+
+
+if __name__ == "__main__":
+    main()