fast-agent-mcp 0.1.9__py3-none-any.whl → 0.1.10__py3-none-any.whl

{fast_agent_mcp-0.1.9.dist-info → fast_agent_mcp-0.1.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.1.9
+Version: 0.1.10
 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
@@ -259,9 +259,10 @@ The simple declarative syntax lets you concentrate on composing your Prompts and
 
 Evaluate how different models handle Agent and MCP Server calling tasks, then build multi-model workflows using the best provider for each task.
 
-`fast-agent` is now multi-modal, supporting Images and PDFs for both Anthropic and OpenAI endpoints (for supported models), via Prompts and MCP Tool Call results.
+`fast-agent` is now multi-modal, supporting Images and PDFs for both Anthropic and OpenAI endpoints (for supported models), via Prompts, Resources and MCP Tool Call results.
 
-> [!TIP] > `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site.
+> [!TIP]
+> `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site.
 
 ### Agent Application Development
 

{fast_agent_mcp-0.1.9.dist-info → fast_agent_mcp-0.1.10.dist-info}/RECORD

@@ -2,13 +2,13 @@ mcp_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/app.py,sha256=0_C1xmNZlk9qZoewnNI_mC7sSfO9oJgkOyiKkQ62MHU,10606
 mcp_agent/config.py,sha256=OpPTsk9gNm2IA1laUomAMkGA-pAlp5uILQpEPBjavQs,10644
 mcp_agent/console.py,sha256=Gjf2QLFumwG1Lav__c07X_kZxxEUSkzV-1_-YbAwcwo,813
-mcp_agent/context.py,sha256=qzwUrexZXVBzFiNkYI4xjztdGxuuiDWZbWrQgVhA-vE,8126
+mcp_agent/context.py,sha256=m1S5M9a2Kdxy5rEGG6Uwwmi19bDEpU6u-e5ZgPmVXfY,8031
 mcp_agent/context_dependent.py,sha256=TGqRLzYCOnsWGoaD1HtrliYtWo8MeaWCQk6ePUmyYCw,1446
 mcp_agent/event_progress.py,sha256=25iz0yyg-O4glMmtijcYpDdUmtUIKsCmR_8A52GgeC4,2716
-mcp_agent/mcp_server_registry.py,sha256=5x30L1IlmC18JASl7NQbZYHMqPWS3ay0f_3U3uleaMM,9884
+mcp_agent/mcp_server_registry.py,sha256=eQbl0usicnsNE03haxc6C_FHl_0goPAZdcb082cDIQk,9992
 mcp_agent/progress_display.py,sha256=GeJU9VUt6qKsFVymG688hCMVCsAygG9ifiiEb5IcbN4,361
 mcp_agent/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mcp_agent/agents/agent.py,sha256=foxgVBSjpRp697467-girJmAjmEylfDCXbXtI660wHI,13173
+mcp_agent/agents/agent.py,sha256=qI3njT8SPTLKzCwBfdlWNMVoSEwLGNjuq6owPfhvIas,17444
 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=DE6EZzspfzHwPK59x8vL4AIDHRQkVQ1Ja70XRGU1IQs,2753
@@ -24,11 +24,11 @@ mcp_agent/core/decorators.py,sha256=dkAah1eIuYsEfQISDryG0u2GrzNnsO_jyN7lhpQfNlM,
 mcp_agent/core/enhanced_prompt.py,sha256=bykUEnnc1CEWODJwXvl4VGfCtrJPtVXU0D4mUglJK7A,18827
 mcp_agent/core/error_handling.py,sha256=D3HMW5odrbJvaKqcpCGj6eDXrbFcuqYaCZz7fyYiTu4,623
 mcp_agent/core/exceptions.py,sha256=a2-JGRwFFRoQEPuAq0JC5PhAJ5TO3xVJfdS4-VN29cw,2225
-mcp_agent/core/factory.py,sha256=TYtGtUKEVQi96uXQu3RddrpYGiUGolHMEATS57e4hgw,19074
-mcp_agent/core/fastagent.py,sha256=CYor0u4Vqrn8XmYIaSEtfuLrJgF2YChJUAE_3xjRGmk,19659
+mcp_agent/core/factory.py,sha256=MhlYS0G0IyFy_j46HVJdjEznJzfCFjx_NRhUPcbQIJI,19081
+mcp_agent/core/fastagent.py,sha256=jJmO0DryFGwSkse_3q5Ll-5XONDvj7k_Oeb-ETBKFkA,19620
 mcp_agent/core/mcp_content.py,sha256=rXT2C5gP9qgC-TI5F362ZLJi_erzcEOnlP9D2ZKK0i0,6860
 mcp_agent/core/prompt.py,sha256=R-X3kptu3ehV_SQeiGnP6F9HMN-92I8e73gnkQ1tDVs,4317
-mcp_agent/core/proxies.py,sha256=lawAc3mcoYlDpX9HwBc8tdh2oAr9YS_CT2LtbqXvuyg,8858
+mcp_agent/core/proxies.py,sha256=a5tNv-EVcv67XNAkbzaybQVbRgkNEfhIkcveS1LBp2s,10242
 mcp_agent/core/types.py,sha256=Zhi9iW7uiOfdpSt9NC0FCtGRFtJPg4mpZPK2aYi7a7M,817
 mcp_agent/core/validation.py,sha256=x0fsx5eLTawASFm9MDtEukwGOj_RTdY1OW064UihMR8,8309
 mcp_agent/eval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -45,7 +45,7 @@ mcp_agent/human_input/types.py,sha256=ZvuDHvI0-wO2tFoS0bzrv8U5B83zYdxAG7g9G9jCxu
 mcp_agent/logging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/logging/events.py,sha256=qfYJnrqgXdujV-nl-iOwBEBh6HMraowBI4zeAWPPU4A,3461
 mcp_agent/logging/json_serializer.py,sha256=pa_mf0i0YKpLsGq3THuITFUdAbmae-dv1OPOLbcS0to,5782
-mcp_agent/logging/listeners.py,sha256=lx2Pq_SE0rsG3nF3TwDSxkmsWzdXxIUjuaWct-KOtJ8,6631
+mcp_agent/logging/listeners.py,sha256=1DOc0CvAE6pFxOljfZqs2TGgF50sZZGMDt4Gm_PAjWo,6551
 mcp_agent/logging/logger.py,sha256=Tr009BnfGUKuZcdinnSin0Z_zIsfDNGdcnamw2rDHRQ,10604
 mcp_agent/logging/rich_progress.py,sha256=IEVFdFGA0nwg6pSt9Ydni5LCNYZZPKYMe-6DCi9pO4Y,4851
 mcp_agent/logging/tracing.py,sha256=jQivxKYl870oXakmyUk7TXuTQSvsIzpHwZlSQfy4b0c,5203
@@ -53,18 +53,18 @@ mcp_agent/logging/transport.py,sha256=MFgiCQ-YFP0tSMhDMpZCj585vflWcMydM4oyCFduVf
 mcp_agent/mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/mcp/gen_client.py,sha256=u0HwdJiw9YCerS5JC7JDuGgBh9oTcLd7vv9vPjwibXc,3025
 mcp_agent/mcp/mcp_activity.py,sha256=CajXCFWZ2cKEX9s4-HfNVAj471ePTVs4NOkvmIh65tE,592
-mcp_agent/mcp/mcp_agent_client_session.py,sha256=NtWcQhjmnnaR3yYcYj2d2lh-m563NexZUa57K1tAjeM,9477
+mcp_agent/mcp/mcp_agent_client_session.py,sha256=lfz38wzIoMfZyH3dAgclHohOVX0tR7Y2FCE2t7CVsPw,3956
 mcp_agent/mcp/mcp_agent_server.py,sha256=xP09HZTeguJi4Fq0p3fjLBP55uSYe5AdqM90xCgn9Ho,1639
-mcp_agent/mcp/mcp_aggregator.py,sha256=X_SnSX-_CPye87Xst_h0XyO4Cd3EuxBCEvLhU1SlRkU,36045
-mcp_agent/mcp/mcp_connection_manager.py,sha256=EPJTKiEMKnFYpC37SOXiLriQL2YyhH0s6vvZWQRb_Mo,13663
+mcp_agent/mcp/mcp_aggregator.py,sha256=NuFslY5-0as2VAfcg6t-k3sgpX-mh3AWttuS9KHL4n4,37684
+mcp_agent/mcp/mcp_connection_manager.py,sha256=PdLia-rxbhUdAdEnW7TQbkf1qeI9RR3xhQw1j11Bi6o,13612
 mcp_agent/mcp/mime_utils.py,sha256=difepNR_gpb4MpMLkBRAoyhDk-AjXUHTiqKvT_VwS1o,1805
 mcp_agent/mcp/prompt_message_multipart.py,sha256=U7IN0JStmy26akTXcqE4x90oWzm8xs1qa0VeKIyPKmE,1962
 mcp_agent/mcp/prompt_serialization.py,sha256=StcXV7V4fqqtCmOCXGCyYXx5vpwNhL2xr3RG_awwdqI,16056
-mcp_agent/mcp/resource_utils.py,sha256=x-hMxVH7moVY0PLV1LHkpzk8cihL8AJINtzRcaGsiSE,6358
-mcp_agent/mcp/stdio.py,sha256=tW075R5rQ-UlflXWFKIFDgCbWbuhKqxhiYolWvyEkFs,3985
+mcp_agent/mcp/resource_utils.py,sha256=G9IBWyasxKKcbq3T_fSpM6mHE8PjBargEdfQnBPrkZY,6650
+mcp_agent/mcp/stdio.py,sha256=QJcxEw2CXJrhR7PHyhuwUekzaXoDng_cNjai-rdZNg0,4479
 mcp_agent/mcp/prompts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/mcp/prompts/__main__.py,sha256=gr1Tdz9fcK0EXjEuZg_BOnKUmvhYq5AH2lFZicVyNb0,237
-mcp_agent/mcp/prompts/prompt_server.py,sha256=lGa-H2rXarVcbwrcjfhdZ0rGwggE9eytUko6soiJVXo,17375
+mcp_agent/mcp/prompts/prompt_server.py,sha256=6K4FeKNW_JApWUNB055gl8UnWyC1mvtl_kPEvgUnPjk,17348
 mcp_agent/mcp/prompts/prompt_template.py,sha256=NDnSVA0W1wayZHCVx27lfuVPoxlAz-FfBwiCEQG9Ixk,16324
 mcp_agent/mcp_server/__init__.py,sha256=SEWyU7aSFzdSk6iTYnrQu-llji5_P5dp3TaztCt_rzo,154
 mcp_agent/mcp_server/agent_server.py,sha256=SUBggPyrzWtBRUC5xIMpCxu6ei-6Vah3q9Si12BQ-zY,4444
@@ -93,7 +93,7 @@ mcp_agent/resources/examples/workflows/chaining.py,sha256=1G_0XBcFkSJCOXb6N_iXWl
 mcp_agent/resources/examples/workflows/evaluator.py,sha256=3XmW1mjImlaWb0c5FWHYS9yP8nVGTbEdJySAoWXwrDg,3109
 mcp_agent/resources/examples/workflows/fastagent.config.yaml,sha256=k2AiapOcK42uqG2nWDVvnSLqN4okQIQZK0FTbZufBpY,809
 mcp_agent/resources/examples/workflows/human_input.py,sha256=c8cBdLEPbaMXddFwsfN3Z7RFs5PZXsdrjANfvq1VTPM,605
-mcp_agent/resources/examples/workflows/orchestrator.py,sha256=orsE4S03uk4ylkhERmTwzIyqyL7kFHR7oOzvYV3Id38,2599
+mcp_agent/resources/examples/workflows/orchestrator.py,sha256=2nkRkpMgi4V-M6fwcpipQUImf0nZoGf4zfVllfojsz8,2596
 mcp_agent/resources/examples/workflows/parallel.py,sha256=pLbQrtXfbdYqMVddxtg5dZnBnm5Wo2mXlIa1Vf2F1FQ,3096
 mcp_agent/resources/examples/workflows/router.py,sha256=J1yTAimFY53jcyd21cq1XAZvtOxnNsmtSjSp13M5EgE,1668
 mcp_agent/resources/examples/workflows/sse.py,sha256=tdmmh7p87YNfcF_fCq3evAmc1Nek0oY0YOqLRKBLqKg,570
@@ -120,7 +120,7 @@ mcp_agent/workflows/llm/anthropic_utils.py,sha256=OFmsVmDQ22880duDWQrEeQEB47xtvu
 mcp_agent/workflows/llm/augmented_llm.py,sha256=9cWy-4yNG13w4oQgXmisgWTcm6aoJIRCYTX85Bkf-MI,30554
 mcp_agent/workflows/llm/augmented_llm_anthropic.py,sha256=opV4PTai2eoYUzJS0gCPGEy4pe-lT2Eo1Sao6Y_EIiY,20140
 mcp_agent/workflows/llm/augmented_llm_openai.py,sha256=OUSmvY2m6HU1JOK5nEzKDHpHReT0ffjoHDFHk6aYhoc,21002
-mcp_agent/workflows/llm/augmented_llm_passthrough.py,sha256=oZC9K90DdjvCQiQ-2yH1FGTTYsjPl9EMRx4n5_CihIM,3996
+mcp_agent/workflows/llm/augmented_llm_passthrough.py,sha256=IoMNOKK9l46bp4OxfXrB4uK7_4X7ufjuFyXSQCH4YnM,6219
 mcp_agent/workflows/llm/augmented_llm_playback.py,sha256=5ypv3owJU6pscktqg9tkLQVKNgaA50e8OWmC1hAhrtE,4328
 mcp_agent/workflows/llm/llm_selector.py,sha256=G7pIybuBDwtmyxUDov_QrNYH2FoI0qFRu2JfoxWUF5Y,11045
 mcp_agent/workflows/llm/model_factory.py,sha256=UHePE5Ow03kpE44kjYtFGEhVFSYp0AY2yGri58yCBKU,7688
@@ -151,8 +151,8 @@ mcp_agent/workflows/swarm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 mcp_agent/workflows/swarm/swarm.py,sha256=-lAIeSWDqbGHGRPTvjiP9nIKWvxxy9DAojl9yQzO1Pw,11050
 mcp_agent/workflows/swarm/swarm_anthropic.py,sha256=pW8zFx5baUWGd5Vw3nIDF2oVOOGNorij4qvGJKdYPcs,1624
 mcp_agent/workflows/swarm/swarm_openai.py,sha256=wfteywvAGkT5bLmIxX_StHJq8144whYmCRnJASAjOes,1596
-fast_agent_mcp-0.1.9.dist-info/METADATA,sha256=c7JIWUS2bWR5pQQ6cVPwzBOQspzzvB8I25zo3wRUCQg,29748
-fast_agent_mcp-0.1.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fast_agent_mcp-0.1.9.dist-info/entry_points.txt,sha256=qPM7vwtN1_KmP3dXehxgiCxUBHtqP7yfenZigztvY-w,226
-fast_agent_mcp-0.1.9.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
-fast_agent_mcp-0.1.9.dist-info/RECORD,,
+fast_agent_mcp-0.1.10.dist-info/METADATA,sha256=Kum2eRyw2tDXTb1rG7JIf-2IrkOC-xWOnFyQpulgXq4,29760
+fast_agent_mcp-0.1.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fast_agent_mcp-0.1.10.dist-info/entry_points.txt,sha256=qPM7vwtN1_KmP3dXehxgiCxUBHtqP7yfenZigztvY-w,226
+fast_agent_mcp-0.1.10.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
+fast_agent_mcp-0.1.10.dist-info/RECORD,,

mcp_agent/agents/agent.py

@@ -9,7 +9,10 @@ from mcp.types import (
     ListToolsResult,
     TextContent,
     Tool,
+    EmbeddedResource,
+    ReadResourceResult,
 )
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
 from mcp_agent.core.exceptions import PromptExitError
 from mcp_agent.mcp.mcp_aggregator import MCPAggregator
@@ -320,6 +323,11 @@ class Agent(MCPAggregator):
                 ],
             )
 
