fast-agent-mcp 0.2.44__py3-none-any.whl → 0.2.45__py3-none-any.whl

{fast_agent_mcp-0.2.44.dist-info → fast_agent_mcp-0.2.45.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.44
+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
@@ -222,10 +222,10 @@ 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

{fast_agent_mcp-0.2.44.dist-info → fast_agent_mcp-0.2.45.dist-info}/RECORD

@@ -2,7 +2,7 @@ mcp_agent/__init__.py,sha256=18T0AG0W9sJhTY38O9GFFOzliDhxx9p87CvRyti9zbw,1620
 mcp_agent/app.py,sha256=3mtHP1nRQcRaKhhxgTmCOv00alh70nT7UxNA8bN47QE,5560
 mcp_agent/config.py,sha256=RjwgvR-Sys4JIzhNyEsaS_NarCe157RenJLOsioUtDk,18980
 mcp_agent/console.py,sha256=Gjf2QLFumwG1Lav__c07X_kZxxEUSkzV-1_-YbAwcwo,813
-mcp_agent/context.py,sha256=9s1F1-UfcI8rz9Yxm6EXHZ4cInuE_cOl_HFu8N8k3yc,7497
+mcp_agent/context.py,sha256=lzz_Fyf9lz9BBAUt1bRVBlyyHjLkyeuyIziAi4qXYUk,7639
 mcp_agent/context_dependent.py,sha256=QXfhw3RaQCKfscEEBRGuZ3sdMWqkgShz2jJ1ivGGX1I,1455
 mcp_agent/event_progress.py,sha256=d7T1hQ1D289MYh2Z5bMPB4JqjGqTOzveJuOHE03B_Xo,3720
 mcp_agent/mcp_server_registry.py,sha256=lmz-aES-l7Gbg4itDF0iCmpso_KD8bVazVKSVzjwNE4,12398
@@ -12,12 +12,12 @@ mcp_agent/agents/agent.py,sha256=EAYlcP1qqI1D0_CS808I806z1048FBjZQxxpcCZPeIU,315
 mcp_agent/agents/base_agent.py,sha256=VCBWJ-l1zMQiBuONGzqcbqPUQfXK4oq-pBB5lJrMgQ0,32318
 mcp_agent/agents/workflow/__init__.py,sha256=HloteEW6kalvgR0XewpiFAqaQlMPlPJYg5p3K33IUzI,25
 mcp_agent/agents/workflow/chain_agent.py,sha256=eIlImirrSXkqBJmPuAJgOKis81Cl6lZEGM0-6IyaUV8,6105
-mcp_agent/agents/workflow/evaluator_optimizer.py,sha256=ysUMGM2NzeCIutgr_vXH6kUPpZMw0cX4J_Wl1r8eT84,13296
+mcp_agent/agents/workflow/evaluator_optimizer.py,sha256=LT81m2B7fxgBZY0CorXFOZJbVhM5fnjDjfrcywO5UrM,12210
 mcp_agent/agents/workflow/orchestrator_agent.py,sha256=lArV7wHwPYepSuxe0ybTGJRJv85iebRI4ZOY_m8kMZQ,21593
 mcp_agent/agents/workflow/orchestrator_models.py,sha256=5P_aXADVT4Et8qT4e1cb9RelmHX5dCRrzu8j8T41Kdg,7230
 mcp_agent/agents/workflow/orchestrator_prompts.py,sha256=EXKEI174sshkZyPPEnWbwwNafzSPuA39MXL7iqG9cWc,9106
 mcp_agent/agents/workflow/parallel_agent.py,sha256=JaQFp35nmAdoBRLAwx8BfnK7kirVq9PMw24LQ3ZEzoc,7705
-mcp_agent/agents/workflow/router_agent.py,sha256=6tvI5D_ssKNZ6-tNxYHmw6r6DAQMYgqz3PZKZz2rC44,9466
+mcp_agent/agents/workflow/router_agent.py,sha256=DYxld96C_xy2TXtZDHPB0CaJqyX-7p0LpsfjkZV6-3o,10517
 mcp_agent/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/cli/__main__.py,sha256=KyZnfXkml0KsOnfy8T9JDYNVNynKix9cslwuafmKNbc,1089
 mcp_agent/cli/constants.py,sha256=KawdkaN289nVB02DKPB4IVUJ8-fohIUD0gLfOp0P7B8,551
@@ -32,9 +32,9 @@ mcp_agent/cli/commands/url_parser.py,sha256=5VdtcHRHzi67YignStVbz7u-rcvNNErw9oJL
 mcp_agent/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/core/agent_app.py,sha256=SolGwejEmv9XtsTsmiMkNKPia7RN1VcHXm6JoEo4hvQ,16187
 mcp_agent/core/agent_types.py,sha256=7zVzAFWjvh5dDV3TuDwmO9LAWmDjYnZd3eeLH-wvvIQ,1705
-mcp_agent/core/direct_decorators.py,sha256=sYoEA1EmdyAxTpQwUDUjQYWY73VviM-fBnV1Zv7KfeU,19047
+mcp_agent/core/direct_decorators.py,sha256=zWnfs4sxONw_7UOno62ERb0gezMgV_AIOfxb0tRQg3w,18939
 mcp_agent/core/direct_factory.py,sha256=d_HvbAxyv2WrM07zyCpLXFVn7eArXk1LZmLKS49hzJo,19537
-mcp_agent/core/enhanced_prompt.py,sha256=e3FA0_70kw4HRxXCYQs5sO0qzvsM47pc6UG186okXtk,36324
+mcp_agent/core/enhanced_prompt.py,sha256=ZIeJCeW7rcGMBZ2OdEQwqOmRT0wNSp0hO2-dZRSnnLE,36068
 mcp_agent/core/error_handling.py,sha256=xoyS2kLe0eG0bj2eSJCJ2odIhGUve2SbDR7jP-A-uRw,624
 mcp_agent/core/exceptions.py,sha256=ENAD_qGG67foxy6vDkIvc-lgopIUQy6O7zvNPpPXaQg,2289
 mcp_agent/core/fastagent.py,sha256=qA64fwmJ6TVFEvmj6l-oTWPD28Js5zJvdDnPjH-agzQ,25117
@@ -49,15 +49,15 @@ mcp_agent/executor/executor.py,sha256=E44p6d-o3OMRoP_dNs_cDnyti91LQ3P9eNU88mSi1k
 mcp_agent/executor/task_registry.py,sha256=PCALFeYtkQrPBg4RBJnlA0aDI8nHclrNkHGUS4kV3W8,1242
 mcp_agent/executor/workflow_signal.py,sha256=Cg1uZBk3fn8kXhPOg-wINNuVaf3v9pvLD6NbqWy5Z6E,11142
 mcp_agent/human_input/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mcp_agent/human_input/elicitation_form.py,sha256=s9rrX-qKxKZ91Uf-wjmrRIKgqDP-gdn6_1xOwizyJno,28158
+mcp_agent/human_input/elicitation_form.py,sha256=VgS-DXlwYTU4qDntok4Pqt8qfl1w_-Xby5PTlfNerug,28324
 mcp_agent/human_input/elicitation_forms.py,sha256=w8XQ1GfZX8Jw-VB4jnDI0Im4mF-T9Ts8mT2zRZBtL6M,3824
 mcp_agent/human_input/elicitation_handler.py,sha256=YfVhIhSBc9wuszPS4zoHho4n1pwmIoq13huN4MSRkIs,3305
 mcp_agent/human_input/elicitation_state.py,sha256=Unl9uhEybUqACCUimnETdfUprJNpYDMq3DdbbHw5oAw,1175
 mcp_agent/human_input/handler.py,sha256=s712Z5ssTCwjL9-VKoIdP5CtgMh43YvepynYisiWTTA,3144
 mcp_agent/human_input/types.py,sha256=RtWBOVzy8vnYoQrc36jRLn8z8N3C4pDPMBN5vF6qM5Y,1476
 mcp_agent/llm/__init__.py,sha256=d8zgwG-bRFuwiMNMYkywg_qytk4P8lawyld_meuUmHI,68
-mcp_agent/llm/augmented_llm.py,sha256=FwH3nFwtqX9JJiwsHWvBCwDRooAMUhVM258-rUMheRI,27568
-mcp_agent/llm/augmented_llm_passthrough.py,sha256=-Pu_cW5p7gKyc6E7OT7lG642RyAFkv-uj6U-JwKpOPE,9421
+mcp_agent/llm/augmented_llm.py,sha256=UiOTOAaNVnc03yuLBbBZstnaOG6Q8XLwkyiHPA3yxEk,27434
+mcp_agent/llm/augmented_llm_passthrough.py,sha256=bu0DJkjyFPzBZEU7f6MHnOp__9BCYl56tFd5nZVhSeY,8808
 mcp_agent/llm/augmented_llm_playback.py,sha256=BQeBXRpO-xGAY9wIJxyde6xpHmZEdQPLd32frF8t3QQ,4916
 mcp_agent/llm/augmented_llm_silent.py,sha256=IUnK_1Byy4D9TG0Pj46LFeNezgSTQ8d6MQIHWAImBwE,1846
 mcp_agent/llm/augmented_llm_slow.py,sha256=DDSD8bL2flmQrVHZm-UDs7sR8aHRWkDOcOW-mX_GPok,2067
@@ -73,7 +73,7 @@ mcp_agent/llm/usage_tracking.py,sha256=rF6v8QQDam8QbvlP4jzHljKqvuNHExeYDLkUMI86c
 mcp_agent/llm/providers/__init__.py,sha256=heVxtmuqFJOnjjxHz4bWSqTAxXoN1E8twC_gQ_yJpHk,265
 mcp_agent/llm/providers/anthropic_utils.py,sha256=vYDN5G5jKMhD2CQg8veJYab7tvvzYkDMq8M1g_hUAQg,3275
 mcp_agent/llm/providers/augmented_llm_aliyun.py,sha256=XylkJKZ9theSVUxJKOZkf1244hgzng4Ng4Dr209Qb-w,1101
-mcp_agent/llm/providers/augmented_llm_anthropic.py,sha256=kmzJ_45eMerUkGZ7Mzy544SLpxcUbfOnAr0h_mHktcs,23980
+mcp_agent/llm/providers/augmented_llm_anthropic.py,sha256=l32pJ3yo0oVv7ELaoi1aCSV2TDGhBuYf0AKwW0lgjPs,30359
 mcp_agent/llm/providers/augmented_llm_azure.py,sha256=sBVWgY88F4OsdRSHl71BAT2p3XPvuZp844z1ubwcV7U,6098
 mcp_agent/llm/providers/augmented_llm_bedrock.py,sha256=nfby1udL07zPTOLlN_tFxd1h0JRioo2oIW7v4iP4Bnk,82267
 mcp_agent/llm/providers/augmented_llm_deepseek.py,sha256=zI9a90dwT4r6E1f_xp4K50Cj9sD7y7kNRgjo0s1pd5w,3804
@@ -150,20 +150,20 @@ mcp_agent/resources/examples/researcher/researcher-eval.py,sha256=CR9m4lyoXijS1w
 mcp_agent/resources/examples/researcher/researcher-imp.py,sha256=oJxSVnLbZfIn71QbQR1E6j_m_UBrOOGP4SVljXErHLQ,7879
 mcp_agent/resources/examples/researcher/researcher.py,sha256=SZfExi-FfwYETzGt2O3caS3L5E6EemV3IUrJHyzZqHI,1333
 mcp_agent/resources/examples/workflows/chaining.py,sha256=tY0kA0U8s2rceAO4ogZFtpQEkiUWcrYnYDgHu_-4G50,889
-mcp_agent/resources/examples/workflows/evaluator.py,sha256=pZckGkulwZguSkEaQFejXyZQm143LU_sHqUtCB_m_dA,3096
+mcp_agent/resources/examples/workflows/evaluator.py,sha256=XJXrk5r1hrJzfZAMtQ7WIggy6qPttMJG1yqxYELO7C4,3101
 mcp_agent/resources/examples/workflows/fastagent.config.yaml,sha256=qaxk-p7Pl7JepdL3a7BTl0CIp4LHCXies7pFdVWS9xk,783
 mcp_agent/resources/examples/workflows/graded_report.md,sha256=QVF38xEtDIO1a2P-xv2hlBEG6KKYughtFkzDhY2NpzE,2726
 mcp_agent/resources/examples/workflows/human_input.py,sha256=_I6nS6xYo8IHAmvzsUYOxqVGb4G6BTyJXPAmS3fNcBU,621
 mcp_agent/resources/examples/workflows/orchestrator.py,sha256=5Jxfe0s3ai4qRpVXm3DaqtkDvjeWD2CcysW36J6JA-M,2521
 mcp_agent/resources/examples/workflows/parallel.py,sha256=OTWhX33uum_rspAzrSf3uCTj7b67Kvw3UUU8nsosz4g,1839
-mcp_agent/resources/examples/workflows/router.py,sha256=56FX7JhZ6ERafWGoVhspoalT1kkfkfbb5P-6MTFDamA,2032
+mcp_agent/resources/examples/workflows/router.py,sha256=vmw8aBitByi5PRFIvjYWWn2GUtAPiwzl7juN3kmRqvw,2033
 mcp_agent/resources/examples/workflows/short_story.md,sha256=XN9I2kzCcMmke3dE5F2lyRH5iFUZUQ8Sy-hS3rm_Wlc,1153
 mcp_agent/resources/examples/workflows/short_story.txt,sha256=X3y_1AyhLFN2AKzCKvucJtDgAFIJfnlbsbGZO5bBWu0,1187
 mcp_agent/tools/tool_definition.py,sha256=L3Pxl-uLEXqlVoo-bYuFTFALeI-2pIU44YgFhsTKEtM,398
-mcp_agent/ui/console_display.py,sha256=2G8hv4Ig70IHCHvw7FK-ksDcp9UHqbUYU-Y64_j0Nuk,25826
+mcp_agent/ui/console_display.py,sha256=cv-dvpJT7-zd7d8nqlcDLKfYg9_pDEQQOt7rGnDvj54,26057
 mcp_agent/ui/console_display_legacy.py,sha256=sm2v61-IPVafbF7uUaOyhO2tW_zgFWOjNS83IEWqGgI,14931
-fast_agent_mcp-0.2.44.dist-info/METADATA,sha256=lvZvAbFvs2tbNpHi35Cbh_PgeyNtWFTnI8Fa8RHpXyQ,31044
-fast_agent_mcp-0.2.44.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fast_agent_mcp-0.2.44.dist-info/entry_points.txt,sha256=QaX5kLdI0VdMPRdPUF1nkG_WdLUTNjp_icW6e3EhNYU,232
-fast_agent_mcp-0.2.44.dist-info/licenses/LICENSE,sha256=Gx1L3axA4PnuK4FxsbX87jQ1opoOkSFfHHSytW6wLUU,10935
-fast_agent_mcp-0.2.44.dist-info/RECORD,,
+fast_agent_mcp-0.2.45.dist-info/METADATA,sha256=xdue1zGI50YjprDUaZUnOlO4vW-S02iGdK6dKh5Cq74,31041
+fast_agent_mcp-0.2.45.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fast_agent_mcp-0.2.45.dist-info/entry_points.txt,sha256=QaX5kLdI0VdMPRdPUF1nkG_WdLUTNjp_icW6e3EhNYU,232
+fast_agent_mcp-0.2.45.dist-info/licenses/LICENSE,sha256=Gx1L3axA4PnuK4FxsbX87jQ1opoOkSFfHHSytW6wLUU,10935
+fast_agent_mcp-0.2.45.dist-info/RECORD,,

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>
+
+```
+
 """

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,
         )

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

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,

mcp_agent/core/enhanced_prompt.py

@@ -511,13 +511,12 @@ def create_keybindings(on_toggle_multiline=None, app=None, agent_provider=None,
                             rich_print("\n[green]✓ Copied to clipboard[/green]")
                             return
 
-                    rich_print("\n[yellow]No assistant messages found[/yellow]")
                 else:
-                    rich_print("\n[yellow]No message history available[/yellow]")
-            except Exception as e:
-                rich_print(f"\n[red]Error copying: {e}[/red]")
+                    pass
+            except Exception:
+                pass
         else:
-            rich_print("[yellow]Clipboard copy not available in this context[/yellow]")
+            pass
 
     return kb
 

mcp_agent/human_input/elicitation_form.py

@@ -5,6 +5,7 @@ from typing import Any, Dict, Optional
 
 from mcp.types import ElicitRequestedSchema
 from prompt_toolkit import Application
+from prompt_toolkit.application.current import get_app
 from prompt_toolkit.buffer import Buffer
 from prompt_toolkit.filters import Condition
 from prompt_toolkit.formatted_text import FormattedText
@@ -272,29 +273,32 @@ class ElicitationForm:
             keep_focused_window_visible=True,
         )
 
-        # Create title bar manually
-        title_bar = Window(
-            FormattedTextControl(FormattedText([("class:title", "Elicitation Request")])),
-            height=1,
-            style="class:dialog.title",
-        )
-
-        # Combine title, sticky headers, and scrollable content
+        # Combine sticky headers and scrollable content (no separate title bar needed)
         full_content = HSplit(
             [
-                title_bar,
-                Window(height=1),  # Spacing after title
+                Window(height=1),  # Top spacing
                 sticky_headers,  # Headers stay fixed at top
                 scrollable_content,  # Form fields can scroll
             ]
         )
 
-        # Create dialog frame manually to avoid Dialog's internal scrolling
+        # Create dialog frame with title
         dialog = Frame(
             body=full_content,
+            title="Elicitation Request",
             style="class:dialog",
         )
 
+        # Apply width constraints by putting Frame in VSplit with flexible spacers
+        # This prevents console display interference and constrains the Frame border
+        constrained_dialog = VSplit(
+            [
+                Window(width=10),  # Smaller left spacer
+                dialog,
+                Window(width=10),  # Smaller right spacer
+            ]
+        )
+
         # Key bindings
         kb = KeyBindings()
 
@@ -370,7 +374,7 @@ class ElicitationForm:
         # Add toolbar to the layout
         root_layout = HSplit(
             [
-                dialog,  # The main dialog
+                constrained_dialog,  # The width-constrained dialog
                 self._toolbar_window,
             ]
         )
@@ -588,7 +592,6 @@ class ElicitationForm:
 
     def _is_in_multiline_field(self) -> bool:
         """Check if currently focused field is a multiline field."""
-        from prompt_toolkit.application.current import get_app
 
         focused = get_app().layout.current_control
 

mcp_agent/llm/augmented_llm.py

@@ -212,8 +212,6 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         # note - check changes here are mirrored in structured(). i've thought hard about
         # a strategy to reduce duplication etc, but aiming for simple but imperfect for the moment
 
-        # We never expect this for structured() calls - this is for interactive use - developers
-        # can do this programatically
         # TODO -- create a "fast-agent" control role rather than magic strings
 
         if multipart_messages[-1].first_text().startswith("***SAVE_HISTORY"):
@@ -235,6 +233,7 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
 
         # add generic error and termination reason handling/rollback
         self._message_history.append(assistant_response)
+
         return assistant_response
 
     @abstractmethod

mcp_agent/llm/augmented_llm_passthrough.py

@@ -164,15 +164,10 @@ class PassthroughLLM(AugmentedLLM):
         request_params: RequestParams | None = None,
         is_template: bool = False,
     ) -> PromptMessageMultipart:
-        print(
-            f"DEBUG: PassthroughLLM _apply_prompt_provider_specific called with {len(multipart_messages)} messages, is_template={is_template}"
-        )
-
         # Add messages to history with proper is_prompt flag
         self.history.extend(multipart_messages, is_prompt=is_template)
 
         last_message = multipart_messages[-1]
-        print(f"DEBUG: Last message role: {last_message.role}, text: '{last_message.first_text()}'")
 
         if self.is_tool_call(last_message):
             result = Prompt.assistant(await self.generate_str(last_message.first_text()))
@@ -209,14 +204,8 @@ class PassthroughLLM(AugmentedLLM):
         else:
             # TODO -- improve when we support Audio/Multimodal gen models e.g. gemini . This should really just return the input as "assistant"...
             concatenated: str = "\n".join(message.all_text() for message in multipart_messages)
-            print(
-                f"DEBUG: PassthroughLLM generating response: '{concatenated}' (is_template={is_template})"
-            )
             await self.show_assistant_message(concatenated)
             result = Prompt.assistant(concatenated)
-            print(f"DEBUG: PassthroughLLM created result: {result}")
-            print(f"DEBUG: Result first_text(): {result.first_text()}")
-            print(f"DEBUG: Result content: {result.content}")
 
         # Track usage for this passthrough "turn"
         try:

mcp_agent/llm/providers/augmented_llm_anthropic.py

@@ -1,4 +1,5 @@
-from typing import TYPE_CHECKING, List, Tuple, Type
+import json
+from typing import TYPE_CHECKING, Any, List, Tuple, Type
 
 from mcp.types import TextContent
 
@@ -33,6 +34,7 @@ from anthropic.types import (
 from mcp.types import (
     CallToolRequest,
     CallToolRequestParams,
+    CallToolResult,
     ContentBlock,
 )
 from rich.text import Text
@@ -99,6 +101,184 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
             cache_mode = self.context.config.anthropic.cache_mode
         return cache_mode
 
+    async def _prepare_tools(self, structured_model: Type[ModelT] | None = None) -> List[ToolParam]:
+        """Prepare tools based on whether we're in structured output mode."""
+        if structured_model:
+            # JSON mode - create a single tool for structured output
+            return [
+                ToolParam(
+                    name="return_structured_output",
+                    description="Return the response in the required JSON format",
+                    input_schema=structured_model.model_json_schema(),
+                )
+            ]
+        else:
+            # Regular mode - use tools from aggregator
+            tool_list: ListToolsResult = await self.aggregator.list_tools()
+            return [
+                ToolParam(
+                    name=tool.name,
+                    description=tool.description or "",
+                    input_schema=tool.inputSchema,
+                )
+                for tool in tool_list.tools
+            ]
+
+    def _apply_system_cache(self, base_args: dict, cache_mode: str) -> None:
+        """Apply cache control to system prompt if cache mode allows it."""
+        if cache_mode != "off" and base_args["system"]:
+            if isinstance(base_args["system"], str):
+                base_args["system"] = [
+                    {
+                        "type": "text",
+                        "text": base_args["system"],
+                        "cache_control": {"type": "ephemeral"},
+                    }
+                ]
+                self.logger.debug(
+                    "Applied cache_control to system prompt (caches tools+system in one block)"
+                )
+            else:
+                self.logger.debug(f"System prompt is not a string: {type(base_args['system'])}")
+
+    async def _apply_conversation_cache(self, messages: List[MessageParam], cache_mode: str) -> int:
+        """Apply conversation caching if in auto mode. Returns number of cache blocks applied."""
+        applied_count = 0
+        if cache_mode == "auto" and self.history.should_apply_conversation_cache():
+            cache_updates = self.history.get_conversation_cache_updates()
+
+            # Remove cache control from old positions
+            if cache_updates["remove"]:
+                self.history.remove_cache_control_from_messages(messages, cache_updates["remove"])
+                self.logger.debug(
+                    f"Removed conversation cache_control from positions {cache_updates['remove']}"
+                )
+
+            # Add cache control to new positions
+            if cache_updates["add"]:
+                applied_count = self.history.add_cache_control_to_messages(
+                    messages, cache_updates["add"]
+                )
+                if applied_count > 0:
+                    self.history.apply_conversation_cache_updates(cache_updates)
+                    self.logger.debug(
+                        f"Applied conversation cache_control to positions {cache_updates['add']} ({applied_count} blocks)"
+                    )
+                else:
+                    self.logger.debug(
+                        f"Failed to apply conversation cache_control to positions {cache_updates['add']}"
+                    )
+
+        return applied_count
+
+    async def _process_structured_output(
+        self,
+        content_block: Any,
+    ) -> Tuple[str, CallToolResult, TextContent]:
+        """
+        Process a structured output tool call from Anthropic.
+
+        This handles the special case where Anthropic's model was forced to use
+        a 'return_structured_output' tool via tool_choice. The tool input contains
+        the JSON data we want, so we extract it and format it for display.
+
+        Even though we don't call an external tool, we must create a CallToolResult
+        to satisfy Anthropic's API requirement that every tool_use has a corresponding
+        tool_result in the next message.
+
+        Returns:
+            Tuple of (tool_use_id, tool_result, content_block) for the structured data
+        """
+        tool_args = content_block.input
+        tool_use_id = content_block.id
+
+        # Show the formatted JSON response to the user
+        json_response = json.dumps(tool_args, indent=2)
+        await self.show_assistant_message(json_response)
+
+        # Create the content for responses
+        structured_content = TextContent(type="text", text=json.dumps(tool_args))
+
+        # Create a CallToolResult to satisfy Anthropic's API requirements
+        # This represents the "result" of our structured output "tool"
+        tool_result = CallToolResult(isError=False, content=[structured_content])
+
+        return tool_use_id, tool_result, structured_content
+
+    async def _process_regular_tool_call(
+        self,
+        content_block: Any,
+        available_tools: List[ToolParam],
+        is_first_tool: bool,
+        message_text: str | Text,
+    ) -> Tuple[str, CallToolResult]:
+        """
+        Process a regular MCP tool call.
+
+        This handles actual tool execution via the MCP aggregator.
+        """
+        tool_name = content_block.name
+        tool_args = content_block.input
+        tool_use_id = content_block.id
+
+        if is_first_tool:
+            await self.show_assistant_message(message_text, tool_name)
+
+        self.show_tool_call(available_tools, tool_name, tool_args)
+        tool_call_request = CallToolRequest(
+            method="tools/call",
+            params=CallToolRequestParams(name=tool_name, arguments=tool_args),
+        )
+        result = await self.call_tool(request=tool_call_request, tool_call_id=tool_use_id)
+        self.show_tool_result(result)
+        return tool_use_id, result
+
+    async def _process_tool_calls(
+        self,
+        tool_uses: List[Any],
+        available_tools: List[ToolParam],
+        message_text: str | Text,
+        structured_model: Type[ModelT] | None = None,
+    ) -> Tuple[List[Tuple[str, CallToolResult]], List[ContentBlock]]:
+        """
+        Process tool calls, handling both structured output and regular MCP tools.
+
+        For structured output mode:
+        - Extracts JSON data from the forced 'return_structured_output' tool
+        - Does NOT create fake CallToolResults
+        - Returns the JSON content directly
+
+        For regular tools:
+        - Calls actual MCP tools via the aggregator
+        - Returns real CallToolResults
+        """
+        tool_results = []
+        responses = []
+
+        for tool_idx, content_block in enumerate(tool_uses):
+            tool_name = content_block.name
+            is_first_tool = tool_idx == 0
+
+            if tool_name == "return_structured_output" and structured_model:
+                # Structured output: extract JSON, don't call external tools
+                (
+                    tool_use_id,
+                    tool_result,
+                    structured_content,
+                ) = await self._process_structured_output(content_block)
+                responses.append(structured_content)
+                # Add to tool_results to satisfy Anthropic's API requirement for tool_result messages
+                tool_results.append((tool_use_id, tool_result))
+            else:
+                # Regular tool: call external MCP tool
+                tool_use_id, tool_result = await self._process_regular_tool_call(
+                    content_block, available_tools, is_first_tool, message_text
+                )
+                tool_results.append((tool_use_id, tool_result))
+                responses.extend(tool_result.content)
+
+        return tool_results, responses
+
     async def _process_stream(self, stream: AsyncMessageStream, model: str) -> Message:
         """Process the streaming response and display real-time token usage."""
         # Track estimated output tokens by counting text chunks
@@ -150,6 +330,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         self,
         message_param,
         request_params: RequestParams | None = None,
+        structured_model: Type[ModelT] | None = None,
     ) -> list[ContentBlock]:
         """
         Process a query using an LLM and available tools.
@@ -181,15 +362,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         cache_mode = self._get_cache_mode()
         self.logger.debug(f"Anthropic cache_mode: {cache_mode}")
 
-        tool_list: ListToolsResult = await self.aggregator.list_tools()
-        available_tools: List[ToolParam] = [
-            ToolParam(
-                name=tool.name,
-                description=tool.description or "",
-                input_schema=tool.inputSchema,
-            )
-            for tool in tool_list.tools
-        ]
+        available_tools = await self._prepare_tools(structured_model)
 
         responses: List[ContentBlock] = []
 
@@ -209,59 +382,25 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                 "tools": available_tools,
             }
 
-            # Apply cache_control to system prompt if cache_mode is not "off"
-            # This caches both tools and system prompt together in one cache block
-            if cache_mode != "off" and base_args["system"]:
-                if isinstance(base_args["system"], str):
-                    base_args["system"] = [
-                        {
-                            "type": "text",
-                            "text": base_args["system"],
-                            "cache_control": {"type": "ephemeral"},
-                        }
-                    ]
-                    self.logger.debug(
-                        "Applied cache_control to system prompt (caches tools+system in one block)"
-                    )
-                else:
-                    self.logger.debug(f"System prompt is not a string: {type(base_args['system'])}")
+            # Add tool_choice for structured output mode
+            if structured_model:
+                base_args["tool_choice"] = {"type": "tool", "name": "return_structured_output"}
 
-            # Apply conversation caching using walking algorithm if in auto mode
-            if cache_mode == "auto" and self.history.should_apply_conversation_cache():
-                cache_updates = self.history.get_conversation_cache_updates()
+            # Apply cache control to system prompt
+            self._apply_system_cache(base_args, cache_mode)
 
-                # Remove cache control from old positions
-                if cache_updates["remove"]:
-                    self.history.remove_cache_control_from_messages(
-                        messages, cache_updates["remove"]
-                    )
-                    self.logger.debug(
-                        f"Removed conversation cache_control from positions {cache_updates['remove']}"
-                    )
+            # Apply conversation caching
+            applied_count = await self._apply_conversation_cache(messages, cache_mode)
 
-                # Add cache control to new positions
-                if cache_updates["add"]:
-                    applied_count = self.history.add_cache_control_to_messages(
-                        messages, cache_updates["add"]
+            # Verify we don't exceed Anthropic's 4 cache block limit
+            if applied_count > 0:
+                total_cache_blocks = applied_count
+                if cache_mode != "off" and base_args["system"]:
+                    total_cache_blocks += 1  # tools+system cache block
+                if total_cache_blocks > 4:
+                    self.logger.warning(
+                        f"Total cache blocks ({total_cache_blocks}) exceeds Anthropic limit of 4"
                     )
-                    if applied_count > 0:
-                        self.history.apply_conversation_cache_updates(cache_updates)
-                        self.logger.debug(
-                            f"Applied conversation cache_control to positions {cache_updates['add']} ({applied_count} blocks)"
-                        )
-
-                        # Verify we don't exceed Anthropic's 4 cache block limit
-                        total_cache_blocks = applied_count
-                        if cache_mode != "off" and base_args["system"]:
-                            total_cache_blocks += 1  # tools+system cache block
-                        if total_cache_blocks > 4:
-                            self.logger.warning(
-                                f"Total cache blocks ({total_cache_blocks}) exceeds Anthropic limit of 4"
-                            )
-                    else:
-                        self.logger.debug(
-                            f"Failed to apply conversation cache_control to positions {cache_updates['add']}"
-                        )
 
             if params.maxTokens is not None:
                 base_args["max_tokens"] = params.maxTokens
@@ -387,34 +526,22 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                             style="dim green italic",
                         )
 
-                    # Process all tool calls and collect results
-                    tool_results = []
-                    # Use a different loop variable for tool enumeration if 'i' is outer loop counter
-                    for tool_idx, content_block in enumerate(tool_uses):
-                        tool_name = content_block.name
-                        tool_args = content_block.input
-                        tool_use_id = content_block.id
-
-                        if tool_idx == 0:  # Only show message for first tool use
-                            await self.show_assistant_message(message_text, tool_name)
-
-                        self.show_tool_call(available_tools, tool_name, tool_args)
-                        tool_call_request = CallToolRequest(
-                            method="tools/call",
-                            params=CallToolRequestParams(name=tool_name, arguments=tool_args),
-                        )
-                        # TODO -- support MCP isError etc.
-                        result = await self.call_tool(
-                            request=tool_call_request, tool_call_id=tool_use_id
-                        )
-                        self.show_tool_result(result)
-
-                        # Add each result to our collection
-                        tool_results.append((tool_use_id, result))
-                        responses.extend(result.content)
+                    # Process all tool calls using the helper method
+                    tool_results, tool_responses = await self._process_tool_calls(
+                        tool_uses, available_tools, message_text, structured_model
+                    )
+                    responses.extend(tool_responses)
 
+                    # Always add tool_results_message first (required by Anthropic API)
                     messages.append(AnthropicConverter.create_tool_results_message(tool_results))
 
+                    # For structured output, we have our result and should exit after sending tool_result
+                    if structured_model and any(
+                        tool.name == "return_structured_output" for tool in tool_uses
+                    ):
+                        self.logger.debug("Structured output received, breaking iteration loop")
+                        break
+
         # Only save the new conversation messages to history if use_history is true
         # Keep the prompt messages separate
         if params.use_history:
@@ -501,19 +628,51 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
     ) -> Tuple[ModelT | None, PromptMessageMultipart]:  # noqa: F821
         request_params = self.get_request_params(request_params)
 
-        # TODO - convert this to use Tool Calling convention for Anthropic Structured outputs
-        multipart_messages[-1].add_text(
-            """YOU MUST RESPOND IN THE FOLLOWING FORMAT:
-            {schema}
-            RESPOND ONLY WITH THE JSON, NO PREAMBLE, CODE FENCES OR 'properties' ARE PERMISSABLE """.format(
-                schema=model.model_json_schema()
-            )
-        )
+        # Check the last message role
+        last_message = multipart_messages[-1]
 
-        result: PromptMessageMultipart = await self._apply_prompt_provider_specific(
-            multipart_messages, request_params
+        # Add all previous messages to history (or all messages if last is from assistant)
+        messages_to_add = (
+            multipart_messages[:-1] if last_message.role == "user" else multipart_messages
         )
-        return self._structured_from_multipart(result, model)
+        converted = []
+
+        for msg in messages_to_add:
+            anthropic_msg = AnthropicConverter.convert_to_anthropic(msg)
+            converted.append(anthropic_msg)
+
+        self.history.extend(converted, is_prompt=False)
+
+        if last_message.role == "user":
+            self.logger.debug("Last message in prompt is from user, generating structured response")
+            message_param = AnthropicConverter.convert_to_anthropic(last_message)
+
+            # Call _anthropic_completion with the structured model
+            response_content = await self._anthropic_completion(
+                message_param, request_params, structured_model=model
+            )
+
+            # Extract the structured data from the response
+            for content in response_content:
+                if content.type == "text":
+                    try:
+                        # Parse the JSON response from the tool
+                        data = json.loads(content.text)
+                        parsed_model = model(**data)
+                        # Create assistant response
+                        assistant_response = Prompt.assistant(content)
+                        return parsed_model, assistant_response
+                    except (json.JSONDecodeError, ValueError) as e:
+                        self.logger.error(f"Failed to parse structured output: {e}")
+                        assistant_response = Prompt.assistant(content)
+                        return None, assistant_response
+
+            # If no valid response found
+            return None, Prompt.assistant()
+        else:
+            # For assistant messages: Return the last message content
+            self.logger.debug("Last message in prompt is from assistant, returning it directly")
+            return None, last_message
 
     def _show_usage(self, raw_usage: Usage, turn_usage: TurnUsage) -> None:
         # Print raw usage for debugging

mcp_agent/resources/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(

mcp_agent/resources/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:

mcp_agent/ui/console_display.py

@@ -1,6 +1,8 @@
+from json import JSONDecodeError
 from typing import Optional, Union
 
 from mcp.types import CallToolResult
+from rich.json import JSON
 from rich.panel import Panel
 from rich.text import Text
 
@@ -52,13 +54,15 @@ class ConsoleDisplay:
             elif len(content) == 1 and is_text_content(content[0]):
                 text_content = get_text(content[0])
                 char_count = len(text_content) if text_content else 0
-                status = f"Text Only ({char_count} chars)"
+                status = f"Text Only {char_count} chars"
             else:
                 text_count = sum(1 for item in content if is_text_content(item))
                 if text_count == len(content):
                     status = f"{len(content)} Text Blocks" if len(content) > 1 else "1 Text Block"
                 else:
-                    status = f"{len(content)} Content Blocks"
+                    status = (
+                        f"{len(content)} Content Blocks" if len(content) > 1 else "1 Content Block"
+                    )
 
         # Combined separator and status line
         left = f"[{block_color}]▎[/{block_color}][{text_color}]▶[/{text_color}]{f' [{block_color}]{name}[/{block_color}]' if name else ''}"
@@ -357,16 +361,22 @@ class ConsoleDisplay:
         right = f"[dim]{model}[/dim]" if model else ""
         self._create_combined_separator_status(left, right)
 
-        # Display content as markdown if it looks like markdown, otherwise as text
         if isinstance(message_text, str):
             content = message_text
-            #         if any(marker in content for marker in ["##", "**", "*", "`", "---", "###"]):
-            md = Markdown(content, code_theme=CODE_STYLE)
-            console.console.print(md, markup=self._markup)
-        #        else:
-        #           console.console.print(content, markup=self._markup)
+
+            # Try to detect and pretty print JSON
+            try:
+                import json
+
+                json.loads(content)
+                json = JSON(message_text)
+                console.console.print(json, markup=self._markup)
+            except (JSONDecodeError, TypeError, ValueError):
+                # Not JSON, treat as markdown
+                md = Markdown(content, code_theme=CODE_STYLE)
+                console.console.print(md, markup=self._markup)
         else:
-            # Handle Text objects directly
+            # Handle Rich Text objects directly
             console.console.print(message_text, markup=self._markup)
 
         # Bottom separator with server list: ─ [server1] [server2] ────────