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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.43
+Version: 0.2.45
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>
 License:                                  Apache License
@@ -218,17 +218,18 @@ Requires-Dist: deprecated>=1.2.18
 Requires-Dist: email-validator>=2.2.0
 Requires-Dist: fastapi>=0.115.6
 Requires-Dist: google-genai
-Requires-Dist: mcp==1.10.1
+Requires-Dist: mcp==1.12.0
 Requires-Dist: openai>=1.93.0
 Requires-Dist: opentelemetry-distro>=0.50b0
 Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.29.0
-Requires-Dist: opentelemetry-instrumentation-anthropic>=0.40.14; python_version >= '3.10' and python_version < '4.0'
+Requires-Dist: opentelemetry-instrumentation-anthropic>=0.42.0; python_version >= '3.10' and python_version < '4.0'
 Requires-Dist: opentelemetry-instrumentation-google-genai>=0.2b0
-Requires-Dist: opentelemetry-instrumentation-mcp>=0.40.14; python_version >= '3.10' and python_version < '4.0'
-Requires-Dist: opentelemetry-instrumentation-openai>=0.40.14; python_version >= '3.10' and python_version < '4.0'
+Requires-Dist: opentelemetry-instrumentation-mcp>=0.42.0; python_version >= '3.10' and python_version < '4.0'
+Requires-Dist: opentelemetry-instrumentation-openai>=0.42.0; python_version >= '3.10' and python_version < '4.0'
 Requires-Dist: prompt-toolkit>=3.0.50
 Requires-Dist: pydantic-settings>=2.7.0
 Requires-Dist: pydantic>=2.10.4
+Requires-Dist: pyperclip>=1.9.0
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=13.9.4
 Requires-Dist: tensorzero>=2025.6.3

{fast_agent_mcp-0.2.43/src/mcp_agent/resources → fast_agent_mcp-0.2.45}/examples/workflows/evaluator.py

@@ -18,7 +18,7 @@ fast = FastAgent("Evaluator-Optimizer")
     candidate details, and company information. Tailor the response to the company and job requirements.
     """,
     servers=["fetch"],
-    model="haiku3",
+    model="gpt-4.1-nano",
     use_history=True,
 )
 # Define evaluator agent
@@ -40,7 +40,7 @@ fast = FastAgent("Evaluator-Optimizer")
     Summarize your evaluation as a structured response with:
     - Overall quality rating.
     - Specific feedback and areas for improvement.""",
