fast-agent-mcp 0.2.4__py3-none-any.whl → 0.2.5__py3-none-any.whl

{fast_agent_mcp-0.2.4.dist-info → fast_agent_mcp-0.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.4
+Version: 0.2.5
 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
@@ -244,7 +244,7 @@ Description-Content-Type: text/markdown
 <a href="https://pypi.org/project/fast-agent-mcp/"><img src="https://img.shields.io/pypi/v/fast-agent-mcp?color=%2334D058&label=pypi" /></a>
 <a href="#"><img src="https://github.com/evalstate/fast-agent/actions/workflows/main-checks.yml/badge.svg" /></a>
 <a href="https://github.com/evalstate/fast-agent/issues"><img src="https://img.shields.io/github/issues-raw/evalstate/fast-agent" /></a>
-<a href="https://lmai.link/discord/mcp-agent"><img src="https://shields.io/discord/1089284610329952357" alt="discord" /></a>
+<a href="https://discord.gg/xg5cJ7ndN6"><img src="https://img.shields.io/discord/1358470293990936787" alt="discord" /></a>
 <img alt="Pepy Total Downloads" src="https://img.shields.io/pepy/dt/fast-agent-mcp?label=pypi%20%7C%20downloads"/>
 <a href="https://github.com/evalstate/fast-agent-mcp/blob/main/LICENSE"><img src="https://img.shields.io/pypi/l/fast-agent-mcp" /></a>
 </p>

{fast_agent_mcp-0.2.4.dist-info → fast_agent_mcp-0.2.5.dist-info}/RECORD

@@ -1,15 +1,15 @@
 mcp_agent/__init__.py,sha256=-AIoeL4c9UAp_P4U0z-uIWTTmQWdihOis5nbQ5L_eao,1664
 mcp_agent/app.py,sha256=jBmzYM_o50g8vhlTgkkf5TGiBWNbXWViYnd0WANbpzo,10276
-mcp_agent/config.py,sha256=lI4B9VhF0qplez20cPeegxPA1ZcFBIxzepm_FOhW_08,10758
+mcp_agent/config.py,sha256=V6TZlKOUelv5N75fypWKFVvkY5YsgpoHrdiSsKxOiM0,11725
 mcp_agent/console.py,sha256=Gjf2QLFumwG1Lav__c07X_kZxxEUSkzV-1_-YbAwcwo,813
-mcp_agent/context.py,sha256=NHcfnp5v-dCSxRvzEbavVaI7WOv5ir64IAFbGSnfeHI,7812
+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/progress_display.py,sha256=GeJU9VUt6qKsFVymG688hCMVCsAygG9ifiiEb5IcbN4,361
 mcp_agent/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/agents/agent.py,sha256=NKz8HTCdjIBDSJwl6EHU2NDnZcAtYiaYH3YnbVGrc3Q,3882
-mcp_agent/agents/base_agent.py,sha256=jQ91SBazFwGlwajveLvitMP5oLOQcuEXwUqwe0JPpd8,23203
+mcp_agent/agents/base_agent.py,sha256=mhLgsS_pST1LeBZmnBo9ldEthcKV9LZdBSdt5PkafCk,23184
 mcp_agent/agents/workflow/__init__.py,sha256=HloteEW6kalvgR0XewpiFAqaQlMPlPJYg5p3K33IUzI,25
 mcp_agent/agents/workflow/chain_agent.py,sha256=ff5ksaJiAm007MMl8QO4pBTTIgQLcf9GLZpRtYkfBJQ,6201
 mcp_agent/agents/workflow/evaluator_optimizer.py,sha256=ArM2CySsTY0gSPndox1DdjecRdNtWIj-Qm9ApUWkygw,13103
@@ -20,7 +20,7 @@ mcp_agent/agents/workflow/parallel_agent.py,sha256=denkFKrvZJZ4c3Cja9cx-EOUhd-mD
 mcp_agent/agents/workflow/router_agent.py,sha256=iOIPhMP9-w-lho50obx1rvGphI_-7Hdr9E9ohlKmtJk,10484
 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=oumTbJPbiLFomm5IcdKJNjP3kXVkeYTxZEtYTkBBfLA,2742
+mcp_agent/cli/main.py,sha256=PZdPJfsAJOm80vTu7j_XpMPhaDZOpqSe-ciU3YQsmA4,3149
 mcp_agent/cli/terminal.py,sha256=GRwD-RGW7saIz2IOWZn5vD6JjiArscELBThm1GTFkuI,1065
 mcp_agent/cli/commands/bootstrap.py,sha256=Pv3LQUQLK_5-8nbOQ6iibJI7awgD04P9xh6-VpU15pw,11571
 mcp_agent/cli/commands/config.py,sha256=jU2gl4d5YESrdUboh3u6mxf7CxVT-_DT_sK8Vuh3ajw,231
@@ -29,11 +29,11 @@ mcp_agent/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/core/agent_app.py,sha256=9c7V-gZKudl-6u2BB__aLEvC4iemJeWpyoI8fGpXsXk,10145
 mcp_agent/core/agent_types.py,sha256=Qyhvzy2CcD7wMaxavuMUOQnD_rg5LZ1RT3DwXVYaM1Q,1345
 mcp_agent/core/direct_decorators.py,sha256=_kS0C9UbwRQ54z58vfUapFXXyJrm1XRVyLMuB7bL0b8,14471
-mcp_agent/core/direct_factory.py,sha256=PGkQCeTd7ACd1aHwDWsPOQPyG5_NbC8U2wxzbldTJ1Q,17764
-mcp_agent/core/enhanced_prompt.py,sha256=loLFJfBgFaAxYqZednUJLLuunFiwrYQb60y1_wNJsgQ,17927
+mcp_agent/core/direct_factory.py,sha256=oMozbr6kK37vWtAIvzCKtlX1i7KTez3hLdQfeXCWUjM,17580
+mcp_agent/core/enhanced_prompt.py,sha256=P9FAtc0rqIYQfUDkTNVXitFIZEtB3fdq_Nr0-st64Qg,17948
 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=ttkBs2yYaZb1gsL6-iYaopSsBKUt4kVeddj16TuWZ2o,12477
+mcp_agent/core/fastagent.py,sha256=HTy1OCAhpHIM-4cd37-dxvb97eZUELN-ICAEFgqmJMk,18503
 mcp_agent/core/interactive_prompt.py,sha256=04yoeOX2JLatr2tuOFfnb84GMwFUIBnBC7y1M_gqOM8,17692
 mcp_agent/core/mcp_content.py,sha256=2D7KHY9mG_vxoDwFLKvsPQV9VRIzHItM7V-jcEnACh8,8878
 mcp_agent/core/prompt.py,sha256=qnintOUGEoDPYLI9bu9G2OlgVMCe5ZPUZilgMzydXhc,7919
@@ -50,11 +50,11 @@ 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=3T7F-VcNc4_n7f9ODBcIhE1KYeFgACOdMslPG0FV624,18124
-mcp_agent/llm/augmented_llm_passthrough.py,sha256=_DC6lGYbXPMXBeJn9Ot2fq-fXJ5GP7HhRmlY9pNvJ2s,6033
+mcp_agent/llm/augmented_llm.py,sha256=K7sfUaJrFqupEbq7xi7hDjyAC4UMXQBYQxza5TFJ6VA,18117
+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=y65gUc8IyX8vbdK_oOIIjauIYk5h7jyrDAdjTlRdBcc,7655
+mcp_agent/llm/model_factory.py,sha256=WOm2IkZLhgFTplmgjVAzNzjpawm3D_aTVcGdgu1DReg,7606
 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
@@ -84,13 +84,12 @@ mcp_agent/mcp/interfaces.py,sha256=8fsQj8r7sMrIyrJHHbUIEP86SVLyXPpEI36KZq1abc0,6
 mcp_agent/mcp/logger_textio.py,sha256=OpnqMam9Pu0oVzYQWFMhrX1dRg2f5Fqb3qqPA6QAATM,2778
 mcp_agent/mcp/mcp_activity.py,sha256=CajXCFWZ2cKEX9s4-HfNVAj471ePTVs4NOkvmIh65tE,592
 mcp_agent/mcp/mcp_agent_client_session.py,sha256=RMYNltc2pDIzxwEJSS5589RbvPO0KWV4Y3jSyAmhKf0,4181
-mcp_agent/mcp/mcp_agent_server.py,sha256=SnKJ9KCMnklGLHKZ9UsgAxd9IOKqiSCRPmQeTGu0CK8,1643
 mcp_agent/mcp/mcp_aggregator.py,sha256=jaWbOvb3wioECohZ47CubyxfJ5QkfNSshu1hwhZksG4,40486
 mcp_agent/mcp/mcp_connection_manager.py,sha256=desQBreHbIcjY7AidcDO6pFomHOx9oOZPOWIcHAx1K0,13761
 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
-mcp_agent/mcp/prompt_serialization.py,sha256=-qmE6CmGyB-wmFqZ3L7PyJtidw8kmwuXpt6x1XHdJVk,15856
+mcp_agent/mcp/prompt_serialization.py,sha256=El12k47c9568sju6fqiaYkYySC9RVhScarHeR_QihNk,17323
 mcp_agent/mcp/resource_utils.py,sha256=K4XY8bihmBMleRTZ2viMPiD2Y2HWxFnlgIJi6dd_PYE,6588
 mcp_agent/mcp/sampling.py,sha256=vzWrIdI1CyFSxDWO-O69TpD6RwQcCM694BqMlYPVtaw,4584
 mcp_agent/mcp/helpers/__init__.py,sha256=sKqwlUR3jSsd9PVJKjXtxHgZA1YOdzPtsSW4xVey77Q,52
@@ -99,19 +98,19 @@ mcp_agent/mcp/prompts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 mcp_agent/mcp/prompts/__main__.py,sha256=gr1Tdz9fcK0EXjEuZg_BOnKUmvhYq5AH2lFZicVyNb0,237
 mcp_agent/mcp/prompts/prompt_constants.py,sha256=Q9W0t3rOXl2LHIG9wcghApUV2QZ1iICuo7SwVwHUf3c,566
 mcp_agent/mcp/prompts/prompt_helpers.py,sha256=Joqo2t09pTKDP-Wge3G-ozPEHikzjaqwV6GVk8hNR50,7534
-mcp_agent/mcp/prompts/prompt_load.py,sha256=ohRvAzJwZvgrN_7iKzy0RA7ILWVlOoD8KvI1c0Xr_eI,3908
+mcp_agent/mcp/prompts/prompt_load.py,sha256=VkcY6dD1jRCu-OB5AtSO8YwVATjEoYCkyAIGIujIHmw,5583
 mcp_agent/mcp/prompts/prompt_server.py,sha256=tXtQd4EnH86MmdAvHlXm4oOS1dWLSCW5PvoA7uU1TvA,16493
 mcp_agent/mcp/prompts/prompt_template.py,sha256=EejiqGkau8OizORNyKTUwUjrPof5V-hH1H_MBQoQfXw,15732
 mcp_agent/mcp_server/__init__.py,sha256=zBU51ITHIEPScd9nRafnhEddsWqXRPAAvHhkrbRI2_4,155
-mcp_agent/mcp_server/agent_server.py,sha256=vGMPy9ZjceqlOAnwDgm29bzjZegxChXZQHvj7OUs5Oo,4472
+mcp_agent/mcp_server/agent_server.py,sha256=5jEHJcoKHKRhMAwn3HArqiqtiiLcFZvantABoEHSw8k,6470
 mcp_agent/resources/examples/data-analysis/analysis-campaign.py,sha256=QdNdo0-7LR4Uzw61hEU_jVKmWyk6A9YpGo81kMwVobM,7267
 mcp_agent/resources/examples/data-analysis/analysis.py,sha256=M9z8Q4YC5OGuqSa5uefYmmfmctqMn-WqCSfg5LI407o,2609
 mcp_agent/resources/examples/data-analysis/fastagent.config.yaml,sha256=ini94PHyJCfgpjcjHKMMbGuHs6LIj46F1NwY0ll5HVk,1609
 mcp_agent/resources/examples/data-analysis/mount-point/WA_Fn-UseC_-HR-Employee-Attrition.csv,sha256=pcMeOL1_r8m8MziE6xgbBrQbjl5Ijo98yycZn7O-dlk,227977
 mcp_agent/resources/examples/in_dev/agent_build.py,sha256=eetMEdYDbmnRH4CLO7chpQucAar3OE7iVzD_pnMjIGs,2854
 mcp_agent/resources/examples/in_dev/slides.py,sha256=-SEFeGIg9SLF253NIxmA0NjlanLe8CR1yjDBBp2LXgs,4904
-mcp_agent/resources/examples/internal/agent.py,sha256=RZOMb5cJzIY1k0V28YgrHcUFSt0Uy977towy4yJE7bA,502
-mcp_agent/resources/examples/internal/fastagent.config.yaml,sha256=7anEzFqlMg3i5T8fEiqGYSO3fgMGI5P2BRsOJKsKl8k,1983
+mcp_agent/resources/examples/internal/agent.py,sha256=JDfb-64gKoEG6ihsyyVWkuY9XNOdC1-P3r9qwG_qN28,497
+mcp_agent/resources/examples/internal/fastagent.config.yaml,sha256=EPJW8vsRfYq57w2U2gPF0rTAxGhkaLgiYXw0mnpXsdM,2060
 mcp_agent/resources/examples/internal/history_transfer.py,sha256=ETyX2wMMvUnMpUhu4ij9ZTpw2wQR6vPpBwlXJswPnhM,1157
 mcp_agent/resources/examples/internal/job.py,sha256=ANF3c01gHJ4O4pIxaAtC3rdgYqVObMySaCUBS4dApW4,4102
 mcp_agent/resources/examples/internal/prompt_category.py,sha256=kMvqNX_zu0sV-kTaAR3skc_tsq9t8QSEofciK0m4aJc,551
@@ -135,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.4.dist-info/METADATA,sha256=ZZc6lPJvUVd0k4Cw9nqy-tOrNjw5KtIlT_Cb8cOR0tk,29841
-fast_agent_mcp-0.2.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fast_agent_mcp-0.2.4.dist-info/entry_points.txt,sha256=qPM7vwtN1_KmP3dXehxgiCxUBHtqP7yfenZigztvY-w,226
-fast_agent_mcp-0.2.4.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
-fast_agent_mcp-0.2.4.dist-info/RECORD,,
+fast_agent_mcp-0.2.5.dist-info/METADATA,sha256=oL4nXJVnNJOv5M5KccLqjAY7jZsygvnIY2-1ZdXb1SI,29839
+fast_agent_mcp-0.2.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fast_agent_mcp-0.2.5.dist-info/entry_points.txt,sha256=qPM7vwtN1_KmP3dXehxgiCxUBHtqP7yfenZigztvY-w,226
+fast_agent_mcp-0.2.5.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
+fast_agent_mcp-0.2.5.dist-info/RECORD,,

mcp_agent/agents/base_agent.py

@@ -120,28 +120,30 @@ class BaseAgent(MCPAggregator, AgentProtocol):
         llm_factory: Union[Type[AugmentedLLMProtocol], Callable[..., AugmentedLLMProtocol]],
         model: Optional[str] = None,
         request_params: Optional[RequestParams] = None,
-        **additional_kwargs
+        **additional_kwargs,
     ) -> AugmentedLLMProtocol:
         """
         Create and attach an LLM instance to this agent.
-        
+
         Parameters have the following precedence (highest to lowest):
         1. Explicitly passed parameters to this method
         2. Agent's default_request_params
         3. LLM's default values
-        
+
         Args:
             llm_factory: A class or callable that constructs an AugmentedLLM
             model: Optional model name override
             request_params: Optional request parameters override
             **additional_kwargs: Additional parameters passed to the LLM constructor
-            
+
         Returns:
             The created LLM instance
         """
         # Start with agent's default params
