fast-agent-mcp 0.2.41__tar.gz → 0.2.43__tar.gz

{fast_agent_mcp-0.2.41 → fast_agent_mcp-0.2.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.41
+Version: 0.2.43
 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.43/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.43/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.43/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.43/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.43/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.41 → fast_agent_mcp-0.2.43}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.2.41"
+version = "0.2.43"
 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'",

{fast_agent_mcp-0.2.41 → fast_agent_mcp-0.2.43}/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.41 → fast_agent_mcp-0.2.43}/src/mcp_agent/config.py

@@ -253,6 +253,20 @@ class TensorZeroSettings(BaseModel):
     model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
 
 
+class BedrockSettings(BaseModel):
+    """
+    Settings for using AWS Bedrock models in the fast-agent application.
+    """
+
+    region: str | None = None
+    """AWS region for Bedrock service"""
+
+    profile: str | None = None
+    """AWS profile to use for authentication"""
+
+    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+
+
 class HuggingFaceSettings(BaseModel):
     """
     Settings for HuggingFace authentication (used for MCP connections).
@@ -419,6 +433,9 @@ class Settings(BaseSettings):
     aliyun: OpenAISettings | None = None
     """Settings for using Aliyun OpenAI Service in the fast-agent application"""
 
+    bedrock: BedrockSettings | None = None
+    """Settings for using AWS Bedrock models in the fast-agent application"""
+
     huggingface: HuggingFaceSettings | None = None
     """Settings for HuggingFace authentication (used for MCP connections)"""
 

{fast_agent_mcp-0.2.41 → fast_agent_mcp-0.2.43}/src/mcp_agent/core/agent_types.py

@@ -4,7 +4,7 @@ Type definitions for agents and agent configurations.
 
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import List
+from typing import Dict, List, Optional
 
 from mcp.client.session import ElicitationFnT
 
@@ -31,6 +31,9 @@ class AgentConfig:
     name: str
     instruction: str = "You are a helpful agent."
     servers: List[str] = field(default_factory=list)
+    tools: Optional[Dict[str, List[str]]] = None
+    resources: Optional[Dict[str, List[str]]] = None
+    prompts: Optional[Dict[str, List[str]]] = None
     model: str | None = None
     use_history: bool = True
     default_request_params: RequestParams | None = None

{fast_agent_mcp-0.2.41 → fast_agent_mcp-0.2.43}/src/mcp_agent/core/direct_decorators.py

@@ -9,6 +9,7 @@ from functools import wraps
 from typing import (
     Awaitable,
     Callable,
+    Dict,
     List,
     Literal,
     Optional,
@@ -93,6 +94,9 @@ def _decorator_impl(
     request_params: RequestParams | None = None,
     human_input: bool = False,
     default: bool = False,
+    tools: Optional[Dict[str, List[str]]] = None,
+    resources: Optional[Dict[str, List[str]]] = None,
+    prompts: Optional[Dict[str, List[str]]] = None,
     **extra_kwargs,
 ) -> Callable[[AgentCallable[P, R]], DecoratedAgentProtocol[P, R]]:
     """