-    model="gpt-4.1",
+    model="sonnet",
 )
 # Define the evaluator-optimizer workflow
 @fast.evaluator_optimizer(

{fast_agent_mcp-0.2.43/src/mcp_agent/resources → fast_agent_mcp-0.2.45}/examples/workflows/router.py

@@ -43,7 +43,7 @@ SAMPLE_REQUESTS = [
 )
 @fast.router(
     name="route",
-    model="sonnet",
+    model="gpt-4.1",
     agents=["code_expert", "general_assistant", "fetcher"],
 )
 async def main() -> None:

{fast_agent_mcp-0.2.43 → fast_agent_mcp-0.2.45}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.2.43"
+version = "0.2.45"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -15,7 +15,7 @@ classifiers = [
 requires-python = ">=3.12"
 dependencies = [
     "fastapi>=0.115.6",
-    "mcp==1.10.1",
+    "mcp==1.12.0",
     "opentelemetry-distro>=0.50b0",
     "opentelemetry-exporter-otlp-proto-http>=1.29.0",
     "pydantic-settings>=2.7.0",
@@ -29,15 +29,16 @@ dependencies = [
     "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'",
-    "opentelemetry-instrumentation-anthropic>=0.40.14; python_version >= '3.10' and python_version < '4.0'",
-    "opentelemetry-instrumentation-mcp>=0.40.14; python_version >= '3.10' and python_version < '4.0'",
+    "opentelemetry-instrumentation-openai>=0.42.0; python_version >= '3.10' and python_version < '4.0'",
+    "opentelemetry-instrumentation-anthropic>=0.42.0; python_version >= '3.10' and python_version < '4.0'",
+    "opentelemetry-instrumentation-mcp>=0.42.0; python_version >= '3.10' and python_version < '4.0'",
     "google-genai",
     "opentelemetry-instrumentation-google-genai>=0.2b0",
     "tensorzero>=2025.6.3",
     "deprecated>=1.2.18",
     "a2a-sdk>=0.2.9",
     "email-validator>=2.2.0",
+    "pyperclip>=1.9.0",
 ]
 
 [project.optional-dependencies]

{fast_agent_mcp-0.2.43 → fast_agent_mcp-0.2.45}/src/mcp_agent/agents/base_agent.py

@@ -330,12 +330,12 @@ class BaseAgent(MCPAggregator, AgentProtocol):
     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
         """
@@ -343,7 +343,7 @@ class BaseAgent(MCPAggregator, AgentProtocol):
         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)
 
@@ -365,9 +365,9 @@ class BaseAgent(MCPAggregator, AgentProtocol):
             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]
-                    
+                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
@@ -495,48 +495,70 @@ class BaseAgent(MCPAggregator, AgentProtocol):
 
     async def apply_prompt(
         self,
-        prompt_name: str,
+        prompt: Union[str, GetPromptResult],
         arguments: Dict[str, str] | None = None,
         agent_name: str | None = None,
         server_name: str | None = None,
+        as_template: bool = False,
     ) -> str:
         """
-        Apply an MCP Server Prompt by name and return the assistant's response.
+        Apply an MCP Server Prompt by name or GetPromptResult and return the assistant's response.
         Will search all available servers for the prompt if not namespaced and no server_name provided.
 
         If the last message in the prompt is from a user, this will automatically
         generate an assistant response to ensure we always end with an assistant message.
 
         Args:
-            prompt_name: The name of the prompt to apply
+            prompt: The name of the prompt to apply OR a GetPromptResult object
             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
+            as_template: If True, store as persistent template (always included in context)
 
         Returns:
             The assistant's response or error message
         """
 
-        # Get the prompt - this will search all servers if needed
-        self.logger.debug(f"Loading prompt '{prompt_name}'")
-        prompt_result: GetPromptResult = await self.get_prompt(prompt_name, arguments, server_name)
+        # Handle both string and GetPromptResult inputs
+        if isinstance(prompt, str):
+            prompt_name = prompt
+            # Get the prompt - this will search all servers if needed
+            self.logger.debug(f"Loading prompt '{prompt_name}'")
+            prompt_result: GetPromptResult = await self.get_prompt(
+                prompt_name, arguments, server_name
+            )
+
+            if not prompt_result or not prompt_result.messages:
+                error_msg = f"Prompt '{prompt_name}' could not be found or contains no messages"
+                self.logger.warning(error_msg)
+                return error_msg
 
-        if not prompt_result or not prompt_result.messages:
-            error_msg = f"Prompt '{prompt_name}' could not be found or contains no messages"
-            self.logger.warning(error_msg)
-            return error_msg
+            # Get the display name (namespaced version)
+            namespaced_name = getattr(prompt_result, "namespaced_name", prompt_name)
+        else:
+            # prompt is a GetPromptResult object
+            prompt_result = prompt
+            if not prompt_result or not prompt_result.messages:
+                error_msg = "Provided GetPromptResult contains no messages"
+                self.logger.warning(error_msg)
+                return error_msg
+
+            # Use a reasonable display name
+            namespaced_name = getattr(prompt_result, "namespaced_name", "provided_prompt")
 
-        # Get the display name (namespaced version)
-        namespaced_name = getattr(prompt_result, "namespaced_name", prompt_name)
         self.logger.debug(f"Using prompt '{namespaced_name}'")
 
         # Convert prompt messages to multipart format using the safer method
         multipart_messages = PromptMessageMultipart.from_get_prompt_result(prompt_result)
 
-        # Always call generate to ensure LLM implementations can handle prompt templates
-        # This is critical for stateful LLMs like PlaybackLLM
-        response = await self.generate(multipart_messages, None)
-        return response.first_text()
+        if as_template:
+            # Use apply_prompt_template to store as persistent prompt messages
+            return await self.apply_prompt_template(prompt_result, namespaced_name)
+        else:
+            # Always call generate to ensure LLM implementations can handle prompt templates
+            # This is critical for stateful LLMs like PlaybackLLM
+            response = await self.generate(multipart_messages, None)
+            return response.first_text()
 
     async def get_embedded_resources(
         self, resource_uri: str, server_name: str | None = None
@@ -636,6 +658,22 @@ class BaseAgent(MCPAggregator, AgentProtocol):
         with self.tracer.start_as_current_span(f"Agent: '{self.name}' generate"):
             return await self._llm.generate(multipart_messages, request_params)
 
+    async def apply_prompt_template(self, prompt_result: GetPromptResult, prompt_name: str) -> str:
+        """
+        Apply a prompt template as persistent context that will be included in all future conversations.
+        Delegates to the attached LLM.
+
+        Args:
+            prompt_result: The GetPromptResult containing prompt messages
+            prompt_name: The name of the prompt being applied
+
+        Returns:
+            String representation of the assistant's response if generated
+        """
+        assert self._llm
+        with self.tracer.start_as_current_span(f"Agent: '{self.name}' apply_prompt_template"):
+            return await self._llm.apply_prompt_template(prompt_result, prompt_name)
+
     async def structured(
         self,
         multipart_messages: List[PromptMessageMultipart],

{fast_agent_mcp-0.2.43 → fast_agent_mcp-0.2.45}/src/mcp_agent/agents/workflow/evaluator_optimizer.py

@@ -33,16 +33,14 @@ class QualityRating(str, Enum):
     GOOD = "GOOD"  # Minor improvements possible
     EXCELLENT = "EXCELLENT"  # No improvements needed
 
-    # Map string values to integer values for comparisons
-    @property
-    def value(self) -> int:
-        """Convert string enum values to integers for comparison."""
-        return {
-            "POOR": 0,
-            "FAIR": 1,
-            "GOOD": 2,
-            "EXCELLENT": 3,
-        }[self._value_]
+
+# Separate mapping for quality ratings to numerical values
+QUALITY_RATING_VALUES = {
+    QualityRating.POOR: 0,
+    QualityRating.FAIR: 1,
+    QualityRating.GOOD: 2,
+    QualityRating.EXCELLENT: 3,
+}
 
 
 class EvaluationResult(BaseModel):
@@ -140,7 +138,7 @@ class EvaluatorOptimizerAgent(BaseAgent):
 
             # Evaluate current response
             eval_prompt = self._build_eval_prompt(
-                request=request, response=response.all_text(), iteration=refinement_count
+                request=request, response=response.last_text(), iteration=refinement_count
             )
 
             # Create evaluation message and get structured evaluation result
@@ -171,7 +169,7 @@ class EvaluatorOptimizerAgent(BaseAgent):
             logger.debug(f"Evaluation result: {evaluation_result.rating}")
 
             # Track best response based on rating
-            if evaluation_result.rating.value > best_rating.value:
+            if QUALITY_RATING_VALUES[evaluation_result.rating] > QUALITY_RATING_VALUES[best_rating]:
                 best_rating = evaluation_result.rating
                 best_response = response
                 logger.debug(f"New best response (rating: {best_rating})")
@@ -183,14 +181,17 @@ class EvaluatorOptimizerAgent(BaseAgent):
                 best_response = response
                 break
 
-            if evaluation_result.rating.value >= self.min_rating.value:
+            if (
+                QUALITY_RATING_VALUES[evaluation_result.rating]
+                >= QUALITY_RATING_VALUES[self.min_rating]
+            ):
                 logger.debug(f"Acceptable quality reached ({evaluation_result.rating})")
                 break
 
             # Generate refined response
             refinement_prompt = self._build_refinement_prompt(
                 request=request,
-                response=response.all_text(),
+                response=response.last_text(),  ## only if there is no history?
                 feedback=evaluation_result,
                 iteration=refinement_count,
             )
@@ -270,48 +271,21 @@ class EvaluatorOptimizerAgent(BaseAgent):
         return f"""
 You are an expert evaluator for content quality. Your task is to evaluate a response against the user's original request.
 
-Evaluate the response for iteration {iteration + 1} and provide structured feedback on its quality and areas for improvement.
+Evaluate the response for iteration {iteration + 1} and provide feedback on its quality and areas for improvement.
 
+```
 <fastagent:data>
-<fastagent:request>
+    <fastagent:request>
 {request}
-</fastagent:request>
+    </fastagent:request>
 
-<fastagent:response>
+    <fastagent:response>
 {response}
-</fastagent:response>
+    </fastagent:response>
 </fastagent:data>
 
-<fastagent:instruction>
-Your response MUST be valid JSON matching this exact format (no other text, markdown, or explanation):
-
-{{
-  "rating": "RATING",
-  "feedback": "DETAILED FEEDBACK",
-  "needs_improvement": BOOLEAN,
-  "focus_areas": ["FOCUS_AREA_1", "FOCUS_AREA_2", "FOCUS_AREA_3"]
-}}
-
-Where:
-- RATING: Must be one of: "EXCELLENT", "GOOD", "FAIR", or "POOR"
-  - EXCELLENT: No improvements needed
-  - GOOD: Only minor improvements possible
-  - FAIR: Several improvements needed
-  - POOR: Major improvements needed
-- DETAILED FEEDBACK: Specific, actionable feedback (as a single string)
-- BOOLEAN: true or false (lowercase, no quotes) indicating if further improvement is needed
-- FOCUS_AREAS: Array of 1-3 specific areas to focus on (empty array if no improvement needed)
-
-Example of valid response (DO NOT include the triple backticks in your response):
-{{
-  "rating": "GOOD",
-  "feedback": "The response is clear but could use more supporting evidence.",
-  "needs_improvement": true,
-  "focus_areas": ["Add more examples", "Include data points"]
-}}
-
-IMPORTANT: Your response should be ONLY the JSON object without any code fences, explanations, or other text.
-</fastagent:instruction>
+```
+
 """
 
     def _build_refinement_prompt(
@@ -333,28 +307,27 @@ IMPORTANT: Your response should be ONLY the JSON object without any code fences,
         Returns:
             Formatted refinement prompt
         """
-        focus_areas = ", ".join(feedback.focus_areas) if feedback.focus_areas else "None specified"
+
+        # Format focus areas as bulleted list with each item on a separate line
+        if feedback.focus_areas:
+            focus_areas = "\n".join(f"      * {area}" for area in feedback.focus_areas)
+        else:
+            focus_areas = "None specified"
 
         return f"""
-You are tasked with improving a response based on expert feedback. This is iteration {iteration + 1} of the refinement process.
+You are tasked with improving your previous response based on expert feedback. This is iteration {iteration + 1} of the refinement process.
 
 Your goal is to address all feedback points while maintaining accuracy and relevance to the original request.
 
-<fastagent:data>
-<fastagent:request>
-{request}
-</fastagent:request>
-
-<fastagent:previous-response>
-{response}
-</fastagent:previous-response>
+```
 
 <fastagent:feedback>
-<rating>{feedback.rating}</rating>
-<details>{feedback.feedback}</details>
-<focus-areas>{focus_areas}</focus-areas>
+    <rating>{feedback.rating.name}</rating>
+    <details>{feedback.feedback}</details>
+    <focus-areas>
+{focus_areas}
+    </focus-areas>
 </fastagent:feedback>
-</fastagent:data>
 
 <fastagent:instruction>
 Create an improved version of the response that:
@@ -365,4 +338,7 @@ Create an improved version of the response that:
 
 Provide your complete improved response without explanations or commentary.
 </fastagent:instruction>
+
+```
+
 """

{fast_agent_mcp-0.2.43 → fast_agent_mcp-0.2.45}/src/mcp_agent/agents/workflow/router_agent.py

@@ -39,7 +39,7 @@ Follow these guidelines:
 """
 
 # Default routing instruction with placeholders for context (AgentCard JSON)
-DEFAULT_ROUTING_INSTRUCTION = """
+ROUTING_AGENT_INSTRUCTION = """
 Select from the following agents to handle the request:
 <fastagent:agents>
 [
@@ -100,7 +100,7 @@ class RouterAgent(BaseAgent):
         self.routing_instruction = routing_instruction
         self.agent_map = {agent.name: agent for agent in agents}
 
-        # Set up base router request parameters
+        # Set up base router request parameters with just the base instruction for now
         base_params = {"systemPrompt": ROUTING_SYSTEM_INSTRUCTION, "use_history": False}
 
         if default_request_params:
@@ -120,6 +120,18 @@ class RouterAgent(BaseAgent):
                 if not getattr(agent, "initialized", False):
                     await agent.initialize()
 
+            complete_routing_instruction = await self._generate_routing_instruction(
+                self.agents, self.routing_instruction
+            )
+
+            # Update the system prompt to include the routing instruction with agent cards
+            combined_system_prompt = (
+                ROUTING_SYSTEM_INSTRUCTION + "\n\n" + complete_routing_instruction
+            )
+            self._default_request_params.systemPrompt = combined_system_prompt
+            self.instruction = combined_system_prompt
+            self._routing_instruction_generated = True
+
             self.initialized = True
 
     async def shutdown(self) -> None:
@@ -133,6 +145,36 @@ class RouterAgent(BaseAgent):
             except Exception as e:
                 logger.warning(f"Error shutting down agent: {str(e)}")
 
+    @staticmethod
+    async def _generate_routing_instruction(
+        agents: List[Agent], routing_instruction: Optional[str] = None
+    ) -> str:
+        """
+        Generate the complete routing instruction with agent cards.
+
+        Args:
+            agents: List of agents to include in routing instruction
+            routing_instruction: Optional custom routing instruction template
+
+        Returns:
+            Complete routing instruction with agent cards formatted
+        """
+        # Generate agent descriptions
+        agent_descriptions = []
+        for agent in agents:
+            agent_card: AgentCard = await agent.agent_card()
+            agent_descriptions.append(
+                agent_card.model_dump_json(
+                    include={"name", "description", "skills"}, exclude_none=True
+                )
+            )
+
+        context = ",\n".join(agent_descriptions)
+
+        # Format the routing instruction
+        instruction_template = routing_instruction or ROUTING_AGENT_INSTRUCTION
+        return instruction_template.format(context=context)
+
     async def attach_llm(
         self,
         llm_factory: type[AugmentedLLMProtocol] | Callable[..., AugmentedLLMProtocol],
@@ -227,27 +269,10 @@ class RouterAgent(BaseAgent):
                 agent=self.agents[0].name, confidence="high", reasoning="Only one agent available"
             ), None
 
-        # Generate agent descriptions for the context
-        agent_descriptions = []
-        for agent in self.agents:
-            agent_card: AgentCard = await agent.agent_card()
-            agent_descriptions.append(
-                agent_card.model_dump_json(
-                    include={"name", "description", "skills"}, exclude_none=True
-                )
-            )
-
-        context = ",\n".join(agent_descriptions)
-
-        # Format the routing prompt
-        routing_instruction = self.routing_instruction or DEFAULT_ROUTING_INSTRUCTION
-        routing_instruction = routing_instruction.format(context=context)
-
         assert self._llm
-        mutated = message.model_copy(deep=True)
-        mutated.add_text(routing_instruction)
+        # No need to add routing instruction here - it's already in the system prompt
         response, _ = await self._llm.structured(
-            [mutated],
+            [message],
             RoutingResponse,
             self._default_request_params,
         )

{fast_agent_mcp-0.2.43 → fast_agent_mcp-0.2.45}/src/mcp_agent/config.py

@@ -319,6 +319,8 @@ class LoggerSettings(BaseModel):
     """Truncate display of long tool calls"""
     enable_markup: bool = True
     """Enable markup in console output. Disable for outputs that may conflict with rich console formatting"""
+    use_legacy_display: bool = False
+    """Use the legacy console display instead of the new style display"""
 
 
 def find_fastagent_config_files(start_path: Path) -> Tuple[Optional[Path], Optional[Path]]:

{fast_agent_mcp-0.2.43 → fast_agent_mcp-0.2.45}/src/mcp_agent/context.py

@@ -10,7 +10,11 @@ from typing import TYPE_CHECKING, Any, Optional, Union
 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
 from opentelemetry.sdk.resources import Resource

{fast_agent_mcp-0.2.43 → fast_agent_mcp-0.2.45}/src/mcp_agent/core/agent_app.py

@@ -5,7 +5,7 @@ Direct AgentApp implementation for interacting with agents without proxies.
 from typing import Dict, List, Optional, Union
 
 from deprecated import deprecated
-from mcp.types import PromptMessage
+from mcp.types import GetPromptResult, PromptMessage
 from rich import print as rich_print
 
 from mcp_agent.agents.agent import Agent
@@ -108,22 +108,26 @@ class AgentApp:
 
     async def apply_prompt(
         self,
-        prompt_name: str,
+        prompt: Union[str, GetPromptResult],
         arguments: Dict[str, str] | None = None,
         agent_name: str | None = None,
+        as_template: bool = False,
     ) -> str:
         """
         Apply a prompt template to an agent (default agent if not specified).
 
         Args:
-            prompt_name: Name of the prompt template to apply
+            prompt: Name of the prompt template to apply OR a GetPromptResult object
             arguments: Optional arguments for the prompt template
             agent_name: Name of the agent to send to
+            as_template: If True, store as persistent template (always included in context)
 
         Returns:
             The agent's response as a string
         """
-        return await self._agent(agent_name).apply_prompt(prompt_name, arguments)
+        return await self._agent(agent_name).apply_prompt(
+            prompt, arguments, as_template=as_template
+        )
 
     async def list_prompts(self, server_name: str | None = None, agent_name: str | None = None):
         """
@@ -235,7 +239,12 @@ class AgentApp:
         """
         return await self.interactive(agent_name=agent_name, default_prompt=default_prompt)
 
-    async def interactive(self, agent_name: str | None = None, default_prompt: str = "", pretty_print_parallel: bool = False) -> str:
+    async def interactive(
+        self,
+        agent_name: str | None = None,
+        default_prompt: str = "",
+        pretty_print_parallel: bool = False,
+    ) -> str:
         """
         Interactive prompt for sending messages with advanced features.
 
@@ -283,6 +292,7 @@ class AgentApp:
                 agent = self._agents.get(agent_name)
                 if agent and agent.agent_type == AgentType.PARALLEL:
                     from mcp_agent.ui.console_display import ConsoleDisplay
+
                     display = ConsoleDisplay(config=None)
                     display.show_parallel_results(agent)
 

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

@@ -23,6 +23,9 @@ from typing import (
 from mcp.client.session import ElicitationFnT
 
 from mcp_agent.agents.agent import AgentConfig
+from mcp_agent.agents.workflow.router_agent import (
+    ROUTING_SYSTEM_INSTRUCTION,
+)
 from mcp_agent.core.agent_types import AgentType
 from mcp_agent.core.request_params import RequestParams
 
@@ -397,10 +400,6 @@ def router(
     Returns:
         A decorator that registers the router with proper type annotations
     """
-    default_instruction = """
-    You are a router that determines which specialized agent should handle a given query.
-    Analyze the query and select the most appropriate agent to handle it.
-    """
 
     return cast(
         "Callable[[AgentCallable[P, R]], DecoratedRouterProtocol[P, R]]",
@@ -408,7 +407,7 @@ def router(
             self,
             AgentType.ROUTER,
             name=name,
-            instruction=instruction or default_instruction,
+            instruction=instruction or ROUTING_SYSTEM_INSTRUCTION,
             servers=servers,
             model=model,
             use_history=use_history,