-        effective_params = self._default_request_params.model_copy() if self._default_request_params else None
-        
+        effective_params = (
+            self._default_request_params.model_copy() if self._default_request_params else None
+        )
+
         # Override with explicitly passed request_params
         if request_params:
             if effective_params:
@@ -151,18 +153,16 @@ class BaseAgent(MCPAggregator, AgentProtocol):
                         setattr(effective_params, k, v)
             else:
                 effective_params = request_params
-        
+
         # Override model if explicitly specified
         if model and effective_params:
             effective_params.model = model
-        
+
         # Create the LLM instance
         self._llm = llm_factory(
-            agent=self,
-            request_params=effective_params,
-            **additional_kwargs
+            agent=self, request_params=effective_params, context=self._context, **additional_kwargs
         )
-        
+
         return self._llm
 
     async def shutdown(self) -> None:
@@ -468,7 +468,7 @@ class BaseAgent(MCPAggregator, AgentProtocol):
 
         # Get the prompt - this will search all servers if needed
         self.logger.debug(f"Loading prompt '{prompt_name}'")
-        prompt_result = await self.get_prompt(prompt_name, arguments, server_name)
+        prompt_result: GetPromptResult = await self.get_prompt(prompt_name, arguments, server_name)
 
         if not prompt_result or not prompt_result.messages:
             error_msg = f"Prompt '{prompt_name}' could not be found or contains no messages"

