fast-agent-mcp 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

{fast_agent_mcp-0.2.6.dist-info → fast_agent_mcp-0.2.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.6
+Version: 0.2.8
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>, Sarmad Qadri <sarmad@lastmileai.dev>
 License:                                  Apache License
@@ -260,8 +260,7 @@ The simple declarative syntax lets you concentrate on composing your Prompts and
 
 `fast-agent` is multi-modal, supporting Images and PDFs for both Anthropic and OpenAI endpoints via Prompts, Resources and MCP Tool Call results. The inclusion of passthrough and playback LLMs enable rapid development and test of Python glue-code for your applications.
 
-> [!TIP]
-> `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site and Further MCP Examples.
+> [!TIP] > `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site and Further MCP Examples.
 
 ### Agent Application Development
 
@@ -525,7 +524,7 @@ agent["greeter"].send("Good Evening!")          # Dictionary access is supported
   servers=["filesystem"],                # list of MCP Servers for the agent
   model="o3-mini.high",                  # specify a model for the agent
   use_history=True,                      # agent maintains chat history
-  request_params={"temperature": 0.7},   # additional parameters for the LLM (or RequestParams())
+  request_params=RequestParams(temperature= 0.7)), # additional parameters for the LLM (or RequestParams())
   human_input=True,                      # agent can request human input
 )
 ```

{fast_agent_mcp-0.2.6.dist-info → fast_agent_mcp-0.2.8.dist-info}/RECORD

@@ -1,23 +1,23 @@
 mcp_agent/__init__.py,sha256=-AIoeL4c9UAp_P4U0z-uIWTTmQWdihOis5nbQ5L_eao,1664
 mcp_agent/app.py,sha256=jBmzYM_o50g8vhlTgkkf5TGiBWNbXWViYnd0WANbpzo,10276
-mcp_agent/config.py,sha256=V6TZlKOUelv5N75fypWKFVvkY5YsgpoHrdiSsKxOiM0,11725
+mcp_agent/config.py,sha256=0GVtAMSiK1oPklHlH-3rbhjPfBx18JfEAn-W-HG5x6k,12167
 mcp_agent/console.py,sha256=Gjf2QLFumwG1Lav__c07X_kZxxEUSkzV-1_-YbAwcwo,813
 mcp_agent/context.py,sha256=pp_F1Q1jgAxGrRccSZJutn1JUxYfVue-St3S8tUyptM,7903
 mcp_agent/context_dependent.py,sha256=QXfhw3RaQCKfscEEBRGuZ3sdMWqkgShz2jJ1ivGGX1I,1455
 mcp_agent/event_progress.py,sha256=25iz0yyg-O4glMmtijcYpDdUmtUIKsCmR_8A52GgeC4,2716
-mcp_agent/mcp_server_registry.py,sha256=r24xX4BYXj4BbWbU37uwuW9e1mFOYgpb258OMb21SaY,9928
+mcp_agent/mcp_server_registry.py,sha256=w0sq-5o_AVVGfwUBo0c_Ekbyjd3Tjg9bzi2r8UZry7o,9945
 mcp_agent/progress_display.py,sha256=GeJU9VUt6qKsFVymG688hCMVCsAygG9ifiiEb5IcbN4,361
 mcp_agent/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/agents/agent.py,sha256=Tn2YKw_ytx9b8jC-65WYQmrnD43kYiZsLa4sVHxn9d4,3854
-mcp_agent/agents/base_agent.py,sha256=9IExAXyPpao4t7J_uF2pjSlbnlKp-229oiOykbE6KDI,23515
+mcp_agent/agents/base_agent.py,sha256=dzyy4tDHJfRC4Sp-JqXeDwykk5SH55k89dUXQROIdQ4,23488
 mcp_agent/agents/workflow/__init__.py,sha256=HloteEW6kalvgR0XewpiFAqaQlMPlPJYg5p3K33IUzI,25
-mcp_agent/agents/workflow/chain_agent.py,sha256=EW10IgEnKJ3YfwLY61B1SQlYC-84jcXsrRmzpLQbngE,6384
+mcp_agent/agents/workflow/chain_agent.py,sha256=efftXdHc5F-XY8jnz5npHbKHhqnzHh28WbU5yQ4yUn0,6105
 mcp_agent/agents/workflow/evaluator_optimizer.py,sha256=VWdzVIy_qSiVsDJO22ta3RB3drkvBfXk9HxBYMpsC5U,13300
 mcp_agent/agents/workflow/orchestrator_agent.py,sha256=30hFQyAmtjQTX6Li_zWWIHCpdNpfZkDo57YXXW5xIsI,21561
 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=SgIXJx2X_MSlLOv6WXYRezwjDYjU9f95eKQzTm5Y_lk,7087
-mcp_agent/agents/workflow/router_agent.py,sha256=WLv2ny_-6mAJ7tjU-6nUe2yVhW008vso5NU9tczNTn0,10666
+mcp_agent/agents/workflow/router_agent.py,sha256=c4MU55U6q1DRayP0sDoyxdlnKX-N0LPbRv-MFlwbwrY,11165
 mcp_agent/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/cli/__main__.py,sha256=AVZ7tQFhU_sDOGuUGJq8ujgKtcxsYJBJwHbVaaiRDlI,166
 mcp_agent/cli/main.py,sha256=PZdPJfsAJOm80vTu7j_XpMPhaDZOpqSe-ciU3YQsmA4,3149
@@ -30,11 +30,11 @@ mcp_agent/core/agent_app.py,sha256=5nQJNo8DocIRWiX4pVKAHUZF8s6HWpc-hJnfzl_1v1c,9
 mcp_agent/core/agent_types.py,sha256=LuWslu9YI6JRnAWwh_A1ZejK72-e839wH7tf2MHxSIU,1389
 mcp_agent/core/direct_decorators.py,sha256=Q6t3VpRPLCRzqJycPZIkKbbEJMVocxdScp5o2xn4gLU,14460
 mcp_agent/core/direct_factory.py,sha256=hYFCucZVAQ2wrfqIe9Qameoa-cCRaQ53R97EMHvUZAM,17572
-mcp_agent/core/enhanced_prompt.py,sha256=P9FAtc0rqIYQfUDkTNVXitFIZEtB3fdq_Nr0-st64Qg,17948
+mcp_agent/core/enhanced_prompt.py,sha256=A0FJ_-dr1RLq3uzmFSxiOBxw5synW2BhA4QntQyYVwg,18792
 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=HTy1OCAhpHIM-4cd37-dxvb97eZUELN-ICAEFgqmJMk,18503
-mcp_agent/core/interactive_prompt.py,sha256=zU53h8mmaJBnddYy2j57tH7jreQ9PUz7vLEo2gdDrio,17704
+mcp_agent/core/fastagent.py,sha256=T2kyq32wBJCOj13Zy1G_XJjQZb1S4HVdx3OBzmEMHBg,18644
+mcp_agent/core/interactive_prompt.py,sha256=y56K2ZIvj5hZZwtEDHezJCOlduRwAcj2fc4GqhKq9ZY,23357
 mcp_agent/core/mcp_content.py,sha256=2D7KHY9mG_vxoDwFLKvsPQV9VRIzHItM7V-jcEnACh8,8878
 mcp_agent/core/prompt.py,sha256=qnintOUGEoDPYLI9bu9G2OlgVMCe5ZPUZilgMzydXhc,7919
 mcp_agent/core/request_params.py,sha256=bEjWo86fqxdiWm2U5nPDd1uCUpcIQO9oiCinhB8lQN0,1185
@@ -50,20 +50,21 @@ mcp_agent/human_input/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 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=AFNA_v7cuxy9MSpCigv9FM9CEg27NsaUfeme4tiy1y8,18125
+mcp_agent/llm/augmented_llm.py,sha256=YIB3I_taoglo_vSmZLQ50cv1qCSctaQlWVwjI-7WTkk,18304
 mcp_agent/llm/augmented_llm_passthrough.py,sha256=U0LssNWNVuZRuD9I7Wuvpo7vdDW4xtoPLirnYCgBGTY,6128
 mcp_agent/llm/augmented_llm_playback.py,sha256=YVR2adzjMf9Q5WfYBytryWMRqJ87a3kNBnjxhApsMcU,3413
 mcp_agent/llm/memory.py,sha256=UakoBCJBf59JBtB6uyZM0OZjlxDW_VHtSfDs08ibVEc,3312
-mcp_agent/llm/model_factory.py,sha256=WOm2IkZLhgFTplmgjVAzNzjpawm3D_aTVcGdgu1DReg,7606
+mcp_agent/llm/model_factory.py,sha256=fj14NMYYg7yBxq7TsVuLIEYrK6rzPW1_p9O0Yegoq00,7844
 mcp_agent/llm/prompt_utils.py,sha256=yWQHykoK13QRF7evHUKxVF0SpVLN-Bsft0Yixzvn0g0,4825
 mcp_agent/llm/sampling_converter.py,sha256=C7wPBlmT0eD90XWabC22zkxsrVHKCrjwIwg6cG628cI,2926
 mcp_agent/llm/sampling_format_converter.py,sha256=xGz4odHpOcP7--eFaJaFtUR8eR9jxZS7MnLH6J7n0EU,1263
 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_anthropic.py,sha256=9JXyweks5Joes4ERtmi2wX8i7ZsXydKM7IkMq7s7dIU,15429
+mcp_agent/llm/providers/augmented_llm_anthropic.py,sha256=CNKpTEvWqjOteACUx_Vha0uFpPt32C17JrkSXg_allM,14445
 mcp_agent/llm/providers/augmented_llm_deepseek.py,sha256=SdYDqZZ9hM9sBvW1FSItNn_ENEKQXGNKwVHGnjqjyAA,1927
 mcp_agent/llm/providers/augmented_llm_generic.py,sha256=IIgwPYsVGwDdL2mMYsc5seY3pVFblMwmnxoI5dbxras,1524
-mcp_agent/llm/providers/augmented_llm_openai.py,sha256=6ZUEOXW-cDENAizMPUKJhhklJyQf73IcyVqT9-3To80,18215
+mcp_agent/llm/providers/augmented_llm_openai.py,sha256=Wso9GVgsq8y3sqlOzTk_iQqrkCOL3LyuG07nA1PWDng,17913
+mcp_agent/llm/providers/augmented_llm_openrouter.py,sha256=AajWXFIgGEDjeEx8AWCTs3mZGTPaihdsrjEUiNAJkIM,3501
 mcp_agent/llm/providers/multipart_converter_anthropic.py,sha256=t5lHYGfFUacJldnrVtMNW-8gEMoto8Y7hJkDrnyZR-Y,16650
 mcp_agent/llm/providers/multipart_converter_openai.py,sha256=zCj0LBgd9FDG8aL_GeTrPo2ssloYnmC_Uj3ENWVUJAg,16753
 mcp_agent/llm/providers/openai_multipart.py,sha256=qKBn7d3jSabnJmVgWweVzqh8q9mBqr09fsPmP92niAQ,6899
@@ -81,11 +82,10 @@ mcp_agent/logging/transport.py,sha256=m8YsLLu5T8eof_ndpLQs4gHOzqqEL98xsVwBwDsBfx
 mcp_agent/mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/mcp/gen_client.py,sha256=fAVwFVCgSamw4PwoWOV4wrK9TABx1S_zZv8BctRyF2k,3030
 mcp_agent/mcp/interfaces.py,sha256=vma7bbWbY3zp1RM6hMYxVO4aV6Vfaygm-nLwzK2jFKI,6748
-mcp_agent/mcp/logger_textio.py,sha256=OpnqMam9Pu0oVzYQWFMhrX1dRg2f5Fqb3qqPA6QAATM,2778
-mcp_agent/mcp/mcp_activity.py,sha256=CajXCFWZ2cKEX9s4-HfNVAj471ePTVs4NOkvmIh65tE,592
+mcp_agent/mcp/logger_textio.py,sha256=vljC1BtNTCxBAda9ExqNB-FwVNUZIuJT3h1nWmCjMws,3172
 mcp_agent/mcp/mcp_agent_client_session.py,sha256=RMYNltc2pDIzxwEJSS5589RbvPO0KWV4Y3jSyAmhKf0,4181
 mcp_agent/mcp/mcp_aggregator.py,sha256=jaWbOvb3wioECohZ47CubyxfJ5QkfNSshu1hwhZksG4,40486
-mcp_agent/mcp/mcp_connection_manager.py,sha256=desQBreHbIcjY7AidcDO6pFomHOx9oOZPOWIcHAx1K0,13761
+mcp_agent/mcp/mcp_connection_manager.py,sha256=AMIm2FBbIk7zHInb8X-kFSQFO5TKcoi9w8WU8nx8Ig0,13834
 mcp_agent/mcp/mime_utils.py,sha256=difepNR_gpb4MpMLkBRAoyhDk-AjXUHTiqKvT_VwS1o,1805
 mcp_agent/mcp/prompt_message_multipart.py,sha256=IpIndd75tAcCbJbfqjpAF0tOUUP1TQceDbWoxO5gvpo,3684
 mcp_agent/mcp/prompt_render.py,sha256=k3v4BZDThGE2gGiOYVQtA6x8WTEdOuXIEnRafANhN1U,2996
@@ -134,8 +134,8 @@ mcp_agent/resources/examples/workflows/orchestrator.py,sha256=rOGilFTliWWnZ3Jx5w
 mcp_agent/resources/examples/workflows/parallel.py,sha256=n0dFN26QvYd2wjgohcaUBflac2SzXYx-bCyxMSousJE,1884
 mcp_agent/resources/examples/workflows/router.py,sha256=E4x_-c3l4YW9w1i4ARcDtkdeqIdbWEGfsMzwLYpdbVc,1677
 mcp_agent/ui/console_display.py,sha256=TVGDtJ37hc6UG0ei9g7ZPZZfFNeS1MYozt-Mx8HsPCk,9752
-fast_agent_mcp-0.2.6.dist-info/METADATA,sha256=f1wgZfK_zZRytbHKacbUDGvP7JS0Qqjp2YemYm1td9Y,29839
-fast_agent_mcp-0.2.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fast_agent_mcp-0.2.6.dist-info/entry_points.txt,sha256=qPM7vwtN1_KmP3dXehxgiCxUBHtqP7yfenZigztvY-w,226
-fast_agent_mcp-0.2.6.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
-fast_agent_mcp-0.2.6.dist-info/RECORD,,
+fast_agent_mcp-0.2.8.dist-info/METADATA,sha256=k7K-lDRpHTGxQ1hH17zLSapAx0DivjdSJaAqSNtuWeI,29849
+fast_agent_mcp-0.2.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fast_agent_mcp-0.2.8.dist-info/entry_points.txt,sha256=qPM7vwtN1_KmP3dXehxgiCxUBHtqP7yfenZigztvY-w,226
+fast_agent_mcp-0.2.8.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
+fast_agent_mcp-0.2.8.dist-info/RECORD,,

mcp_agent/agents/base_agent.py

@@ -215,7 +215,7 @@ class BaseAgent(MCPAggregator, AgentProtocol):
 
         # Use the LLM to generate a response
         response = await self.generate([prompt], None)
-        return response.first_text()
+        return response.all_text()
 
     def _normalize_message_input(
         self, message: Union[str, PromptMessage, PromptMessageMultipart]
@@ -625,15 +625,15 @@ class BaseAgent(MCPAggregator, AgentProtocol):
     @property
     def agent_type(self) -> str:
         """
-        Return the type of this agent. 
-        
+        Return the type of this agent.
+
         This is used for display purposes in the interactive prompt and other UI elements.
-        
+
         Returns:
             String representing the agent type
         """
         return self.config.agent_type
-        
+
     @property
     def message_history(self) -> List[PromptMessageMultipart]:
         """

mcp_agent/agents/workflow/chain_agent.py

@@ -23,7 +23,8 @@ class ChainAgent(BaseAgent):
     A chain agent that processes requests through a series of specialized agents in sequence.
     Passes the output of each agent to the next agent in the chain.
     """
-    
+
+    # TODO -- consider adding "repeat" mode
     @property
     def agent_type(self) -> str:
         """Return the type of this agent."""
@@ -70,20 +71,11 @@ class ChainAgent(BaseAgent):
         # # Get the original user message (last message in the list)
         user_message = multipart_messages[-1] if multipart_messages else None
 
-        # # If no user message, return an error
-        # if not user_message:
-        #     return PromptMessageMultipart(
-        #         role="assistant",
-        #         content=[TextContent(type="text", text="No input message provided.")],
-        #     )
-
-        # Initialize messages with the input
-
         if not self.cumulative:
             response: PromptMessageMultipart = await self.agents[0].generate(multipart_messages)
             # Process the rest of the agents in the chain
             for agent in self.agents[1:]:
-                next_message = Prompt.user(response.content[0].text)
+                next_message = Prompt.user(*response.content)
                 response = await agent.generate([next_message])
 
             return response

mcp_agent/agents/workflow/router_agent.py

@@ -53,12 +53,29 @@ You are a highly accurate request router that directs incoming requests to the m
 Your task is to analyze the request and determine the most appropriate agent from the options above.
 
 <fastagent:instruction>
-Respond in JSON format. ONLY include JSON (no explanation). NEVER include Code Fences:
+Respond with JSON following the schema below:
 {{
-    "agent": "<agent name>",
-    "confidence": "<high, medium or low>",
-    "reasoning": "<brief explanation>"
+    "type": "object",
+    "required": ["agent", "confidence", "reasoning"],
+    "properties": {{
+        "agent": {{
+            "type": "string",
+            "description": "The exact name of the selected agent"
+        }},
+        "confidence": {{
+            "type": "string",
+            "enum": ["high", "medium", "low"],
+            "description": "Your confidence level in this selection"
+        }},
+        "reasoning": {{
+            "type": "string",
+            "description": "Brief explanation for your selection"
+        }}
+    }}
 }}
+
+Supply only the JSON with no preamble. Use "reasoning" field to describe actions. NEVER EMIT CODE FENCES. 
+
 </fastagent:instruction>
 """
 
@@ -87,7 +104,7 @@ class RouterAgent(BaseAgent):
     A simplified router that uses an LLM to determine the best agent for a request,
     then dispatches the request to that agent and returns the response.
     """
-    
+
     @property
     def agent_type(self) -> str:
         """Return the type of this agent."""

mcp_agent/config.py

@@ -75,6 +75,9 @@ class MCPServerSettings(BaseModel):
     url: str | None = None
     """The URL for the server (e.g. for SSE transport)."""
 
+    headers: Dict[str, str] | None = None
+    """Headers dictionary for SSE connections"""
+
     auth: MCPServerAuthSettings | None = None
     """The authentication configuration for the server."""
 
@@ -84,9 +87,6 @@ class MCPServerSettings(BaseModel):
     env: Dict[str, str] | None = None
     """Environment variables to pass to the server process."""
 
-    env: Dict[str, str] | None = None
-    """Environment variables to pass to the server process."""
-
     sampling: MCPSamplingSettings | None = None
     """Sampling settings for this Client/Server pair"""
 
@@ -146,6 +146,17 @@ class GenericSettings(BaseModel):
     base_url: str | None = None
 
     model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+    
+
+class OpenRouterSettings(BaseModel):
+    """
+    Settings for using OpenRouter models via its OpenAI-compatible API.
+    """
+    api_key: str | None = None
+    
+    base_url: str | None = None # Optional override, defaults handled in provider
+
+    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
 
 
 class TemporalSettings(BaseModel):
@@ -262,6 +273,9 @@ class Settings(BaseSettings):
     deepseek: DeepSeekSettings | None = None
     """Settings for using DeepSeek models in the fast-agent application"""
 
+    openrouter: OpenRouterSettings | None = None
+    """Settings for using OpenRouter models in the fast-agent application"""
+
     generic: GenericSettings | None = None
     """Settings for using Generic models in the fast-agent application"""
 

mcp_agent/core/enhanced_prompt.py

@@ -285,10 +285,17 @@ async def get_enhanced_input(
             elif cmd == "agents":
                 return "LIST_AGENTS"
             elif cmd == "prompts":
-                return "SELECT_PROMPT"  # Directly launch prompt selection UI
+                # Return a dictionary with select_prompt action instead of a string
+                # This way it will match what the command handler expects
+                return {"select_prompt": True, "prompt_name": None}
             elif cmd == "prompt" and len(cmd_parts) > 1:
-                # Direct prompt selection with name
-                return f"SELECT_PROMPT:{cmd_parts[1].strip()}"
+                # Direct prompt selection with name or number
+                prompt_arg = cmd_parts[1].strip()
+                # Check if it's a number (use as index) or a name (use directly)
+                if prompt_arg.isdigit():
+                    return {"select_prompt": True, "prompt_index": int(prompt_arg)}
+                else:
+                    return f"SELECT_PROMPT:{prompt_arg}"
             elif cmd == "exit":
                 return "EXIT"
             elif cmd.lower() == "stop":
@@ -420,13 +427,27 @@ async def get_argument_input(
             prompt_session.app.exit()
 
 
-async def handle_special_commands(command: str, agent_app=None):
-    """Handle special input commands."""
+async def handle_special_commands(command, agent_app=None):
+    """
+    Handle special input commands.
+    
+    Args:
+        command: The command to handle, can be string or dictionary
+        agent_app: Optional agent app reference
+        
+    Returns:
+        True if command was handled, False if not, or a dict with action info
+    """
     # Quick guard for empty or None commands
     if not command:
         return False
+        
+    # If command is already a dictionary, it has been pre-processed
+    # Just return it directly (like when /prompts converts to select_prompt dict)
+    if isinstance(command, dict):
+        return command
 
-    # Check for special commands
+    # Check for special string commands
     if command == "HELP":
         rich_print("\n[bold]Available Commands:[/bold]")
         rich_print("  /help          - Show this help")
@@ -450,7 +471,7 @@ async def handle_special_commands(command: str, agent_app=None):
         print("\033c", end="")
         return True
 
-    elif command.upper() == "EXIT":
+    elif isinstance(command, str) and command.upper() == "EXIT":
         raise PromptExitError("User requested to exit fast-agent session")
 
     elif command == "LIST_AGENTS":
@@ -462,8 +483,6 @@ async def handle_special_commands(command: str, agent_app=None):
             rich_print("[yellow]No agents available[/yellow]")
         return True
 
-    # Removed LIST_PROMPTS handling as it's now covered by SELECT_PROMPT
-
     elif command == "SELECT_PROMPT" or (
         isinstance(command, str) and command.startswith("SELECT_PROMPT:")
     ):

mcp_agent/core/fastagent.py

@@ -235,6 +235,8 @@ class FastAgent:
                     progress_display.stop()
 
                 # Pre-flight validation
+                if 0 == len(self.agents):
+                    raise AgentConfigError("No agents defined. Please define at least one agent.")
                 validate_server_references(self.context, self.agents)
                 validate_workflow_references(self.agents)
 

mcp_agent/core/interactive_prompt.py

@@ -26,6 +26,7 @@ from mcp_agent.core.enhanced_prompt import (
     get_selection_input,
     handle_special_commands,
 )
+from mcp_agent.mcp.mcp_aggregator import SEP  # Import SEP once at the top
 from mcp_agent.progress_display import progress_display
 
 
@@ -96,7 +97,7 @@ class InteractivePrompt:
 
                 # Handle special commands - pass "True" to enable agent switching
                 command_result = await handle_special_commands(user_input, True)
-
+                
                 # Check if we should switch agents
                 if isinstance(command_result, dict):
                     if "switch_agent" in command_result:
@@ -107,6 +108,7 @@ class InteractivePrompt:
                         else:
                             rich_print(f"[red]Agent '{new_agent}' not found[/red]")
                             continue
+                    # Keep the existing list_prompts handler for backward compatibility
                     elif "list_prompts" in command_result and list_prompts_func:
                         # Use the list_prompts_func directly
                         await self._list_prompts(list_prompts_func, agent)
@@ -114,7 +116,29 @@ class InteractivePrompt:
                     elif "select_prompt" in command_result and (list_prompts_func and apply_prompt_func):
                         # Handle prompt selection, using both list_prompts and apply_prompt
                         prompt_name = command_result.get("prompt_name")
-                        await self._select_prompt(list_prompts_func, apply_prompt_func, agent, prompt_name)
+                        prompt_index = command_result.get("prompt_index")
+                        
+                        # If a specific index was provided (from /prompt <number>)
+                        if prompt_index is not None:
+                            # First get a list of all prompts to look up the index
+                            all_prompts = await self._get_all_prompts(list_prompts_func, agent)
+                            if not all_prompts:
+                                rich_print("[yellow]No prompts available[/yellow]")
+                                continue
+                                
+                            # Check if the index is valid
+                            if 1 <= prompt_index <= len(all_prompts):
+                                # Get the prompt at the specified index (1-based to 0-based)
+                                selected_prompt = all_prompts[prompt_index - 1]
+                                # Use the already created namespaced_name to ensure consistency
+                                await self._select_prompt(list_prompts_func, apply_prompt_func, agent, selected_prompt["namespaced_name"])
+                            else:
+                                rich_print(f"[red]Invalid prompt number: {prompt_index}. Valid range is 1-{len(all_prompts)}[/red]")
+                                # Show the prompt list for convenience
+                                await self._list_prompts(list_prompts_func, agent)
+                        else:
+                            # Use the name-based selection
+                            await self._select_prompt(list_prompts_func, apply_prompt_func, agent, prompt_name)
                         continue
 
                 # Skip further processing if command was handled
@@ -131,42 +155,119 @@ class InteractivePrompt:
 
         return result
 
-    async def _list_prompts(self, list_prompts_func, agent_name) -> None:
+    async def _get_all_prompts(self, list_prompts_func, agent_name):
         """
-        List available prompts for an agent.
-
+        Get a list of all available prompts.
+        
         Args:
             list_prompts_func: Function to get available prompts
             agent_name: Name of the agent
+            
+        Returns:
+            List of prompt info dictionaries, sorted by server and name
         """
-        from rich import print as rich_print
-
         try:
-            # Directly call the list_prompts function for this agent
-            rich_print(f"\n[bold]Fetching prompts for agent [cyan]{agent_name}[/cyan]...[/bold]")
-            
-            prompt_servers = await list_prompts_func(agent_name)
+            # Pass None instead of agent_name to get prompts from all servers
+            # the agent_name parameter should never be used as a server name
+            prompt_servers = await list_prompts_func(None)
+            all_prompts = []
             
             # Process the returned prompt servers
             if prompt_servers:
-                found_prompts = False
+                # First collect all prompts
                 for server_name, prompts_info in prompt_servers.items():
                     if prompts_info and hasattr(prompts_info, "prompts") and prompts_info.prompts:
-                        rich_print(f"\n[bold cyan]{server_name}:[/bold cyan]")
                         for prompt in prompts_info.prompts:
-                            rich_print(f"  {prompt.name}")
-                        found_prompts = True
+                            # Use the SEP constant for proper namespacing
+                            all_prompts.append({
+                                "server": server_name,
+                                "name": prompt.name,
+                                "namespaced_name": f"{server_name}{SEP}{prompt.name}",
+                                "description": getattr(prompt, "description", "No description"),
+                                "arg_count": len(getattr(prompt, "arguments", [])),
+                                "arguments": getattr(prompt, "arguments", [])
+                            })
                     elif isinstance(prompts_info, list) and prompts_info:
-                        rich_print(f"\n[bold cyan]{server_name}:[/bold cyan]")
                         for prompt in prompts_info:
                             if isinstance(prompt, dict) and "name" in prompt:
-                                rich_print(f"  {prompt['name']}")
+                                all_prompts.append({
+                                    "server": server_name,
+                                    "name": prompt["name"],
+                                    "namespaced_name": f"{server_name}{SEP}{prompt['name']}",
+                                    "description": prompt.get("description", "No description"),
+                                    "arg_count": len(prompt.get("arguments", [])),
+                                    "arguments": prompt.get("arguments", [])
+                                })
                             else:
-                                rich_print(f"  {prompt}")
-                        found_prompts = True
+                                all_prompts.append({
+                                    "server": server_name,
+                                    "name": str(prompt),
+                                    "namespaced_name": f"{server_name}{SEP}{str(prompt)}",
+                                    "description": "No description",
+                                    "arg_count": 0,
+                                    "arguments": []
+                                })
+                
+                # Sort prompts by server and name for consistent ordering
+                all_prompts.sort(key=lambda p: (p["server"], p["name"]))
+            
+            return all_prompts
+        
+        except Exception as e:
+            import traceback
+
+            from rich import print as rich_print
+            rich_print(f"[red]Error getting prompts: {e}[/red]")
+            rich_print(f"[dim]{traceback.format_exc()}[/dim]")
+            return []
+
+    async def _list_prompts(self, list_prompts_func, agent_name) -> None:
+        """
+        List available prompts for an agent.
+
+        Args:
+            list_prompts_func: Function to get available prompts
+            agent_name: Name of the agent
+        """
+        from rich import print as rich_print
+        from rich.console import Console
+        from rich.table import Table
 
-                if not found_prompts:
-                    rich_print("[yellow]No prompts available[/yellow]")
+        console = Console()
+
+        try:
+            # Directly call the list_prompts function for this agent
+            rich_print(f"\n[bold]Fetching prompts for agent [cyan]{agent_name}[/cyan]...[/bold]")
+            
+            # Get all prompts using the helper function - pass None as server name
+            # to get prompts from all available servers
+            all_prompts = await self._get_all_prompts(list_prompts_func, None)
+            
+            if all_prompts:
+                # Create a table for better display
+                table = Table(title="Available MCP Prompts")
+                table.add_column("#", justify="right", style="cyan")
+                table.add_column("Server", style="green")
+                table.add_column("Prompt Name", style="bright_blue")
+                table.add_column("Description")
+                table.add_column("Args", justify="center")
+                
+                # Add prompts to table
+                for i, prompt in enumerate(all_prompts):
+                    table.add_row(
+                        str(i + 1),
+                        prompt["server"],
+                        prompt["name"],
+                        prompt["description"],
+                        str(prompt["arg_count"])
+                    )
+                
+                console.print(table)
+                
+                # Add usage instructions
+                rich_print("\n[bold]Usage:[/bold]")
+                rich_print("  • Use [cyan]/prompt <number>[/cyan] to select a prompt by number")
+                rich_print("  • Or use [cyan]/prompts[/cyan] to open the prompt selection UI")
             else:
                 rich_print("[yellow]No prompts available[/yellow]")
         except Exception as e:
@@ -192,7 +293,9 @@ class InteractivePrompt:
         try:
             # Get all available prompts directly from the list_prompts function
             rich_print(f"\n[bold]Fetching prompts for agent [cyan]{agent_name}[/cyan]...[/bold]")
-            prompt_servers = await list_prompts_func(agent_name)
+            # IMPORTANT: list_prompts_func gets MCP server prompts, not agent prompts 
+            # So we pass None to get prompts from all servers, not using agent_name as server name
+            prompt_servers = await list_prompts_func(None)
 
             if not prompt_servers:
                 rich_print("[yellow]No prompts available for this agent[/yellow]")
@@ -242,8 +345,8 @@ class InteractivePrompt:
                                 else:
                                     optional_args.append(name)
 
-                    # Create namespaced version
-                    namespaced_name = f"{server_name}-{prompt_name}"
+                    # Create namespaced version using the consistent separator
+                    namespaced_name = f"{server_name}{SEP}{prompt_name}"
 
                     # Add to collection
                     all_prompts.append(
@@ -410,12 +513,13 @@ class InteractivePrompt:
                             arg_values[arg_name] = arg_value
 
             # Apply the prompt
+            namespaced_name = selected_prompt["namespaced_name"]
             rich_print(
-                f"\n[bold]Applying prompt [cyan]{selected_prompt['namespaced_name']}[/cyan]...[/bold]"
+                f"\n[bold]Applying prompt [cyan]{namespaced_name}[/cyan]...[/bold]"
             )
 
             # Call apply_prompt function with the prompt name and arguments
-            await apply_prompt_func(selected_prompt["namespaced_name"], arg_values, agent_name)
+            await apply_prompt_func(namespaced_name, arg_values, agent_name)
 
         except Exception as e:
             import traceback

mcp_agent/llm/augmented_llm.py

@@ -32,6 +32,7 @@ from mcp_agent.llm.sampling_format_converter import (
     ProviderFormatConverter,
 )
 from mcp_agent.logging.logger import get_logger
+from mcp_agent.mcp.helpers.content_helpers import get_text
 from mcp_agent.mcp.interfaces import (
     AugmentedLLMProtocol,
     ModelT,
@@ -147,8 +148,11 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         """Apply the prompt and return the result as a Pydantic model, or None if coercion fails"""
         try:
             result: PromptMessageMultipart = await self.generate(prompt, request_params)
-            json_data = from_json(result.first_text().strip(), allow_partial=True)
+            final_generation = get_text(result.content[-1]) or ""
+            await self.show_assistant_message(final_generation)
+            json_data = from_json(final_generation, allow_partial=True)
             validated_model = model.model_validate(json_data)
+
             return cast("ModelT", validated_model), Prompt.assistant(json_data)
         except Exception as e:
             logger = get_logger(__name__)

mcp_agent/llm/model_factory.py

@@ -11,6 +11,7 @@ from mcp_agent.llm.providers.augmented_llm_anthropic import AnthropicAugmentedLL
 from mcp_agent.llm.providers.augmented_llm_deepseek import DeepSeekAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_generic import GenericAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_openai import OpenAIAugmentedLLM
+from mcp_agent.llm.providers.augmented_llm_openrouter import OpenRouterAugmentedLLM
 from mcp_agent.mcp.interfaces import AugmentedLLMProtocol
 
 # from mcp_agent.workflows.llm.augmented_llm_deepseek import DeekSeekAugmentedLLM
@@ -23,6 +24,7 @@ LLMClass = Union[
     Type[PassthroughLLM],
     Type[PlaybackLLM],
     Type[DeepSeekAugmentedLLM],
+    Type[OpenRouterAugmentedLLM],
 ]
 
 
@@ -34,6 +36,7 @@ class Provider(Enum):
     FAST_AGENT = auto()
     DEEPSEEK = auto()
     GENERIC = auto()
+    OPENROUTER = auto()
 
 
 class ReasoningEffort(Enum):
@@ -63,6 +66,7 @@ class ModelFactory:
         "fast-agent": Provider.FAST_AGENT,
         "deepseek": Provider.DEEPSEEK,
         "generic": Provider.GENERIC,
+        "openrouter": Provider.OPENROUTER,
     }
 
     # Mapping of effort strings to enum values
@@ -120,6 +124,7 @@ class ModelFactory:
         Provider.FAST_AGENT: PassthroughLLM,
         Provider.DEEPSEEK: DeepSeekAugmentedLLM,
         Provider.GENERIC: GenericAugmentedLLM,
+        Provider.OPENROUTER: OpenRouterAugmentedLLM,
     }
 
     # Mapping of special model names to their specific LLM classes

mcp_agent/llm/providers/augmented_llm_anthropic.py

@@ -1,5 +1,7 @@
 import os
-from typing import TYPE_CHECKING, List, Type
+from typing import TYPE_CHECKING, List
+
+from mcp.types import EmbeddedResource, ImageContent, TextContent
 
 from mcp_agent.core.prompt import Prompt
 from mcp_agent.llm.providers.multipart_converter_anthropic import (
@@ -28,13 +30,11 @@ from mcp.types import (
     CallToolRequest,
     CallToolRequestParams,
 )
-from pydantic_core import from_json
 from rich.text import Text
 
 from mcp_agent.core.exceptions import ProviderKeyError
 from mcp_agent.llm.augmented_llm import (
     AugmentedLLM,
-    ModelT,
     RequestParams,
 )
 from mcp_agent.logging.logger import get_logger
@@ -69,14 +69,15 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
             use_history=True,
         )
 
-    def _base_url(self) -> str:
+    def _base_url(self) -> str | None:
+        assert self.context.config
         return self.context.config.anthropic.base_url if self.context.config.anthropic else None
 
     async def generate_internal(
         self,
         message_param,
         request_params: RequestParams | None = None,
-    ):
+    ) -> list[TextContent | ImageContent | EmbeddedResource]:
         """
         Process a query using an LLM and available tools.
         Override this method to use a different LLM.
@@ -113,7 +114,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
             for tool in tool_list.tools
         ]
 
-        responses: List[Message] = []
+        responses: List[TextContent | ImageContent | EmbeddedResource] = []
 
         model = self.default_request_params.model
 
@@ -175,7 +176,8 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
 
             response_as_message = self.convert_message_to_message_param(response)
             messages.append(response_as_message)
-            responses.append(response)
+            if response.content[0].type == "text":
+                responses.append(TextContent(type="text", text=response.content[0].text))
 
             if response.stop_reason == "end_turn":
                 message_text = ""
@@ -255,6 +257,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
 
                         # Add each result to our collection
                         tool_results.append((tool_use_id, result))
+                        responses.extend(result.content)
 
                     messages.append(AnthropicConverter.create_tool_results_message(tool_results))
 
@@ -295,41 +298,22 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
 
         return api_key
 
-    async def generate_str(
+    async def generate_messages(
         self,
         message_param,
         request_params: RequestParams | None = None,
-    ) -> str:
+    ) -> PromptMessageMultipart:
         """
         Process a query using an LLM and available tools.
         The default implementation uses Claude as the LLM.
         Override this method to use a different LLM.
 
         """
-
-        responses: List[Message] = await self.generate_internal(
+        res = await self.generate_internal(
             message_param=message_param,
             request_params=request_params,
         )
-
-        final_text: List[str] = []
-
-        # Process all responses and collect all text content
-        for response in responses:
-            # Extract text content from each message
-            message_text = ""
-            for content in response.content:
-                if content.type == "text":
-                    # Extract text from text blocks
-                    message_text += content.text
-
-            # Only append non-empty text
-            if message_text:
-                final_text.append(message_text)
-
-        # TODO -- make tool detail inclusion behaviour configurable
-        # Join all collected text
-        return "\n".join(final_text)
+        return Prompt.assistant(*res)
 
     async def _apply_prompt_provider_specific(
         self,
@@ -352,30 +336,12 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         if last_message.role == "user":
             self.logger.debug("Last message in prompt is from user, generating assistant response")
             message_param = AnthropicConverter.convert_to_anthropic(last_message)
-            return Prompt.assistant(await self.generate_str(message_param, request_params))
+            return await self.generate_messages(message_param, request_params)
         else:
             # For assistant messages: Return the last message content as text
             self.logger.debug("Last message in prompt is from assistant, returning it directly")
             return last_message
 
-    async def generate_structured(
-        self,
-        message: str,
-        response_model: Type[ModelT],
-        request_params: RequestParams | None = None,
-    ) -> ModelT:
-        # TODO -- simiar to the OAI version, we should create a tool call for the expected schema
-        response = await self.generate_str(
-            message=message,
-            request_params=request_params,
-        )
-        # Don't try to parse if we got no response
-        if not response:
-            self.logger.error("No response from generate_str")
-            return None
-
-        return response_model.model_validate(from_json(response, allow_partial=True))
-
     @classmethod
     def convert_message_to_message_param(cls, message: Message, **kwargs) -> MessageParam:
         """Convert a response object to an input parameter object to allow LLM calls to be chained."""

mcp_agent/llm/providers/augmented_llm_openai.py

@@ -5,6 +5,9 @@ from mcp.types import (
     CallToolRequest,
     CallToolRequestParams,
     CallToolResult,
+    EmbeddedResource,
+    ImageContent,
+    TextContent,
 )
 from openai import AuthenticationError, OpenAI
 
@@ -115,7 +118,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
         self,
         message,
         request_params: RequestParams | None = None,
-    ) -> List[ChatCompletionMessage]:
+    ) -> List[TextContent | ImageContent | EmbeddedResource]:
         """
         Process a query using an LLM and available tools.
         The default implementation uses OpenAI's ChatCompletion as the LLM.
@@ -164,7 +167,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
         if not available_tools:
             available_tools = None  # deepseek does not allow empty array
 
-        responses: List[ChatCompletionMessage] = []
+        responses: List[TextContent | ImageContent | EmbeddedResource] = []
         model = self.default_request_params.model
 
         # we do NOT send stop sequences as this causes errors with mutlimodal processing
@@ -218,7 +221,9 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
 
             choice = response.choices[0]
             message = choice.message
-            responses.append(message)
+            # prep for image/audio gen models
+            if message.content:
+                responses.append(TextContent(type="text", text=message.content))
 
             converted_message = self.convert_message_to_message_param(message, name=self.name)
             messages.append(converted_message)
@@ -258,7 +263,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                     self.show_oai_tool_result(str(result))
 
                     tool_results.append((tool_call.id, result))
-
+                    responses.extend(result.content)
                 messages.extend(OpenAIConverter.convert_function_results_to_openai(tool_results))
 
                 self.logger.debug(
@@ -310,39 +315,6 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
 
         return responses
 
-    async def generate_str(
-        self,
-        message,
-        request_params: RequestParams | None = None,
-    ) -> str:
-        """
-        Process a query using an LLM and available tools.
-        The default implementation uses OpenAI's ChatCompletion as the LLM.
-        Override this method to use a different LLM.
-
-        Special commands:
-        - "***SAVE_HISTORY <filename.md>" - Saves the conversation history to the specified file
-          in MCP prompt format with user/assistant delimiters.
-        """
-
-        responses = await self.generate_internal(
-            message=message,
-            request_params=request_params,
-        )
-
-        final_text: List[str] = []
-
-        for response in responses:
-            content = response.content
-            if not content:
-                continue
-
-            if isinstance(content, str):
-                final_text.append(content)
-                continue
-
-        return "\n".join(final_text)
-
     async def _apply_prompt_provider_specific(
         self,
         multipart_messages: List["PromptMessageMultipart"],
@@ -366,7 +338,13 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
             # For user messages: Generate response to the last one
             self.logger.debug("Last message in prompt is from user, generating assistant response")
             message_param = OpenAIConverter.convert_to_openai(last_message)
-            return Prompt.assistant(await self.generate_str(message_param, request_params))
+            responses: List[
+                TextContent | ImageContent | EmbeddedResource
+            ] = await self.generate_internal(
+                message_param,
+                request_params,
+            )
+            return Prompt.assistant(*responses)
         else:
             # For assistant messages: Return the last message content as text
             self.logger.debug("Last message in prompt is from assistant, returning it directly")
@@ -411,7 +389,8 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                     role="system", content=self.instruction
                 )
                 messages.insert(0, system_msg)
-
+            model_name = self.default_request_params.model
+            self.show_user_message(prompt[-1].first_text(), model_name, self.chat_turn())
             # Use the beta parse feature
             try:
                 openai_client = OpenAI(api_key=self._api_key(), base_url=self._base_url())
@@ -429,8 +408,8 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
 
                 if response and isinstance(response[0], BaseException):
                     raise response[0]
-
                 parsed_result = response[0].choices[0].message
+                await self.show_assistant_message(parsed_result.content)
                 logger.debug("Successfully used OpenAI beta parse feature for structured output")
                 return parsed_result.parsed, Prompt.assistant(parsed_result.content)
 

mcp_agent/llm/providers/augmented_llm_openrouter.py

@@ -0,0 +1,78 @@
+import os
+
+from mcp_agent.core.exceptions import ProviderKeyError
+from mcp_agent.core.request_params import RequestParams
+from mcp_agent.llm.providers.augmented_llm_openai import OpenAIAugmentedLLM
+
+OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1"
+# No single default model for OpenRouter, users must specify full path
+DEFAULT_OPENROUTER_MODEL = None 
+
+
+class OpenRouterAugmentedLLM(OpenAIAugmentedLLM):
+    """Augmented LLM provider for OpenRouter, using an OpenAI-compatible API."""
+    def __init__(self, *args, **kwargs) -> None:
+        kwargs["provider_name"] = "OpenRouter"  # Set provider name
+        super().__init__(*args, **kwargs)
+
+    def _initialize_default_params(self, kwargs: dict) -> RequestParams:
+        """Initialize OpenRouter-specific default parameters."""
+        # OpenRouter model names include the provider, e.g., "google/gemini-flash-1.5"
+        # The model should be passed in the 'model' kwarg during factory creation.
+        chosen_model = kwargs.get("model", DEFAULT_OPENROUTER_MODEL)
+        if not chosen_model:
+             # Unlike Deepseek, OpenRouter *requires* a model path in the identifier.
+             # The factory should extract this before calling the constructor.
+             # We rely on the model being passed correctly via kwargs.
+             # If it's still None here, it indicates an issue upstream (factory or user input).
+             # However, the base class _get_model handles the error if model is None.
+             pass
+
+
+        return RequestParams(
+            model=chosen_model, # Will be validated by base class
+            systemPrompt=self.instruction,
+            parallel_tool_calls=True, # Default based on OpenAI provider
+            max_iterations=10,      # Default based on OpenAI provider
+            use_history=True,       # Default based on OpenAI provider
+        )
+
+    def _api_key(self) -> str:
+        """Retrieve the OpenRouter API key from config or environment variables."""
+        config = self.context.config
+        api_key = None
+
+        # Check config file first
+        if config and hasattr(config, 'openrouter') and config.openrouter:
+            api_key = getattr(config.openrouter, 'api_key', None)
+            if api_key == "<your-openrouter-api-key-here>" or not api_key:
+                api_key = None
+
+        # Fallback to environment variable
+        if api_key is None:
+            api_key = os.getenv("OPENROUTER_API_KEY")
+
+        if not api_key:
+            raise ProviderKeyError(
+                "OpenRouter API key not configured",
+                "The OpenRouter API key is required but not set.\n"
+                "Add it to your configuration file under openrouter.api_key\n"
+                "Or set the OPENROUTER_API_KEY environment variable.",
+            )
+        return api_key
+
+    def _base_url(self) -> str:
+        """Retrieve the OpenRouter base URL from config or use the default."""
+        base_url = OPENROUTER_BASE_URL # Default
+        config = self.context.config
+        
+        # Check config file for override
+        if config and hasattr(config, 'openrouter') and config.openrouter:
+            config_base_url = getattr(config.openrouter, 'base_url', None)
+            if config_base_url:
+                base_url = config_base_url
+
+        return base_url
+
+    # Other methods like _get_model, _send_request etc., are inherited from OpenAIAugmentedLLM
+    # We may override them later if OpenRouter deviates significantly or offers unique features. 

mcp_agent/mcp/logger_textio.py

@@ -3,7 +3,7 @@ Utilities for MCP stdio client integration with our logging system.
 """
 
 import io
-import sys
+import os
 from typing import TextIO
 
 from mcp_agent.logging.logger import get_logger
@@ -78,10 +78,21 @@ class LoggerTextIO(TextIO):
 
     def fileno(self) -> int:
         """
-        Return a file descriptor for this stream.
-        We use sys.stderr's fileno since TextIO is expected to return a real file descriptor.
+        Return a file descriptor for /dev/null.
+        This prevents output from showing on the terminal
+        while still allowing our write() method to capture it for logging.
         """
-        return sys.stderr.fileno()
+        if not hasattr(self, '_devnull_fd'):
+            self._devnull_fd = os.open(os.devnull, os.O_WRONLY)
+        return self._devnull_fd
+        
+    def __del__(self):
+        """Clean up the devnull file descriptor."""
+        if hasattr(self, '_devnull_fd'):
+            try:
+                os.close(self._devnull_fd)
+            except (OSError, AttributeError):
+                pass
 
 
 def get_stderr_handler(server_name: str) -> TextIO:

mcp_agent/mcp/mcp_connection_manager.py

@@ -3,6 +3,7 @@ Manages the lifecycle of multiple MCP server connections.
 """
 
 import asyncio
+import traceback
 from datetime import timedelta
 from typing import (
     TYPE_CHECKING,
@@ -179,7 +180,7 @@ async def _server_lifecycle_task(server_conn: ServerConnection) -> None:
             },
         )
         server_conn._error_occurred = True
-        server_conn._error_message = str(exc)
+        server_conn._error_message = traceback.format_exception(exc)
         # If there's an error, we should also set the event so that
         # 'get_server' won't hang
         server_conn._initialized_event.set()
@@ -270,7 +271,7 @@ class MCPConnectionManager(ContextDependent):
                 logger.debug(f"{server_name}: Creating stdio client with custom error handler")
                 return stdio_client(server_params, errlog=error_handler)
             elif config.transport == "sse":
-                return sse_client(config.url)
+                return sse_client(config.url, config.headers)
             else:
                 raise ValueError(f"Unsupported transport: {config.transport}")
 
@@ -328,7 +329,8 @@ class MCPConnectionManager(ContextDependent):
         if not server_conn.is_healthy():
             error_msg = server_conn._error_message or "Unknown error"
             raise ServerInitializationError(
-                f"MCP Server: '{server_name}': Failed to initialize with error: '{error_msg}'. Check fastagent.config.yaml"
+                f"MCP Server: '{server_name}': Failed to initialize - see details. Check fastagent.config.yaml?",
+                error_msg,
             )
 
         return server_conn

mcp_agent/mcp_server_registry.py

@@ -152,7 +152,7 @@ class ServerRegistry:
                 raise ValueError(f"URL is required for SSE transport: {server_name}")
 
             # Use sse_client to get the read and write streams
-            async with sse_client(config.url) as (read_stream, write_stream):
+            async with sse_client(config.url, config.headers) as (read_stream, write_stream):
                 session = client_session_factory(
                     read_stream,
                     write_stream,
@@ -260,6 +260,7 @@ class ServerRegistry:
         Returns:
             MCPServerSettings: The server configuration.
         """
+
         server_config = self.registry.get(server_name)
         if server_config is None:
             logger.warning(f"Server '{server_name}' not found in registry.")

mcp_agent/mcp/mcp_activity.py

@@ -1,18 +0,0 @@
-# import functools
-# from temporalio import activity
-# from typing import Dict, Any, List, Callable, Awaitable
-# from .gen_client import gen_client
-
-
-# def mcp_activity(server_name: str, mcp_call: Callable):
-#     def decorator(func):
-#         @activity.defn
-#         @functools.wraps(func)
-#         async def wrapper(*activity_args, **activity_kwargs):
-#             params = await func(*activity_args, **activity_kwargs)
-#             async with gen_client(server_name) as client:
-#                 return await mcp_call(client, params)
-
-#         return wrapper
-
-#     return decorator