@@ -133,6 +137,9 @@ def _decorator_impl(
             name=name,
             instruction=instruction,
             servers=servers,
+            tools=tools,
+            resources=resources,
+            prompts=prompts,
             model=model,
             use_history=use_history,
             human_input=human_input,
@@ -177,6 +184,9 @@ def agent(
     *,
     instruction: str = "You are a helpful agent.",
     servers: List[str] = [],
+    tools: Optional[Dict[str, List[str]]] = None,
+    resources: Optional[Dict[str, List[str]]] = None,
+    prompts: Optional[Dict[str, List[str]]] = None,
     model: Optional[str] = None,
     use_history: bool = True,
     request_params: RequestParams | None = None,
@@ -193,12 +203,16 @@ def agent(
         instruction_or_kwarg: Optional positional parameter for instruction
         instruction: Base instruction for the agent (keyword arg)
         servers: List of server names the agent should connect to
+        tools: Optional list of tool names or patterns to include
+        resources: Optional list of resource names or patterns to include
+        prompts: Optional list of prompt names or patterns to include
         model: Model specification string
         use_history: Whether to maintain conversation history
         request_params: Additional request parameters for the LLM
         human_input: Whether to enable human input capabilities
         default: Whether to mark this as the default agent
         elicitation_handler: Custom elicitation handler function (ElicitationFnT)
+        api_key: Optional API key for the LLM provider
 
     Returns:
         A decorator that registers the agent with proper type annotations
@@ -217,6 +231,9 @@ def agent(
         human_input=human_input,
         default=default,
         elicitation_handler=elicitation_handler,
+        tools=tools,
+        resources=resources,
+        prompts=prompts,
         api_key=api_key,
     )
 
@@ -229,6 +246,9 @@ def custom(
     *,
     instruction: str = "You are a helpful agent.",
     servers: List[str] = [],
+    tools: Optional[Dict[str, List[str]]] = None,
+    resources: Optional[Dict[str, List[str]]] = None,
+    prompts: Optional[Dict[str, List[str]]] = None,
     model: Optional[str] = None,
     use_history: bool = True,
     request_params: RequestParams | None = None,
@@ -270,6 +290,9 @@ def custom(
         default=default,
         elicitation_handler=elicitation_handler,
         api_key=api_key,
+        tools=tools,
+        resources=resources,
+        prompts=prompts,
     )
 
 
@@ -344,6 +367,9 @@ def router(
     agents: List[str],
     instruction: Optional[str] = None,
     servers: List[str] = [],
+    tools: Optional[Dict[str, List[str]]] = None,
+    resources: Optional[Dict[str, List[str]]] = None,
+    prompts: Optional[Dict[str, List[str]]] = None,
     model: Optional[str] = None,
     use_history: bool = False,
     request_params: RequestParams | None = None,
@@ -392,6 +418,9 @@ def router(
             router_agents=agents,
             elicitation_handler=elicitation_handler,
             api_key=api_key,
+            tools=tools,
+            prompts=prompts,
+            resources=resources,
         ),
     )
 

{fast_agent_mcp-0.2.41 → fast_agent_mcp-0.2.43}/src/mcp_agent/core/enhanced_prompt.py

@@ -68,6 +68,11 @@ async def _display_agent_info_helper(agent_name: str, agent_provider: object) ->
             len(tools_result.tools) if tools_result and hasattr(tools_result, "tools") else 0
         )
 
+        resources_dict = await agent.list_resources()
+        resource_count = (
+            sum(len(resources) for resources in resources_dict.values()) if resources_dict else 0
+        )
+
         prompts_dict = await agent.list_prompts()
         prompt_count = sum(len(prompts) for prompts in prompts_dict.values()) if prompts_dict else 0
 
@@ -104,10 +109,11 @@ async def _display_agent_info_helper(agent_name: str, agent_provider: object) ->
                 # Pluralization helpers
                 server_word = "Server" if server_count == 1 else "Servers"
                 tool_word = "tool" if tool_count == 1 else "tools"
+                resource_word = "resource" if resource_count == 1 else "resources"
                 prompt_word = "prompt" if prompt_count == 1 else "prompts"
 
                 rich_print(
-                    f"[dim]Agent [/dim][blue]{agent_name}[/blue][dim]:[/dim] {server_count:,}[dim] MCP {server_word}, [/dim]{tool_count:,}[dim] {tool_word}, [/dim]{prompt_count:,}[dim] {prompt_word} available[/dim]"
+                    f"[dim]Agent [/dim][blue]{agent_name}[/blue][dim]:[/dim] {server_count:,}[dim] MCP {server_word}, [/dim]{tool_count:,}[dim] {tool_word}, [/dim]{resource_count:,}[dim] {resource_word}, [/dim]{prompt_count:,}[dim] {prompt_word} available[/dim]"
                 )
 
         # Mark as shown
@@ -221,6 +227,11 @@ async def _display_child_agent_info(child_agent, prefix: str, agent_provider) ->
             len(tools_result.tools) if tools_result and hasattr(tools_result, "tools") else 0
         )
 
+        resources_dict = await child_agent.list_resources()
+        resource_count = (
+            sum(len(resources) for resources in resources_dict.values()) if resources_dict else 0
+        )
+
         prompts_dict = await child_agent.list_prompts()
         prompt_count = sum(len(prompts) for prompts in prompts_dict.values()) if prompts_dict else 0
 
@@ -229,10 +240,11 @@ async def _display_child_agent_info(child_agent, prefix: str, agent_provider) ->
             # Pluralization helpers
             server_word = "Server" if server_count == 1 else "Servers"
             tool_word = "tool" if tool_count == 1 else "tools"
+            resource_word = "resource" if resource_count == 1 else "resources"
             prompt_word = "prompt" if prompt_count == 1 else "prompts"
 
             rich_print(
-                f"[dim]  {prefix} [/dim][blue]{child_agent.name}[/blue][dim]:[/dim] {server_count:,}[dim] MCP {server_word}, [/dim]{tool_count:,}[dim] {tool_word}, [/dim]{prompt_count:,}[dim] {prompt_word} available[/dim]"
+                f"[dim]  {prefix} [/dim][blue]{child_agent.name}[/blue][dim]:[/dim] {server_count:,}[dim] MCP {server_word}, [/dim]{tool_count:,}[dim] {tool_word}, [/dim]{resource_count:,}[dim] {resource_word}, [/dim]{prompt_count:,}[dim] {prompt_word} available[/dim]"
             )
         else:
             # Show child even without MCP servers for context