mcp_agent/cli/main.py

@@ -62,6 +62,7 @@ def main(
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose mode"),
     quiet: bool = typer.Option(False, "--quiet", "-q", help="Disable output"),
     color: bool = typer.Option(True, "--color/--no-color", help="Enable/disable color output"),
+    version: bool = typer.Option(False, "--version", help="Show version and exit"),
 ) -> None:
     """FastAgent CLI - Build effective agents using Model Context Protocol (MCP).
 
@@ -70,6 +71,16 @@ def main(
     application.verbosity = 1 if verbose else 0 if not quiet else -1
     application.console = application.console if color else None
 
+    # Handle version flag
+    if version:
+        from importlib.metadata import version as get_version
+        try:
+            app_version = get_version("fast-agent-mcp")
+        except:  # noqa: E722
+            app_version = "unknown"
+        console.print(f"fast-agent-mcp v{app_version}")
+        raise typer.Exit()
+
     # Show welcome message if no command was invoked
     if ctx.invoked_subcommand is None:
         show_welcome()

mcp_agent/config.py

@@ -40,7 +40,7 @@ class MCPRootSettings(BaseModel):
     @classmethod
     def validate_uri(cls, v: str) -> str:
         """Validate that the URI starts with file:// (required by specification 2024-11-05)"""
-        if not v.startswith("file://"):
+        if v and not v.startswith("file://"):
             raise ValueError("Root URI must start with file://")
         return v
 