+    async def read_resource(
+        self, server_name: str, resource_name: str
+    ) -> ReadResourceResult:
+        return None
+
     async def apply_prompt(
         self, prompt_name: str, arguments: dict[str, str] = None
     ) -> str:
@@ -359,3 +367,107 @@ class Agent(MCPAggregator):
         # The LLM will automatically generate a response if needed
         result = await self._llm.apply_prompt_template(prompt_result, display_name)
         return result
+
+    async def get_resource(self, server_name: str, resource_name: str):
+        """
+        Get a resource directly from an MCP server by name.
+
+        Args:
+            server_name: Name of the MCP server to retrieve the resource from
+            resource_name: Name of the resource to retrieve
+
+        Returns:
+            The resource object from the MCP server
+
+        Raises:
+            ValueError: If the server doesn't exist or the resource couldn't be found
+        """
+        if not self.initialized:
+            await self.initialize()
+
+        # Get the specified server connection
+        server = self.get_server(server_name)
+        if not server:
+            raise ValueError(f"Server '{server_name}' not found or not connected")
+
+        # Request the resource directly from the server
+        try:
+            resource_result = await server.get_resource(resource_name)
+            return resource_result
+        except Exception as e:
+            self.logger.error(
+                f"Error retrieving resource '{resource_name}' from server '{server_name}': {str(e)}"
+            )
+            raise ValueError(
+                f"Failed to retrieve resource '{resource_name}' from server '{server_name}': {str(e)}"
+            )
+
+    async def get_embedded_resources(
+        self, server_name: str, resource_name: str
+    ) -> List[EmbeddedResource]:
+        """
+        Get a resource from an MCP server and return it as a list of embedded resources ready for use in prompts.
+
+        Args:
+            server_name: Name of the MCP server to retrieve the resource from
+            resource_name: Name or URI of the resource to retrieve
+
+        Returns:
+            List of EmbeddedResource objects ready to use in a PromptMessageMultipart
+
+        Raises:
+            ValueError: If the server doesn't exist or the resource couldn't be found
+        """
+        # Get the raw resource result
+        result: ReadResourceResult = await super().get_resource(
+            server_name, resource_name
+        )
+
+        # Convert each resource content to an EmbeddedResource
+        embedded_resources: List[EmbeddedResource] = []
+        for resource_content in result.contents:
+            embedded_resource = EmbeddedResource(
+                type="resource", resource=resource_content, annotations=None
+            )
+            embedded_resources.append(embedded_resource)
+
+        return embedded_resources
+
+    async def with_resource(
+        self,
+        prompt_content: Union[str, PromptMessageMultipart],
+        server_name: str,
+        resource_name: str,
+    ) -> str:
+        """
+        Create a prompt with the given content and resource, then send it to the agent.
+
+        Args:
+            prompt_content: Either a string message or an existing PromptMessageMultipart
+            server_name: Name of the MCP server to retrieve the resource from
+            resource_name: Name or URI of the resource to retrieve
+
+        Returns:
+            The agent's response as a string
+        """
+        # Get the embedded resources
+        embedded_resources: List[EmbeddedResource] = await self.get_embedded_resources(
+            server_name, resource_name
+        )
+
+        # Create or update the prompt message
+        prompt: PromptMessageMultipart
+        if isinstance(prompt_content, str):
+            # Create a new prompt with the text and resources
+            content = [TextContent(type="text", text=prompt_content)]
+            content.extend(embedded_resources)
+            prompt = PromptMessageMultipart(role="user", content=content)
+        elif isinstance(prompt_content, PromptMessageMultipart):
+            # Add resources to the existing prompt
+            prompt = prompt_content
+            prompt.content.extend(embedded_resources)
+        else:
+            raise TypeError("prompt_content must be a string or PromptMessageMultipart")
+
+        # Send the prompt to the agent and return the response
+        return await self._llm.generate_prompt(prompt, None)