@@ -276,9 +276,9 @@ class Settings(BaseSettings):
         # Check current directory and parent directories
         while current_dir != current_dir.parent:
             for filename in [
+                "fastagent.config.yaml",
                 "mcp-agent.config.yaml",
                 "mcp_agent.config.yaml",
-                "fastagent.config.yaml",
             ]:
                 config_path = current_dir / filename
                 if config_path.exists():
@@ -306,15 +306,33 @@ def get_settings(config_path: str | None = None) -> Settings:
         return merged
 
     global _settings
-    if _settings:
+
+    # If we have a specific config path, always reload settings
+    # This ensures each test gets its own config
+    if config_path:
+        # Reset for the new path
+        _settings = None
+    elif _settings:
+        # Use cached settings only for no specific path
         return _settings
 
-    config_file = Path(config_path) if config_path else Settings.find_config()
+    # Handle config path - convert string to Path if needed
+    if config_path:
+        config_file = Path(config_path)
+        # If it's a relative path and doesn't exist, try finding it
+        if not config_file.is_absolute() and not config_file.exists():
+            # Try resolving against current directory first
+            resolved_path = Path.cwd() / config_file.name
+            if resolved_path.exists():
+                config_file = resolved_path
+    else:
+        config_file = Settings.find_config()
+
     merged_settings = {}
 
     if config_file:
         if not config_file.exists():
-            pass
+            print(f"Warning: Specified config file does not exist: {config_file}")
         else:
             import yaml  # pylint: disable=C0415
 
@@ -326,11 +344,14 @@ def get_settings(config_path: str | None = None) -> Settings:
             # but stop after finding the first one
             current_dir = config_file.parent
             found_secrets = False
+            # Start with the absolute path of the config file's directory
+            current_dir = config_file.parent.resolve()
+
             while current_dir != current_dir.parent and not found_secrets:
                 for secrets_filename in [
+                    "fastagent.secrets.yaml",
                     "mcp-agent.secrets.yaml",
                     "mcp_agent.secrets.yaml",
-                    "fastagent.secrets.yaml",
                 ]:
                     secrets_file = current_dir / secrets_filename
                     if secrets_file.exists():
@@ -340,7 +361,8 @@ def get_settings(config_path: str | None = None) -> Settings:
                             found_secrets = True
                             break
                 if not found_secrets:
-                    current_dir = current_dir.parent
+                    # Get the absolute path of the parent directory
+                    current_dir = current_dir.parent.resolve()
 
             _settings = Settings(**merged_settings)
             return _settings

mcp_agent/context.py

@@ -234,5 +234,7 @@ def get_current_context() -> Context:
 def get_current_config():
     """
     Get the current application config.
+    
+    Returns the context config if available, otherwise falls back to global settings.
     """
     return get_current_context().config or get_settings()

mcp_agent/core/direct_factory.py