mcp_agent/context.py

@@ -24,7 +24,6 @@ from mcp_agent.executor.executor import Executor
 from mcp_agent.executor.decorator_registry import (
     DecoratorRegistry,
     register_asyncio_decorators,
-    register_temporal_decorators,
 )
 from mcp_agent.executor.task_registry import ActivityRegistry
 from mcp_agent.executor.executor import AsyncioExecutor
@@ -194,7 +193,6 @@ async def initialize_context(
 
     context.decorator_registry = DecoratorRegistry()
     register_asyncio_decorators(context.decorator_registry)
-    register_temporal_decorators(context.decorator_registry)
 
     # Store the tracer in context if needed
     context.tracer = trace.get_tracer(config.otel.service_name)

mcp_agent/core/factory.py

@@ -172,16 +172,17 @@ async def create_agents_by_type(
             if agent_type == AgentType.BASIC:
                 # Get the agent name for special handling
                 agent_name = agent_data["config"].name
-                agent = Agent(config=config, context=app_instance.context)
-
-                # Set up LLM with proper configuration
-                async with agent:
-                    llm_factory = model_factory_func(
-                        model=config.model,
-                        request_params=config.default_request_params,
-                    )
-                    agent._llm = await agent.attach_llm(llm_factory)
+                agent = Agent(
+                    config=config,
+                    context=app_instance.context,
+                )
+                await agent.initialize()
 
+                llm_factory = model_factory_func(
+                    model=config.model,
+                    request_params=config.default_request_params,
+                )
+                agent._llm = await agent.attach_llm(llm_factory)
                 # Store the agent
                 instance = agent
 
@@ -222,16 +223,16 @@ async def create_agents_by_type(
                     default_request_params=base_params,
                 )
                 planner_agent = Agent(
-                    config=planner_config, context=app_instance.context
+                    config=planner_config,
+                    context=app_instance.context,
                 )
                 planner_factory = model_factory_func(
                     model=config.model,
                     request_params=config.default_request_params,
                 )
 
-                async with planner_agent:
-                    planner = await planner_agent.attach_llm(planner_factory)
-
+                planner = await planner_agent.attach_llm(planner_factory)
+                await planner.initialize()
                 # Create the orchestrator with pre-configured planner
                 instance = Orchestrator(
                     name=config.name,

mcp_agent/core/fastagent.py

@@ -16,7 +16,6 @@ from contextlib import asynccontextmanager
 from functools import partial
 
 from mcp_agent.app import MCPApp
-from mcp_agent.context_dependent import ContextDependent
 from mcp_agent.config import Settings
 
 from mcp_agent.core.agent_app import AgentApp
@@ -64,7 +63,7 @@ from mcp_agent.mcp_server import AgentMCPServer
 T = TypeVar("T")  # For the wrapper classes
 
 
-class FastAgent(ContextDependent):
+class FastAgent:
     """
     A decorator-based interface for MCP Agent applications.
     Provides a simplified way to create and manage agents using decorators.
@@ -320,6 +319,7 @@ class FastAgent(ContextDependent):
         """
         active_agents = {}
         had_error = False
+        await self.app.initialize()
 
         # Handle quiet mode by disabling logger settings after initialization
         quiet_mode = hasattr(self, "args") and self.args.quiet

mcp_agent/core/proxies.py

@@ -8,6 +8,7 @@ from typing import List, Optional, Dict, Union, TYPE_CHECKING
 from mcp_agent.agents.agent import Agent
 from mcp_agent.app import MCPApp
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from mcp.types import EmbeddedResource
 
 # Handle circular imports
 if TYPE_CHECKING:
@@ -129,6 +130,43 @@ class LLMAgentProxy(BaseAgentProxy):
         """
         return await self._agent.apply_prompt(prompt_name, arguments)
 
+    # Add the new methods
+    async def get_embedded_resources(
+        self, server_name: str, resource_name: str
+    ) -> List[EmbeddedResource]:
+        """
+        Get a resource from an MCP server and return it as a list of embedded resources ready for use in prompts.
+
+        Args:
+            server_name: Name of the MCP server to retrieve the resource from
+            resource_name: Name or URI of the resource to retrieve
+
+        Returns:
+            List of EmbeddedResource objects ready to use in a PromptMessageMultipart
+        """
+        return await self._agent.get_embedded_resources(server_name, resource_name)
+
+    async def with_resource(
+        self,
+        prompt_content: Union[str, PromptMessageMultipart],
+        server_name: str,
+        resource_name: str,
+    ) -> str:
+        """
+        Create a prompt with the given content and resource, then send it to the agent.
+
+        Args:
+            prompt_content: Either a string message or an existing PromptMessageMultipart
+            server_name: Name of the MCP server to retrieve the resource from
+            resource_name: Name or URI of the resource to retrieve
+
+        Returns:
+            The agent's response as a string
+        """
+        return await self._agent.with_resource(
+            prompt_content, server_name, resource_name
+        )
+
 
 class WorkflowProxy(BaseAgentProxy):
     """Proxy for workflow types that implement generate_str() directly"""

mcp_agent/logging/listeners.py

@@ -177,10 +177,7 @@ class BatchingListener(FilteredListener):
 
         if self._flush_task and not self._flush_task.done():
             self._flush_task.cancel()
-            try:
-                await self._flush_task
-            except asyncio.CancelledError:
-                pass
+            await self._flush_task
             self._flush_task = None
         await self.flush()
 
@@ -193,8 +190,8 @@ class BatchingListener(FilteredListener):
                     )
                 except asyncio.TimeoutError:
                     await self.flush()
-        except asyncio.CancelledError:
-            pass
+        # except asyncio.CancelledError:
+        #     break
         finally:
             await self.flush()  # Final flush
 

mcp_agent/mcp/mcp_agent_client_session.py

@@ -7,7 +7,6 @@ from typing import Optional
 
 from mcp import ClientSession
 from mcp.shared.session import (
-    RequestResponder,
     ReceiveResultT,
     ReceiveNotificationT,
     RequestId,
@@ -16,18 +15,11 @@ from mcp.shared.session import (
     SendResultT,
 )
 from mcp.types import (
-    ClientResult,
-    CreateMessageRequest,
-    CreateMessageResult,
     ErrorData,
-    JSONRPCNotification,
-    JSONRPCRequest,
-    ServerRequest,
-    TextContent,
-    ListRootsRequest,
     ListRootsResult,
     Root,
 )
+from pydantic import AnyUrl
 
 from mcp_agent.config import MCPServerSettings
 from mcp_agent.context_dependent import ContextDependent
@@ -36,6 +28,24 @@ from mcp_agent.logging.logger import get_logger
 logger = get_logger(__name__)
 
 
+async def list_roots(ctx: ClientSession) -> ListRootsResult:
+    """List roots callback that will be called by the MCP library."""
+
+    roots = []
+    if (
+        hasattr(ctx, "session")
+        and hasattr(ctx.session, "server_config")
+        and ctx.session.server_config
+        and hasattr(ctx.session.server_config, "roots")
+        and ctx.session.server_config.roots
+    ):
+        roots = [
+            Root(uri=AnyUrl(root.uri), name=root.name)
+            for root in ctx.session.server_config.roots
+        ]
+    return ListRootsResult(roots=roots or [])
+
+
 class MCPAgentClientSession(ClientSession, ContextDependent):
     """
     MCP Agent framework acts as a client to the servers providing tools/resources/prompts for the agent workloads.
@@ -48,36 +58,9 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
     """
 
     def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs, list_roots_callback=list_roots)
         self.server_config: Optional[MCPServerSettings] = None
 
-    async def _received_request(
-        self, responder: RequestResponder[ServerRequest, ClientResult]
-    ) -> None:
-        logger.debug("Received request:", data=responder.request.model_dump())
-        request = responder.request.root
-
-        if isinstance(request, CreateMessageRequest):
-            return await self.handle_sampling_request(request, responder)
-        elif isinstance(request, ListRootsRequest):
-            # Handle list_roots request by returning configured roots
-            if hasattr(self, "server_config") and self.server_config.roots:
-                roots = [
-                    Root(
-                        uri=root.server_uri_alias or root.uri,
-                        name=root.name,
-                    )
-                    for root in self.server_config.roots
-                ]
-
-                await responder.respond(ListRootsResult(roots=roots))
-            else:
-                await responder.respond(ListRootsResult(roots=[]))
-            return
-
-        # Handle other requests as usual
-        await super()._received_request(responder)
-
     async def send_request(
         self,
         request: SendRequestT,
@@ -89,7 +72,7 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
             logger.debug("send_request: response=", data=result.model_dump())
             return result
         except Exception as e:
-            logger.error(f"send_request failed: {e}")
+            logger.error(f"send_request failed: {str(e)}")
             raise
 
     async def send_notification(self, notification: SendNotificationT) -> None:
@@ -133,110 +116,3 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
         return await super().send_progress_notification(
             progress_token=progress_token, progress=progress, total=total
         )
-
-    async def _receive_loop(self) -> None:
-        async with (
-            self._read_stream,
-            self._write_stream,
-            self._incoming_message_stream_writer,
-        ):
-            async for message in self._read_stream:
-                if isinstance(message, Exception):
-                    await self._incoming_message_stream_writer.send(message)
-                elif isinstance(message.root, JSONRPCRequest):
-                    validated_request = self._receive_request_type.model_validate(
-                        message.root.model_dump(
-                            by_alias=True, mode="json", exclude_none=True
-                        )
-                    )
-                    responder = RequestResponder(
-                        request_id=message.root.id,
-                        request_meta=validated_request.root.params.meta
-                        if validated_request.root.params
-                        else None,
-                        request=validated_request,
-                        session=self,
-                    )
-
-                    await self._received_request(responder)
-                    if not responder._responded:
-                        await self._incoming_message_stream_writer.send(responder)
-                elif isinstance(message.root, JSONRPCNotification):
-                    notification = self._receive_notification_type.model_validate(
-                        message.root.model_dump(
-                            by_alias=True, mode="json", exclude_none=True
-                        )
-                    )
-
-                    await self._received_notification(notification)
-                    await self._incoming_message_stream_writer.send(notification)
-                else:  # Response or error
-                    stream = self._response_streams.pop(message.root.id, None)
-                    if stream:
-                        await stream.send(message.root)
-                    else:
-                        await self._incoming_message_stream_writer.send(
-                            RuntimeError(
-                                "Received response with an unknown "
-                                f"request ID: {message}"
-                            )
-                        )
-
-    async def handle_sampling_request(
-        self,
-        request: CreateMessageRequest,
-        responder: RequestResponder[ServerRequest, ClientResult],
-    ):
-        logger.info("Handling sampling request: %s", request)
-        config = self.context.config
-        session = self.context.upstream_session
-        if session is None:
-            # TODO: saqadri - consider whether we should be handling the sampling request here as a client
-            logger.warning(
-                "Error: No upstream client available for sampling requests. Request:",
-                data=request,
-            )
-            try:
-                from anthropic import AsyncAnthropic
-
-                client = AsyncAnthropic(api_key=config.anthropic.api_key)
-
-                params = request.params
-                response = await client.messages.create(
-                    model="claude-3-sonnet-20240229",
-                    max_tokens=params.maxTokens,
-                    messages=[
-                        {
-                            "role": m.role,
-                            "content": m.content.text
-                            if hasattr(m.content, "text")
-                            else m.content.data,
-                        }
-                        for m in params.messages
-                    ],
-                    system=getattr(params, "systemPrompt", None),
-                    temperature=getattr(params, "temperature", 0.7),
-                    stop_sequences=getattr(params, "stopSequences", None),
-                )
-
-                await responder.respond(
-                    CreateMessageResult(
-                        model="claude-3-sonnet-20240229",
-                        role="assistant",
-                        content=TextContent(type="text", text=response.content[0].text),
-                    )
-                )
-            except Exception as e:
-                logger.error(f"Error handling sampling request: {e}")
-                await responder.respond(ErrorData(code=-32603, message=str(e)))
-        else:
-            try:
-                # If a session is available, we'll pass-through the sampling request to the upstream client
-                result = await session.send_request(
-                    request=ServerRequest(request), result_type=CreateMessageResult
-                )
-
-                # Pass the result from the upstream client back to the server. We just act as a pass-through client here.
-                await responder.send_result(result)
-            except Exception as e:
-                await responder.send_error(code=-32603, message=str(e))

mcp_agent/mcp/mcp_aggregator.py

@@ -8,8 +8,8 @@ from typing import (
     Callable,
     TypeVar,
 )
-from mcp import GetPromptResult
-from pydantic import BaseModel, ConfigDict
+from mcp import GetPromptResult, ReadResourceResult
+from pydantic import AnyUrl, BaseModel, ConfigDict
 from mcp.client.session import ClientSession
 from mcp.server.lowlevel.server import Server
 from mcp.server.stdio import stdio_server
@@ -210,6 +210,7 @@ class MCPAggregator(ContextDependent):
                         "agent_name": self.agent_name,
                     },
                 )
+
                 await self._persistent_connection_manager.get_server(
                     server_name, client_session_factory=MCPAgentClientSession
                 )
@@ -821,6 +822,53 @@ class MCPAggregator(ContextDependent):
         logger.debug(f"Available prompts across servers: {results}")
         return results
 
+    async def get_resource(
+        self, server_name: str, resource_uri: str
+    ) -> ReadResourceResult:
+        """
+        Get a resource directly from an MCP server by URI.
+
+        Args:
+            server_name: Name of the MCP server to retrieve the resource from
+            resource_uri: URI of the resource to retrieve
+
+        Returns:
+            ReadResourceResult object containing the resource content
+
+        Raises:
+            ValueError: If the server doesn't exist or the resource couldn't be found
+        """
+        if not self.initialized:
+            await self.load_servers()
+
+        if server_name not in self.server_names:
+            raise ValueError(f"Server '{server_name}' not found")
+
+        logger.info(
+            "Requesting resource",
+            data={
+                "progress_action": ProgressAction.CALLING_TOOL,
+                "resource_uri": resource_uri,
+                "server_name": server_name,
+                "agent_name": self.agent_name,
+            },
+        )
+
+        try:
+            uri = AnyUrl(resource_uri)
+        except Exception as e:
+            raise ValueError(f"Invalid resource URI: {resource_uri}. Error: {e}")
+
+        # Use the _execute_on_server method to call read_resource on the server
+        return await self._execute_on_server(
+            server_name=server_name,
+            operation_type="resource",
+            operation_name=resource_uri,
+            method_name="read_resource",
+            method_args={"uri": uri},
+            error_factory=lambda msg: ValueError(f"Failed to retrieve resource: {msg}"),
+        )
+
 
 class MCPCompoundServer(Server):
     """

mcp_agent/mcp/mcp_connection_manager.py

@@ -163,7 +163,6 @@ async def _server_lifecycle_task(server_conn: ServerConnection) -> None:
         async with transport_context as (read_stream, write_stream):
             #      try:
             server_conn.create_session(read_stream, write_stream)
-            #       except FileNotFoundError as e:
 
             async with server_conn.session:
                 await server_conn.initialize_session()

mcp_agent/mcp/prompts/prompt_server.py

@@ -12,6 +12,8 @@ import logging
 import sys
 from pathlib import Path
 from typing import List, Dict, Optional, Callable, Awaitable, Literal, Any
+from mcp.server.fastmcp.resources import FileResource
+from pydantic import AnyUrl
 
 from mcp_agent.mcp import mime_utils, resource_utils
 
@@ -185,19 +187,19 @@ def create_prompt_handler(
 
 
 # Type for resource handler
-ResourceHandler = Callable[[], Awaitable[str]]
+ResourceHandler = Callable[[], Awaitable[str | bytes]]
 
 
 def create_resource_handler(resource_path: Path, mime_type: str) -> ResourceHandler:
     """Create a resource handler function for the given resource"""
 
-    async def get_resource() -> str:
+    async def get_resource() -> str | bytes:
         is_binary = mime_utils.is_binary_content(mime_type)
 
         if is_binary:
             # For binary files, read in binary mode and base64 encode
             with open(resource_path, "rb") as f:
-                return base64.b64encode(f.read()).decode("utf-8")
+                return f.read()
         else:
             # For text files, read as utf-8 text
             with open(resource_path, "r", encoding="utf-8") as f:
@@ -284,15 +286,14 @@ def register_prompt(file_path: Path):
                         exposed_resources[resource_id] = resource_file
                         mime_type = mime_utils.guess_mime_type(str(resource_file))
 
-                        # Register with the correct resource ID directly with MCP
-                        resource_handler = create_resource_handler(
-                            resource_file, mime_type
+                        mcp.add_resource(
+                            FileResource(
+                                uri=AnyUrl(resource_id),
+                                path=resource_file,
+                                mime_type=mime_type,
+                                is_binary=mime_utils.is_binary_content(mime_type),
+                            )
                         )
-                        mcp.resource(
-                            resource_id,
-                            description=f"Resource from {file_path.name}",
-                            mime_type=mime_type,
-                        )(resource_handler)
 
                         logger.info(
                             f"Registered resource: {resource_id} ({resource_file})"

mcp_agent/mcp/resource_utils.py

@@ -25,44 +25,6 @@ def find_resource_file(resource_path: str, prompt_files: List[Path]) -> Optional
     return None
 
 
-# TODO -- decide how to deal with this. Both Anthropic and OpenAI allow sending URLs in
-# input message
-# TODO -- used?
-# async def fetch_remote_resource(
-#     url: str, timeout: int = HTTP_TIMEOUT
-# ) -> ResourceContent:
-#     """
-#     Fetch a remote resource from a URL
-
-#     Returns:
-#         Tuple of (content, mime_type, is_binary)
-#         - content: Text content or base64-encoded binary content
-#         - mime_type: The MIME type of the resource
-#         - is_binary: Whether the content is binary (and base64-encoded)
-#     """
-
-#     async with httpx.AsyncClient(timeout=timeout) as client:
-#         response = await client.get(url)
-#         response.raise_for_status()
-
-#         # Get the content type or guess from URL
-#         mime_type = response.headers.get("content-type", "").split(";")[0]
-#         if not mime_type:
-#             mime_type = mime_utils.guess_mime_type(url)
-
-#         # Check if this is binary content
-#         is_binary = mime_utils.is_binary_content(mime_type)
-
-#         if is_binary:
-#             # For binary responses, get the binary content and base64 encode it
-#             content = base64.b64encode(response.content).decode("utf-8")
-#         else:
-#             # For text responses, just get the text
-#             content = response.text
-
-#         return content, mime_type, is_binary
-
-
 def load_resource_content(
     resource_path: str, prompt_files: List[Path]
 ) -> ResourceContent:
@@ -109,6 +71,36 @@ def create_resource_uri(path: str) -> str:
     return f"resource://fast-agent/{Path(path).name}"
 
 
+# Add this to your resource_utils.py module
+
+
+def create_resource_reference(uri: str, mime_type: str) -> "EmbeddedResource":
+    """
+    Create a reference to a resource without embedding its content directly.
+
+    This creates an EmbeddedResource that references another resource URI.
+    When the client receives this, it will make a separate request to fetch
+    the resource content using the provided URI.
+
+    Args:
+        uri: URI for the resource
+        mime_type: MIME type of the resource
+
+    Returns:
+        An EmbeddedResource object
+    """
+    from mcp.types import EmbeddedResource, TextResourceContents
+
+    # Create a resource reference
+    resource_contents = TextResourceContents(
+        uri=uri,
+        mimeType=mime_type,
+        text="",  # Empty text as we're just referencing
+    )
+
+    return EmbeddedResource(type="resource", resource=resource_contents)
+
+
 def create_embedded_resource(
     resource_path: str, content: str, mime_type: str, is_binary: bool = False
 ) -> EmbeddedResource:
@@ -149,6 +141,34 @@ def create_image_content(data: str, mime_type: str) -> ImageContent:
     )
 
 
+def create_blob_resource(
+    resource_path: str, content: str, mime_type: str
+) -> EmbeddedResource:
+    """Create an embedded resource for binary data"""
+    return EmbeddedResource(
+        type="resource",
+        resource=BlobResourceContents(
+            uri=resource_path,
+            mimeType=mime_type,
+            blob=content,  # Content should already be base64 encoded
+        ),
+    )
+
+
+def create_text_resource(
+    resource_path: str, content: str, mime_type: str
+) -> EmbeddedResource:
+    """Create an embedded resource for text data"""
+    return EmbeddedResource(
+        type="resource",
+        resource=TextResourceContents(
+            uri=resource_path,
+            mimeType=mime_type,
+            text=content,
+        ),
+    )
+
+
 def normalize_uri(uri_or_filename: str) -> str:
     """
     Normalize a URI or filename to ensure it's a valid URI.

mcp_agent/mcp/stdio.py

@@ -9,10 +9,12 @@ from anyio.streams.text import TextReceiveStream
 from mcp.client.stdio import StdioServerParameters, get_default_environment
 import mcp.types as types
 from mcp_agent.logging.logger import get_logger
+from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
 
 logger = get_logger(__name__)
 
 
+# TODO this will be removed when client library 1.4.2 is released
 @asynccontextmanager
 async def stdio_client_with_rich_stderr(server: StdioServerParameters):
     """
@@ -22,10 +24,16 @@ async def stdio_client_with_rich_stderr(server: StdioServerParameters):
     Args:
         server: The server parameters for the stdio connection
     """
+    read_stream: MemoryObjectReceiveStream[types.JSONRPCMessage | Exception]
+    read_stream_writer: MemoryObjectSendStream[types.JSONRPCMessage | Exception]
+
+    write_stream: MemoryObjectSendStream[types.JSONRPCMessage]
+    write_stream_reader: MemoryObjectReceiveStream[types.JSONRPCMessage]
+
     read_stream_writer, read_stream = anyio.create_memory_object_stream(0)
     write_stream, write_stream_reader = anyio.create_memory_object_stream(0)
-
     # Open process with stderr piped for capture
+
     process = await anyio.open_process(
         [server.command, *server.args],
         env=server.env if server.env is not None else get_default_environment(),
@@ -67,19 +75,19 @@ async def stdio_client_with_rich_stderr(server: StdioServerParameters):
         except anyio.ClosedResourceError:
             await anyio.lowlevel.checkpoint()
 
-    async def stderr_reader():
-        assert process.stderr, "Opened process is missing stderr"
-        try:
-            async for chunk in TextReceiveStream(
-                process.stderr,
-                encoding=server.encoding,
-                errors=server.encoding_error_handler,
-            ):
-                if chunk.strip():
-                    # Let the logging system handle the formatting consistently
-                    logger.event("info", "mcpserver.stderr", chunk.rstrip(), None, {})
-        except anyio.ClosedResourceError:
-            await anyio.lowlevel.checkpoint()
+    # async def stderr_reader():
+    #     assert process.stderr, "Opened process is missing stderr"
+    #     try:
+    #         async for chunk in TextReceiveStream(
+    #             process.stderr,
+    #             encoding=server.encoding,
+    #             errors=server.encoding_error_handler,
+    #         ):
+    #             if chunk.strip():
+    #                 # Let the logging system handle the formatting consistently
+    #                 logger.event("info", "mcpserver.stderr", chunk.rstrip(), None, {})
+    #     except anyio.ClosedResourceError:
+    #         await anyio.lowlevel.checkpoint()
 
     async def stdin_writer():
         assert process.stdin, "Opened process is missing stdin"
@@ -87,6 +95,7 @@ async def stdio_client_with_rich_stderr(server: StdioServerParameters):
             async with write_stream_reader:
                 async for message in write_stream_reader:
                     json = message.model_dump_json(by_alias=True, exclude_none=True)
+                    print(f"**********{id(process.stdin)}")
                     await process.stdin.send(
                         (json + "\n").encode(
                             encoding=server.encoding,
@@ -100,5 +109,4 @@ async def stdio_client_with_rich_stderr(server: StdioServerParameters):
     async with anyio.create_task_group() as tg, process:
         tg.start_soon(stdout_reader)
         tg.start_soon(stdin_writer)
-        tg.start_soon(stderr_reader)
         yield read_stream, write_stream

mcp_agent/mcp_server_registry.py

@@ -15,9 +15,9 @@ from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStre
 from mcp import ClientSession
 from mcp.client.stdio import (
     StdioServerParameters,
-    stdio_client,
     get_default_environment,
 )
+from mcp_agent.mcp.stdio import stdio_client_with_rich_stderr
 from mcp.client.sse import sse_client
 
 from mcp_agent.config import (
@@ -134,7 +134,10 @@ class ServerRegistry:
                 env={**get_default_environment(), **(config.env or {})},
             )
 
-            async with stdio_client(server_params) as (read_stream, write_stream):
+            async with stdio_client_with_rich_stderr(server_params) as (
+                read_stream,
+                write_stream,
+            ):
                 session = client_session_factory(
                     read_stream,
                     write_stream,

mcp_agent/resources/examples/workflows/orchestrator.py

@@ -50,9 +50,9 @@ fast = FastAgent("Orchestrator-Workers")
 async def main():
     async with fast.run() as agent:
         await agent()
-#        await agent.author(
-#            "write a 250 word short story about kittens discovering a castle, and save it to short_story.md"
-#        )
+        await agent.author(
+            "write a 250 word short story about kittens discovering a castle, and save it to short_story.md"
+        )
 
         # The orchestrator can be used just like any other agent
         task = (

mcp_agent/workflows/llm/augmented_llm_passthrough.py

@@ -1,5 +1,5 @@
 from typing import Any, List, Optional, Type, Union
-
+import json
 from mcp import GetPromptResult
 from mcp.types import PromptMessage
 from pydantic_core import from_json
@@ -45,11 +45,63 @@ class PassthroughLLM(AugmentedLLM):
         request_params: Optional[RequestParams] = None,
     ) -> str:
         """Return the input message as a string."""
+        # Check if this is a special command to call a tool
+        if isinstance(message, str) and message.startswith("***CALL_TOOL "):
+            return await self._call_tool_and_return_result(message)
+
         self.show_user_message(message, model="fastagent-passthrough", chat_turn=0)
         await self.show_assistant_message(message, title="ASSISTANT/PASSTHROUGH")
 
         return str(message)
 
+    async def _call_tool_and_return_result(self, command: str) -> str:
+        """
+        Call a tool based on the command and return its result as a string.
+
+        Args:
+            command: The command string, expected format: "***CALL_TOOL <server>-<tool_name> [arguments_json]"
+
+        Returns:
+            Tool result as a string
+        """
+        try:
+            # Parse the tool name and optional arguments
+            parts = command.split(" ", 2)
+            if len(parts) < 2:
+                return "Error: Invalid format. Expected '***CALL_TOOL <tool_name> [arguments_json]'"
+
+            tool_name = parts[1].strip()
+            arguments = None
+
+            # Parse optional JSON arguments if provided
+            if len(parts) > 2:
+                try:
+                    arguments = json.loads(parts[2])
+                except json.JSONDecodeError:
+                    return f"Error: Invalid JSON arguments: {parts[2]}"
+
+            # Call the tool and get the result
+            self.logger.info(f"Calling tool {tool_name} with arguments {arguments}")
+            result = await self.aggregator.call_tool(tool_name, arguments)
+
+            # Format the result as a string
+            if result.isError:
+                return f"Error calling tool '{tool_name}': {result.message}"
+
+            # Extract text content from result
+            result_text = []
+            for content_item in result.content:
+                if hasattr(content_item, "text"):
+                    result_text.append(content_item.text)
+                else:
+                    result_text.append(str(content_item))
+
+            return "\n".join(result_text)
+
+        except Exception as e:
+            self.logger.error(f"Error calling tool: {str(e)}")
+            return f"Error calling tool: {str(e)}"
+
     async def generate_structured(
         self,
         message: Union[str, MessageParamT, List[MessageParamT]],
@@ -71,7 +123,10 @@ class PassthroughLLM(AugmentedLLM):
     async def generate_prompt(
         self, prompt: "PromptMessageMultipart", request_params: RequestParams | None
     ) -> str:
-        return await self.generate_str(prompt.content[0].text, request_params)
+        message = prompt.content[0].text if prompt.content else ""
+        if isinstance(message, str) and message.startswith("***CALL_TOOL "):
+            return await self._call_tool_and_return_result(message)
+        return await self.generate_str(message, request_params)
 
     async def apply_prompt_template(
         self, prompt_result: GetPromptResult, prompt_name: str