@@ -148,10 +148,7 @@ async def create_agents_by_type(
 
                 # Attach LLM to the agent
                 llm_factory = model_factory_func(model=config.model)
-                await agent.attach_llm(
-                    llm_factory,
-                    request_params=config.default_request_params
-                )
+                await agent.attach_llm(llm_factory, request_params=config.default_request_params)
                 result_agents[name] = agent
 
             elif agent_type == AgentType.ORCHESTRATOR:
@@ -185,8 +182,7 @@ async def create_agents_by_type(
                 # Attach LLM to the orchestrator
                 llm_factory = model_factory_func(model=config.model)
                 await orchestrator.attach_llm(
-                    llm_factory,
-                    request_params=config.default_request_params
+                    llm_factory, request_params=config.default_request_params
                 )
 
                 result_agents[name] = orchestrator
@@ -201,9 +197,7 @@ async def create_agents_by_type(
                     # Create default fan-in agent with auto-generated name
                     fan_in_name = f"{name}_fan_in"
                     fan_in_agent = await _create_default_fan_in_agent(
-                        fan_in_name,
-                        app_instance.context, 
-                        model_factory_func
+                        fan_in_name, app_instance.context, model_factory_func
                     )
                     # Add to result_agents so it's registered properly
                     result_agents[fan_in_name] = fan_in_agent
@@ -248,10 +242,7 @@ async def create_agents_by_type(
 
                 # Attach LLM to the router
                 llm_factory = model_factory_func(model=config.model)
-                await router.attach_llm(
-                    llm_factory,
-                    request_params=config.default_request_params
-                )
+                await router.attach_llm(llm_factory, request_params=config.default_request_params)
                 result_agents[name] = router
 
             elif agent_type == AgentType.CHAIN:
@@ -459,7 +450,7 @@ async def _create_default_fan_in_agent(
     default_config = AgentConfig(
         name=fan_in_name,
         model="passthrough",
-        instruction="You are a passthrough agent that combines outputs from parallel agents."
+        instruction="You are a passthrough agent that combines outputs from parallel agents.",
     )
 
     # Create and initialize the default agent

mcp_agent/core/enhanced_prompt.py

@@ -291,7 +291,7 @@ async def get_enhanced_input(
                 return f"SELECT_PROMPT:{cmd_parts[1].strip()}"
             elif cmd == "exit":
                 return "EXIT"
-            elif cmd == "stop":
+            elif cmd.lower() == "stop":
                 return "STOP"
 
         # Agent switching
@@ -420,7 +420,7 @@ async def get_argument_input(
             prompt_session.app.exit()
 
 
-async def handle_special_commands(command, agent_app=None):
+async def handle_special_commands(command: str, agent_app=None):
     """Handle special input commands."""
     # Quick guard for empty or None commands
     if not command:
@@ -450,7 +450,7 @@ async def handle_special_commands(command, agent_app=None):
         print("\033c", end="")
         return True
 
-    elif command == "EXIT":
+    elif command.upper() == "EXIT":
         raise PromptExitError("User requested to exit fast-agent session")
 
     elif command == "LIST_AGENTS":

mcp_agent/core/fastagent.py

@@ -6,14 +6,15 @@ directly creates Agent instances without proxies.
 
 import argparse
 import asyncio
-import os
+import sys
 from contextlib import asynccontextmanager
+from importlib.metadata import version as get_version
 from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, TypeVar
 
 import yaml
 
+from mcp_agent import config
 from mcp_agent.app import MCPApp
-from mcp_agent.config import Settings
 from mcp_agent.context import Context
 from mcp_agent.core.agent_app import AgentApp
 from mcp_agent.core.direct_decorators import (
@@ -70,7 +71,7 @@ class FastAgent:
     def __init__(
         self,
         name: str,
-        config_path: Optional[str] = None,
+        config_path: str | None = None,
         ignore_unknown_args: bool = False,
     ) -> None:
         """
@@ -101,6 +102,33 @@ class FastAgent:
             action="store_true",
             help="Disable progress display, tool and message logging for cleaner output",
         )
+        parser.add_argument(
+            "--version",
+            action="store_true",
+            help="Show version and exit",
+        )
+        parser.add_argument(
+            "--server",
+            action="store_true",
+            help="Run as an MCP server",
+        )
+        parser.add_argument(
+            "--transport",
+            choices=["sse", "stdio"],
+            default="sse",
+            help="Transport protocol to use when running as a server (sse or stdio)",
+        )
+        parser.add_argument(
+            "--port",
+            type=int,
+            default=8000,
+            help="Port to use when running as a server with SSE transport",
+        )
+        parser.add_argument(
+            "--host",
+            default="0.0.0.0",
+            help="Host address to bind to when running as a server with SSE transport",
+        )
 
         if ignore_unknown_args:
             known_args, _ = parser.parse_known_args()
@@ -108,10 +136,28 @@ class FastAgent:
         else:
             self.args = parser.parse_args()
 
+        # Handle version flag
+        if self.args.version:
+            try:
+                app_version = get_version("fast-agent-mcp")
+            except:  # noqa: E722
+                app_version = "unknown"
+            print(f"fast-agent-mcp v{app_version}")
+            sys.exit(0)
+
         self.name = name
         self.config_path = config_path
+
         try:
+            # Load configuration directly for this instance
             self._load_config()
+
+            # Create the app with our local settings
+            self.app = MCPApp(
+                name=name,
+                settings=config.Settings(**self.config) if hasattr(self, "config") else None,
+            )
+
         except yaml.parser.ParserError as e:
             handle_error(
                 e,
@@ -119,25 +165,30 @@ class FastAgent:
                 "There was an error parsing the config or secrets YAML configuration file.",
             )
             raise SystemExit(1)
-        # Create the MCPApp with the config
-        self.app = MCPApp(
-            name=name,
-            settings=Settings(**self.config) if hasattr(self, "config") else None,
-        )
 
         # Dictionary to store agent configurations from decorators
         self.agents: Dict[str, Dict[str, Any]] = {}
 
     def _load_config(self) -> None:
-        """Load configuration from YAML file"""
-        if self.config_path:
-            with open(self.config_path) as f:
-                self.config = yaml.safe_load(f) or {}
-        elif os.path.exists("fastagent.config.yaml"):
-            with open("fastagent.config.yaml") as f:
-                self.config = yaml.safe_load(f) or {}
-        else:
-            self.config = {}
+        """Load configuration from YAML file including secrets using get_settings
+        but without relying on the global cache."""
+
+        # Import but make a local copy to avoid affecting the global state
+        from mcp_agent.config import _settings, get_settings
+
+        # Temporarily clear the global settings to ensure a fresh load
+        old_settings = _settings
+        _settings = None
+
+        try:
+            # Use get_settings to load config - this handles all paths and secrets merging
+            settings = get_settings(self.config_path)
+
+            # Convert to dict for backward compatibility
+            self.config = settings.model_dump() if settings else {}
+        finally:
+            # Restore the original global settings
+            _settings = old_settings
 
     @property
     def context(self) -> Context:
@@ -166,16 +217,17 @@ class FastAgent:
         quiet_mode = hasattr(self, "args") and self.args.quiet
 
         try:
-            async with self.app.run() as agent_app:
+            async with self.app.run():
                 # Apply quiet mode if requested
                 if (
                     quiet_mode
-                    and hasattr(agent_app.context, "config")
-                    and hasattr(agent_app.context.config, "logger")
+                    and hasattr(self.app.context, "config")
+                    and hasattr(self.app.context.config, "logger")
                 ):
-                    agent_app.context.config.logger.progress_display = False
-                    agent_app.context.config.logger.show_chat = False
-                    agent_app.context.config.logger.show_tools = False
+                    # Update our app's config directly
+                    self.app.context.config.logger.progress_display = False
+                    self.app.context.config.logger.show_chat = False
+                    self.app.context.config.logger.show_tools = False
 
                     # Directly disable the progress display singleton
                     from mcp_agent.progress_display import progress_display
@@ -205,6 +257,41 @@ class FastAgent:
                 # Create a wrapper with all agents for simplified access
                 wrapper = AgentApp(active_agents)
 
+                # Handle command line options that should be processed after agent initialization
+
+                # Handle --server option
+                if hasattr(self, "args") and self.args.server:
+                    try:
+                        # Print info message if not in quiet mode
+                        if not quiet_mode:
+                            print(f"Starting FastAgent '{self.name}' in server mode")
+                            print(f"Transport: {self.args.transport}")
+                            if self.args.transport == "sse":
+                                print(f"Listening on {self.args.host}:{self.args.port}")
+                            print("Press Ctrl+C to stop")
+
+                        # Create the MCP server
+                        from mcp_agent.mcp_server import AgentMCPServer
+
+                        mcp_server = AgentMCPServer(
+                            agent_app=wrapper,
+                            server_name=f"{self.name}-MCP-Server",
+                        )
+
+                        # Run the server directly (this is a blocking call)
+                        await mcp_server.run_async(
+                            transport=self.args.transport, host=self.args.host, port=self.args.port
+                        )
+                    except KeyboardInterrupt:
+                        if not quiet_mode:
+                            print("\nServer stopped by user (Ctrl+C)")
+                    except Exception as e:
+                        if not quiet_mode:
+                            print(f"\nServer stopped with error: {e}")
+
+                    # Exit after server shutdown
+                    raise SystemExit(0)
+
                 # Handle direct message sending if --agent and --message are provided
                 if hasattr(self, "args") and self.args.agent and self.args.message:
                     agent_name = self.args.agent
@@ -222,7 +309,8 @@ class FastAgent:
                         agent = active_agents[agent_name]
                         response = await agent.send(message)
 
-                        # Print the response in quiet mode
+                        # In quiet mode, just print the raw response
+                        # The chat display should already be turned off by the configuration
                         if self.args.quiet:
                             print(f"{response}")
 
@@ -313,6 +401,58 @@ class FastAgent:
         else:
             handle_error(e, error_type or "Error", "An unexpected error occurred.")
 
+    async def start_server(
+        self,
+        transport: str = "sse",
+        host: str = "0.0.0.0",
+        port: int = 8000,
+        server_name: Optional[str] = None,
+        server_description: Optional[str] = None,
+    ) -> None:
+        """
+        Start the application as an MCP server.
+        This method initializes agents and exposes them through an MCP server.
+        It is a blocking method that runs until the server is stopped.
+
+        Args:
+            transport: Transport protocol to use ("stdio" or "sse")
+            host: Host address for the server when using SSE
+            port: Port for the server when using SSE
+            server_name: Optional custom name for the MCP server
+            server_description: Optional description for the MCP server
+        """
+        # This method simply updates the command line arguments and uses run()
+        # to ensure we follow the same initialization path for all operations
+
+        # Store original args
+        original_args = None
+        if hasattr(self, "args"):
+            original_args = self.args
+
+        # Create our own args object with server settings
+        from argparse import Namespace
+
+        self.args = Namespace()
+        self.args.server = True
+        self.args.transport = transport
+        self.args.host = host
+        self.args.port = port
+        self.args.quiet = (
+            original_args.quiet if original_args and hasattr(original_args, "quiet") else False
+        )
+        self.args.model = None
+        if hasattr(original_args, "model"):
+            self.args.model = original_args.model
+
+        # Run the application, which will detect the server flag and start server mode
+        async with self.run():
+            pass  # This won't be reached due to SystemExit in run()
+
+        # Restore original args (if we get here)
+        if original_args:
+            self.args = original_args
+
+    # Keep run_with_mcp_server for backward compatibility
     async def run_with_mcp_server(
         self,
         transport: str = "sse",
@@ -323,6 +463,8 @@ class FastAgent:
     ) -> None:
         """
         Run the application and expose agents through an MCP server.
+        This method is kept for backward compatibility.
+        For new code, use start_server() instead.
 
         Args:
             transport: Transport protocol to use ("stdio" or "sse")
@@ -331,26 +473,40 @@ class FastAgent:
             server_name: Optional custom name for the MCP server
             server_description: Optional description for the MCP server
         """
-        from mcp_agent.mcp_server import AgentMCPServer
-
-        async with self.run() as agent_app:
-            # Create the MCP server
-            mcp_server = AgentMCPServer(
-                agent_app=agent_app,
-                server_name=server_name or f"{self.name}-MCP-Server",
-                server_description=server_description,
-            )
-
-            # Run the MCP server in a separate task
-            server_task = asyncio.create_task(
-                mcp_server.run_async(transport=transport, host=host, port=port)
-            )
+        await self.start_server(
+            transport=transport,
+            host=host,
+            port=port,
+            server_name=server_name,
+            server_description=server_description,
+        )
 
-            try:
-                # Wait for the server task to complete (or be cancelled)
-                await server_task
-            except asyncio.CancelledError:
-                # Propagate cancellation
-                server_task.cancel()
-                await asyncio.gather(server_task, return_exceptions=True)
-                raise
+    async def main(self):
+        """
+        Helper method for checking if server mode was requested.
+
+        Usage:
+        ```python
+        fast = FastAgent("My App")
+
+        @fast.agent(...)
+        async def app_main():
+            # Check if server mode was requested
+            # This doesn't actually do anything - the check happens in run()
+            # But it provides a way for application code to know if server mode
+            # was requested for conditionals
+            is_server_mode = hasattr(self, "args") and self.args.server
+
+            # Normal run - this will handle server mode automatically if requested
+            async with fast.run() as agent:
+                # This code only executes for normal mode
+                # Server mode will exit before reaching here
+                await agent.send("Hello")
+        ```
+
+        Returns:
+            bool: True if --server flag is set, False otherwise
+        """
+        # Just check if the flag is set, no action here
+        # The actual server code will be handled by run()
+        return hasattr(self, "args") and self.args.server

mcp_agent/llm/augmented_llm.py

@@ -39,7 +39,6 @@ from mcp_agent.mcp.interfaces import (
 from mcp_agent.mcp.mcp_aggregator import MCPAggregator
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 from mcp_agent.mcp.prompt_render import render_multipart_message
-from mcp_agent.mcp.prompt_serialization import multipart_messages_to_delimited_format
 from mcp_agent.ui.console_display import ConsoleDisplay
 
 # Define type variables locally
@@ -435,16 +434,15 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
 
     async def _save_history(self, filename: str) -> None:
         """
-        Save the Message History to a file in a simple delimeted format.
+        Save the Message History to a file in a format determined by the file extension.
+
+        Uses JSON format for .json files (MCP SDK compatible format) and
+        delimited text format for other extensions.
         """
-        # Convert to delimited format
-        delimited_content = multipart_messages_to_delimited_format(
-            self._message_history,
-        )
+        from mcp_agent.mcp.prompt_serialization import save_messages_to_file
 
-        # Write to file
-        with open(filename, "w", encoding="utf-8") as f:
-            f.write("\n\n".join(delimited_content))
+        # Save messages using the unified save function that auto-detects format
+        save_messages_to_file(self._message_history, filename)
 
     @abstractmethod
     async def _apply_prompt_provider_specific(

mcp_agent/llm/augmented_llm_passthrough.py

@@ -143,7 +143,9 @@ class PassthroughLLM(AugmentedLLM):
 
         # TODO -- improve when we support Audio/Multimodal gen
         if self.is_tool_call(last_message):
-            return Prompt.assistant(await self.generate_str(last_message.first_text()))
+            result = Prompt.assistant(await self.generate_str(last_message.first_text()))
+            await self.show_assistant_message(result.first_text())
+            return result
 
         if last_message.first_text().startswith(FIXED_RESPONSE_INDICATOR):
             self._fixed_response = (

mcp_agent/llm/model_factory.py

@@ -103,7 +103,7 @@ class ModelFactory:
         "sonnet": "claude-3-7-sonnet-latest",
         "sonnet35": "claude-3-5-sonnet-latest",
         "sonnet37": "claude-3-7-sonnet-latest",
-        "claude": "claude-3-5-sonnet-latest",
+        "claude": "claude-3-7-sonnet-latest",
         "haiku": "claude-3-5-haiku-latest",
         "haiku3": "claude-3-haiku-20240307",
         "haiku35": "claude-3-5-haiku-latest",
@@ -188,24 +188,22 @@ class ModelFactory:
 
         # Create a factory function matching the updated attach_llm protocol
         def factory(
-            agent: Agent, 
-            request_params: Optional[RequestParams] = None, 
-            **kwargs
+            agent: Agent, request_params: Optional[RequestParams] = None, **kwargs
         ) -> AugmentedLLMProtocol:
             # Create base params with parsed model name
             base_params = RequestParams()
             base_params.model = config.model_name  # Use the parsed model name, not the alias
-            
+
             # Add reasoning effort if available
             if config.reasoning_effort:
                 kwargs["reasoning_effort"] = config.reasoning_effort.value
-            
+
             # Forward all arguments to LLM constructor
             llm_args = {
                 "agent": agent,
                 "model": config.model_name,
                 "request_params": request_params,
-                **kwargs
+                **kwargs,
             }
 
             llm: AugmentedLLMProtocol = llm_class(**llm_args)

mcp_agent/mcp/prompt_serialization.py

@@ -110,6 +110,48 @@ def load_messages_from_json_file(file_path: str) -> List[PromptMessageMultipart]
     return json_to_multipart_messages(json_str)
 
 
+def save_messages_to_file(messages: List[PromptMessageMultipart], file_path: str) -> None:
+    """
+    Save PromptMessageMultipart objects to a file, with format determined by file extension.
+    
+    Uses JSON format for .json files and delimited text format for other extensions.
+    
+    Args:
+        messages: List of PromptMessageMultipart objects
+        file_path: Path to save the file
+    """
+    path_str = str(file_path).lower()
+    
+    if path_str.endswith(".json"):
+        # Use JSON format for .json files (MCP SDK compatible format)
+        save_messages_to_json_file(messages, file_path)
+    else:
+        # Use delimited text format for other extensions
+        save_messages_to_delimited_file(messages, file_path)
+
+
+def load_messages_from_file(file_path: str) -> List[PromptMessageMultipart]:
+    """
+    Load PromptMessageMultipart objects from a file, with format determined by file extension.
+    
+    Uses JSON format for .json files and delimited text format for other extensions.
+    
+    Args:
+        file_path: Path to the file
+        
+    Returns:
+        List of PromptMessageMultipart objects
+    """
+    path_str = str(file_path).lower()
+    
+    if path_str.endswith(".json"):
+        # Use JSON format for .json files (MCP SDK compatible format)
+        return load_messages_from_json_file(file_path)
+    else:
+        # Use delimited text format for other extensions
+        return load_messages_from_delimited_file(file_path)
+
+
 # -------------------------------------------------------------------------
 # Delimited Text Format Functions
 # -------------------------------------------------------------------------

mcp_agent/mcp/prompts/prompt_load.py

@@ -101,9 +101,57 @@ def create_resource_message(
 
 
 def load_prompt(file: Path) -> List[PromptMessage]:
-    template: PromptTemplate = PromptTemplateLoader().load_from_file(file)
-    return create_messages_with_resources(template.content_sections, [file])
+    """
+    Load a prompt from a file and return as PromptMessage objects.
+    
+    The loader uses file extension to determine the format:
+    - .json files are loaded as MCP SDK compatible JSON format
+    - All other files are loaded using the template-based delimited format
+    
+    Args:
+        file: Path to the prompt file
+        
+    Returns:
+        List of PromptMessage objects
+    """
+    file_str = str(file).lower()
+    
+    if file_str.endswith(".json"):
+        # JSON format (MCP SDK compatible)
+        from mcp_agent.mcp.prompt_serialization import load_messages_from_json_file
+        
+        # Load multipart messages and convert to flat messages
+        multipart_messages = load_messages_from_json_file(str(file))
+        messages = []
+        for mp in multipart_messages:
+            messages.extend(mp.from_multipart())
+        return messages
+    else:
+        # Template-based format (delimited text)
+        template: PromptTemplate = PromptTemplateLoader().load_from_file(file)
+        return create_messages_with_resources(template.content_sections, [file])
 
 
 def load_prompt_multipart(file: Path) -> List[PromptMessageMultipart]:
-    return PromptMessageMultipart.to_multipart(load_prompt(file))
+    """
+    Load a prompt from a file and return as PromptMessageMultipart objects.
+    
+    The loader uses file extension to determine the format:
+    - .json files are loaded as MCP SDK compatible JSON format
+    - All other files are loaded using the template-based delimited format
+    
+    Args:
+        file: Path to the prompt file
+        
+    Returns:
+        List of PromptMessageMultipart objects
+    """
+    file_str = str(file).lower()
+    
+    if file_str.endswith(".json"):
+        # JSON format (MCP SDK compatible)
+        from mcp_agent.mcp.prompt_serialization import load_messages_from_json_file
+        return load_messages_from_json_file(str(file))
+    else:
+        # Template-based format (delimited text)
+        return PromptMessageMultipart.to_multipart(load_prompt(file))

mcp_agent/mcp_server/agent_server.py

@@ -1,9 +1,13 @@
 # src/mcp_agent/mcp_server/agent_server.py
 
+import asyncio
+
 from mcp.server.fastmcp import Context as MCPContext
 from mcp.server.fastmcp import FastMCP
 
-# Import the DirectAgentApp instead of AgentApp
+import mcp_agent
+import mcp_agent.core
+import mcp_agent.core.prompt
 from mcp_agent.core.agent_app import AgentApp
 
 
@@ -14,7 +18,7 @@ class AgentMCPServer:
         self,
         agent_app: AgentApp,
         server_name: str = "FastAgent-MCP-Server",
-        server_description: str = None,
+        server_description: str | None = None,
     ) -> None:
         self.agent_app = agent_app
         self.mcp_server = FastMCP(
@@ -26,10 +30,10 @@ class AgentMCPServer:
 
     def setup_tools(self) -> None:
         """Register all agents as MCP tools."""
-        for agent_name, agent_proxy in self.agent_app._agents.items():
-            self.register_agent_tools(agent_name, agent_proxy)
+        for agent_name, agent in self.agent_app._agents.items():
+            self.register_agent_tools(agent_name, agent)
 
-    def register_agent_tools(self, agent_name: str, agent_proxy) -> None:
+    def register_agent_tools(self, agent_name: str, agent) -> None:
         """Register tools for a specific agent."""
 
         # Basic send message tool
@@ -41,13 +45,11 @@ class AgentMCPServer:
             """Send a message to the agent and return its response."""
 
             # Get the agent's context
-            agent_context = None
-            if hasattr(agent_proxy, "_agent") and hasattr(agent_proxy._agent, "context"):
-                agent_context = agent_proxy._agent.context
+            agent_context = getattr(agent, "context", None)
 
             # Define the function to execute
             async def execute_send():
-                return await agent_proxy.send(message)
+                return await agent.send(message)
 
             # Execute with bridged context
             if agent_context and ctx:
@@ -55,6 +57,25 @@ class AgentMCPServer:
             else:
                 return await execute_send()
 
+        # Register a history prompt for this agent
+        @self.mcp_server.prompt(name=f"{agent_name}.history", description=f"Conversation history for the {agent_name} agent")
+        async def get_history_prompt() -> list:
+            """Return the conversation history as MCP messages."""
+            # Get the conversation history from the agent's LLM
+            if not hasattr(agent, "_llm") or agent._llm is None:
+                return []
+                
+            # Convert the multipart message history to standard PromptMessages
+            multipart_history = agent._llm.message_history
+            prompt_messages = mcp_agent.core.prompt.Prompt.from_multipart(multipart_history)
+            
+            # In FastMCP, we need to return the raw list of messages
+            # that matches the structure that FastMCP expects (list of dicts with role/content)
+            return [
+                {"role": msg.role, "content": msg.content}
+                for msg in prompt_messages
+            ]
+
     def run(self, transport: str = "sse", host: str = "0.0.0.0", port: int = 8000) -> None:
         """Run the MCP server."""
         if transport == "sse":
@@ -71,9 +92,19 @@ class AgentMCPServer:
         if transport == "sse":
             self.mcp_server.settings.host = host
             self.mcp_server.settings.port = port
-            await self.mcp_server.run_sse_async()
+            try:
+                await self.mcp_server.run_sse_async()
+            except (asyncio.CancelledError, KeyboardInterrupt):
+                # Gracefully handle cancellation during shutdown
+                await self.shutdown()
+                pass
         else:  # stdio
-            await self.mcp_server.run_stdio_async()
+            try:
+                await self.mcp_server.run_stdio_async()
+            except (asyncio.CancelledError, KeyboardInterrupt):
+                # Gracefully handle cancellation during shutdown
+                await self.shutdown()
+                pass
 
     async def with_bridged_context(self, agent_context, mcp_context, func, *args, **kwargs):
         """
@@ -115,3 +146,21 @@ class AgentMCPServer:
             # Remove MCP context reference
             if hasattr(agent_context, "mcp_context"):
                 delattr(agent_context, "mcp_context")
+
+    async def shutdown(self):
+        """Gracefully shutdown the MCP server and its resources."""
+        # Your MCP server may have additional cleanup code here
+        try:
+            # If your MCP server has a shutdown method, call it
+            if hasattr(self.mcp_server, "shutdown"):
+                await self.mcp_server.shutdown()
+
+            # Clean up any other resources
+            import asyncio
+
+            # Allow any pending tasks to clean up
+            await asyncio.sleep(0.5)
+        except Exception as e:
+            # Just log exceptions during shutdown, don't raise
+            print(f"Error during MCP server shutdown: {e}")
+            pass

mcp_agent/resources/examples/internal/agent.py

@@ -7,13 +7,13 @@ fast = FastAgent("FastAgent Example")
 
 
 # Define the agent
-@fast.agent(servers=["category", "mcp_hfspace"])
+@fast.agent(servers=["category", "mcp_hfspace","mcp_webcam"])
 #@fast.agent(name="test")
 async def main() -> None:
     # use the --model command line switch or agent arguments to change model
     async with fast.run() as agent:
 #        await agent.prompt(agent_name="test")
-        await agent.send("hello,world")
+        await agent()
 
 
 if __name__ == "__main__":

mcp_agent/resources/examples/internal/fastagent.config.yaml

@@ -59,3 +59,8 @@ mcp:
     mcp_hfspace:
       command: "npx"
       args: ["@llmindset/mcp-hfspace"]
+
+    mcp_webcam:
+      command: "npx"
+      args: ["@llmindset/mcp-webcam"]
+

mcp_agent/mcp/mcp_agent_server.py

@@ -1,56 +0,0 @@
-import asyncio
-
-from mcp.server import NotificationOptions
-from mcp.server.fastmcp import FastMCP
-from mcp.server.stdio import stdio_server
-
-from mcp_agent.executor.temporal import get_temporal_client
-from mcp_agent.telemetry.tracing import setup_tracing
-
-app = FastMCP("mcp-agent-server")
-
-setup_tracing("mcp-agent-server")
-
-
-async def run() -> None:
-    async with stdio_server() as (read_stream, write_stream):
-        await app._mcp_server.run(
-            read_stream,
-            write_stream,
-            app._mcp_server.create_initialization_options(
-                notification_options=NotificationOptions(tools_changed=True, resources_changed=True)
-            ),
-        )
-
-
-@app.tool
-async def run_workflow(query: str) -> None:
-    """Run the workflow given its name or id"""
-    pass
-
-
-@app.tool
-async def pause_workflow(workflow_id: str) -> None:
-    """Pause a running workflow."""
-    temporal_client = await get_temporal_client()
-    handle = temporal_client.get_workflow_handle(workflow_id)
-    await handle.signal("pause")
-
-
-@app.tool
-async def resume_workflow(workflow_id: str) -> None:
-    """Resume a paused workflow."""
-    temporal_client = await get_temporal_client()
-    handle = temporal_client.get_workflow_handle(workflow_id)
-    await handle.signal("resume")
-
-
-async def provide_user_input(workflow_id: str, input_data: str) -> None:
-    """Provide user/human input to a waiting workflow step."""
-    temporal_client = await get_temporal_client()
-    handle = temporal_client.get_workflow_handle(workflow_id)
-    await handle.signal("human_input", input_data)
-
-
-if __name__ == "__main__":
-    asyncio.run(run())