fast-agent-mcp 0.2.23__py3-none-any.whl → 0.2.24__py3-none-any.whl

{fast_agent_mcp-0.2.23.dist-info → fast_agent_mcp-0.2.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.23
+Version: 0.2.24
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>
 License:                                  Apache License
@@ -218,6 +218,7 @@ Requires-Dist: openai>=1.63.2
 Requires-Dist: opentelemetry-distro>=0.50b0
 Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.29.0
 Requires-Dist: opentelemetry-instrumentation-anthropic>=0.39.3
+Requires-Dist: opentelemetry-instrumentation-mcp>=0.40.3
 Requires-Dist: opentelemetry-instrumentation-openai>=0.39.3
 Requires-Dist: prompt-toolkit>=3.0.50
 Requires-Dist: pydantic-settings>=2.7.0

{fast_agent_mcp-0.2.23.dist-info → fast_agent_mcp-0.2.24.dist-info}/RECORD

@@ -2,7 +2,7 @@ mcp_agent/__init__.py,sha256=18T0AG0W9sJhTY38O9GFFOzliDhxx9p87CvRyti9zbw,1620
 mcp_agent/app.py,sha256=WRsiUdwy_9IAnaGRDwuLm7pzgQpt2wgsg10vBOpfcwM,5539
 mcp_agent/config.py,sha256=L_wUWTdqFXaRTBA5tL_j2l_9dufWE_MHHPut5e89lBk,12773
 mcp_agent/console.py,sha256=Gjf2QLFumwG1Lav__c07X_kZxxEUSkzV-1_-YbAwcwo,813
-mcp_agent/context.py,sha256=Kb3s_0MolHx7AeTs1NVcY3ly-xFBd35o8LT7Srpx9is,7334
+mcp_agent/context.py,sha256=5pnw78LgezCLeO5Os5dgmLDadwXqw_B4Ojib48XP1s4,7431
 mcp_agent/context_dependent.py,sha256=QXfhw3RaQCKfscEEBRGuZ3sdMWqkgShz2jJ1ivGGX1I,1455
 mcp_agent/event_progress.py,sha256=b1VKlQQF2AgPMb6XHjlJAVoPdx8GuxRTUk2g-4lBNm0,2749
 mcp_agent/mcp_server_registry.py,sha256=QTzu0elBWzqXks6u5nI5n8uN5CX8CpyV6ybxnyt5LZM,11531
@@ -65,7 +65,7 @@ mcp_agent/llm/providers/augmented_llm_anthropic.py,sha256=gK_IvllVBNJUUrSfpgFpdh
 mcp_agent/llm/providers/augmented_llm_deepseek.py,sha256=NiZK5nv91ZS2VgVFXpbsFNFYLsLcppcbo_RstlRMd7I,1145
 mcp_agent/llm/providers/augmented_llm_generic.py,sha256=5Uq8ZBhcFuQTt7koP_5ykolREh2iWu8zKhNbh3pM9lQ,1210
 mcp_agent/llm/providers/augmented_llm_google.py,sha256=N0a2fphVtkvNYxKQpEX6J4tlO1C_mRw4sw3LBXnrOeI,1130
-mcp_agent/llm/providers/augmented_llm_openai.py,sha256=0C7BOB7i3xo0HsMCTagRSQ8Hsywb-31mot26OfohzCU,14478
+mcp_agent/llm/providers/augmented_llm_openai.py,sha256=jbLG9t0iuneRPX0Cscim6K48SJEB5vPopDE3IBmJ708,14515
 mcp_agent/llm/providers/augmented_llm_openrouter.py,sha256=V_TlVKm92GHBxYIo6gpvH_6cAaIdppS25Tz6x5T7LW0,2341
 mcp_agent/llm/providers/augmented_llm_tensorzero.py,sha256=Mol_Wzj_ZtccW-LMw0oFwWUt1m1yfofloay9QYNP23c,20729
 mcp_agent/llm/providers/multipart_converter_anthropic.py,sha256=t5lHYGfFUacJldnrVtMNW-8gEMoto8Y7hJkDrnyZR-Y,16650
@@ -86,8 +86,8 @@ mcp_agent/mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/mcp/gen_client.py,sha256=fAVwFVCgSamw4PwoWOV4wrK9TABx1S_zZv8BctRyF2k,3030
 mcp_agent/mcp/interfaces.py,sha256=PAou8znAl2HgtvfCpLQOZFbKra9F72OcVRfBJbboNX8,6965
 mcp_agent/mcp/logger_textio.py,sha256=vljC1BtNTCxBAda9ExqNB-FwVNUZIuJT3h1nWmCjMws,3172
-mcp_agent/mcp/mcp_agent_client_session.py,sha256=Ng7epBXq8BEA_3m1GX5LqwafgNUAMSzBugwN6N0VUWQ,4364
-mcp_agent/mcp/mcp_aggregator.py,sha256=lVSt0yp0CnaYjcHCWmluwBeFgl8JXHYEZk0MzXgrQzA,40110
+mcp_agent/mcp/mcp_agent_client_session.py,sha256=4597ww1ihSKh-zKc9xMF3ODqosVPU_A4xVmUbk1DvcE,6002
+mcp_agent/mcp/mcp_aggregator.py,sha256=_zqSuWGwRTLleXldQjqPSNqV0RRRr1luJIZOvB2AdRg,46011
 mcp_agent/mcp/mcp_connection_manager.py,sha256=jlqaAdS4zc1UfVBHQU0TkTbVr0-rOkbN9bkrLPrZVLk,17159
 mcp_agent/mcp/mime_utils.py,sha256=difepNR_gpb4MpMLkBRAoyhDk-AjXUHTiqKvT_VwS1o,1805
 mcp_agent/mcp/prompt_message_multipart.py,sha256=BDwRdNwyWHb2q2bccDb2iR2VlORqVvkvoG3xYzcMpCE,4403
@@ -146,8 +146,8 @@ mcp_agent/resources/examples/workflows/parallel.py,sha256=DQ5vY5-h8Qa5QHcYjsWXhZ
 mcp_agent/resources/examples/workflows/router.py,sha256=E4x_-c3l4YW9w1i4ARcDtkdeqIdbWEGfsMzwLYpdbVc,1677
 mcp_agent/resources/examples/workflows/short_story.txt,sha256=X3y_1AyhLFN2AKzCKvucJtDgAFIJfnlbsbGZO5bBWu0,1187
 mcp_agent/ui/console_display.py,sha256=EUeMJ7yqtxJ0-hAjXNZFJFTlmfyKlENdfzTlw0e5ETg,9949
-fast_agent_mcp-0.2.23.dist-info/METADATA,sha256=Vtk96ocWT3Xk_Y8f3ZLUILhh2aybr8OebCPn5jZeZOY,30156
-fast_agent_mcp-0.2.23.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fast_agent_mcp-0.2.23.dist-info/entry_points.txt,sha256=bRniFM5zk3Kix5z7scX0gf9VnmGQ2Cz_Q1Gh7Ir4W00,186
-fast_agent_mcp-0.2.23.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
-fast_agent_mcp-0.2.23.dist-info/RECORD,,
+fast_agent_mcp-0.2.24.dist-info/METADATA,sha256=BxBQ5fsAWpeZ2UhH_zChQb816cZp6_ipY05ea60lKJA,30213
+fast_agent_mcp-0.2.24.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fast_agent_mcp-0.2.24.dist-info/entry_points.txt,sha256=bRniFM5zk3Kix5z7scX0gf9VnmGQ2Cz_Q1Gh7Ir4W00,186
+fast_agent_mcp-0.2.24.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
+fast_agent_mcp-0.2.24.dist-info/RECORD,,

mcp_agent/context.py

@@ -11,6 +11,7 @@ from mcp import ServerSession
 from opentelemetry import trace
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
 from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
+from opentelemetry.instrumentation.mcp import McpInstrumentor
 from opentelemetry.instrumentation.openai import OpenAIInstrumentor
 from opentelemetry.propagate import set_global_textmap
 from opentelemetry.sdk.resources import Resource
@@ -111,6 +112,7 @@ async def configure_otel(config: "Settings") -> None:
     trace.set_tracer_provider(tracer_provider)
     AnthropicInstrumentor().instrument()
     OpenAIInstrumentor().instrument()
+    McpInstrumentor().instrument()
 
 
 async def configure_logger(config: "Settings") -> None:

mcp_agent/llm/providers/augmented_llm_openai.py

@@ -274,7 +274,9 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
             # Calculate new conversation messages (excluding prompts)
             new_messages = messages[len(prompt_messages) :]
 
-            # Update conversation history
+            if system_prompt:
+                new_messages = new_messages[1:]
+
             self.history.set(new_messages)
 
         self._log_chat_finished(model=self.default_request_params.model)

mcp_agent/mcp/mcp_agent_client_session.py

@@ -6,21 +6,16 @@ It adds logging and supports sampling requests.
 from datetime import timedelta
 from typing import TYPE_CHECKING, Optional
 
-from mcp import ClientSession
+from mcp import ClientSession, ServerNotification
 from mcp.shared.session import (
-    ReceiveNotificationT,
     ReceiveResultT,
     RequestId,
     SendNotificationT,
     SendRequestT,
     SendResultT,
 )
-from mcp.types import (
-    ErrorData,
-    ListRootsResult,
-    Root,
-)
-from pydantic import AnyUrl
+from mcp.types import ErrorData, ListRootsResult, Root, ToolListChangedNotification
+from pydantic import FileUrl
 
 from mcp_agent.context_dependent import ContextDependent
 from mcp_agent.logging.logger import get_logger
@@ -45,7 +40,7 @@ async def list_roots(ctx: ClientSession) -> ListRootsResult:
     ):
         roots = [
             Root(
-                uri=AnyUrl(
+                uri=FileUrl(
                     root.server_uri_alias or root.uri,
                 ),
                 name=root.name,
@@ -67,6 +62,11 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
     """
 
     def __init__(self, *args, **kwargs) -> None:
+        # Extract server_name if provided in kwargs
+        self.session_server_name = kwargs.pop("server_name", None)
+        # Extract the notification callbacks if provided
+        self._tool_list_changed_callback = kwargs.pop("tool_list_changed_callback", None)
+
         super().__init__(*args, **kwargs, list_roots_callback=list_roots, sampling_callback=sample)
         self.server_config: Optional[MCPServerSettings] = None
 
@@ -104,7 +104,7 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
         )
         return await super()._send_response(request_id, response)
 
-    async def _received_notification(self, notification: ReceiveNotificationT) -> None:
+    async def _received_notification(self, notification: ServerNotification) -> None:
         """
         Can be overridden by subclasses to handle a notification without needing
         to listen on the message stream.
@@ -113,7 +113,37 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
             "_received_notification: notification=",
             data=notification.model_dump(),
         )
-        return await super()._received_notification(notification)
+
+        # Call parent notification handler first
+        await super()._received_notification(notification)
+
+        # Then process our specific notification types
+        match notification.root:
+            case ToolListChangedNotification():
+                # Simple notification handling - just call the callback if it exists
+                if self._tool_list_changed_callback and self.session_server_name:
+                    logger.info(
+                        f"Tool list changed for server '{self.session_server_name}', triggering callback"
+                    )
+                    # Use asyncio.create_task to prevent blocking the notification handler
+                    import asyncio
+                    asyncio.create_task(self._handle_tool_list_change_callback(self.session_server_name))
+                else:
+                    logger.debug(
+                        f"Tool list changed for server '{self.session_server_name}' but no callback registered"
+                    )
+
+        return None
+
+    async def _handle_tool_list_change_callback(self, server_name: str) -> None:
+        """
+        Helper method to handle tool list change callback in a separate task
+        to prevent blocking the notification handler
+        """
+        try:
+            await self._tool_list_changed_callback(server_name)
+        except Exception as e:
+            logger.error(f"Error in tool list changed callback: {e}")
 
     async def send_progress_notification(
         self, progress_token: str | int, progress: float, total: float | None = None

mcp_agent/mcp/mcp_aggregator.py

@@ -138,6 +138,9 @@ class MCPAggregator(ContextDependent):
         self._prompt_cache: Dict[str, List[Prompt]] = {}
         self._prompt_cache_lock = Lock()
 
+        # Lock for refreshing tools from a server
+        self._refresh_lock = Lock()
+
     async def close(self) -> None:
         """
         Close all persistent connections when the aggregator is deleted.
@@ -217,8 +220,19 @@ class MCPAggregator(ContextDependent):
                     },
                 )
 
+                # Create a wrapper to capture the parameters for the client session
+                def session_factory(read_stream, write_stream, read_timeout):
+                    return MCPAgentClientSession(
+                        read_stream,
+                        write_stream,
+                        read_timeout,
+                        server_name=server_name,
+                        tool_list_changed_callback=self._handle_tool_list_changed
+                    )
+
                 await self._persistent_connection_manager.get_server(
-                    server_name, client_session_factory=MCPAgentClientSession
+                    server_name,
+                    client_session_factory=session_factory
                 )
 
             logger.info(
@@ -261,8 +275,20 @@ class MCPAggregator(ContextDependent):
                 tools = await fetch_tools(server_connection.session)
                 prompts = await fetch_prompts(server_connection.session, server_name)
             else:
+                # Create a factory function for the client session
+                def create_session(read_stream, write_stream, read_timeout):
+                    return MCPAgentClientSession(
+                        read_stream,
+                        write_stream,
+                        read_timeout,
+                        server_name=server_name,
+                        tool_list_changed_callback=self._handle_tool_list_changed
+                    )
+
                 async with gen_client(
-                    server_name, server_registry=self.context.server_registry
+                    server_name,
+                    server_registry=self.context.server_registry,
+                    client_session_factory=create_session
                 ) as client:
                     tools = await fetch_tools(client)
                     prompts = await fetch_prompts(client, server_name)
@@ -384,6 +410,15 @@ class MCPAggregator(ContextDependent):
             ]
         )
 
+    async def refresh_all_tools(self) -> None:
+        """
+        Refresh the tools for all servers.
+        This is useful when you know tools have changed but haven't received notifications.
+        """
+        logger.info("Refreshing tools for all servers")
+        for server_name in self.server_names:
+            await self._refresh_server_tools(server_name)
+
     async def _execute_on_server(
         self,
         server_name: str,
@@ -864,6 +899,102 @@ class MCPAggregator(ContextDependent):
         logger.debug(f"Available prompts across servers: {results}")
         return results
 
+    async def _handle_tool_list_changed(self, server_name: str) -> None:
+        """
+        Callback handler for ToolListChangedNotification.
+        This will refresh the tools for the specified server.
+
+        Args:
+            server_name: The name of the server whose tools have changed
+        """
+        logger.info(f"Tool list changed for server '{server_name}', refreshing tools")
+
+        # Refresh the tools for this server
+        await self._refresh_server_tools(server_name)
+
+    async def _refresh_server_tools(self, server_name: str) -> None:
+        """
+        Refresh the tools for a specific server.
+
+        Args:
+            server_name: The name of the server to refresh tools for
+        """
+        if not await self.validate_server(server_name):
+            logger.error(f"Cannot refresh tools for unknown server '{server_name}'")
+            return
+
+        async with self._refresh_lock:
+            try:
+                # Fetch new tools from the server
+                if self.connection_persistence:
+                    # Create a factory function that will include our parameters
+                    def create_session(read_stream, write_stream, read_timeout):
+                        return MCPAgentClientSession(
+                            read_stream,
+                            write_stream,
+                            read_timeout,
+                            server_name=server_name,
+                            tool_list_changed_callback=self._handle_tool_list_changed
+                        )
+
+                    server_connection = await self._persistent_connection_manager.get_server(
+                        server_name,
+                        client_session_factory=create_session
+                    )
+                    tools_result = await server_connection.session.list_tools()
+                    new_tools = tools_result.tools or []
+                else:
+                    # Create a factory function for the client session
+                    def create_session(read_stream, write_stream, read_timeout):
+                        return MCPAgentClientSession(
+                            read_stream,
+                            write_stream,
+                            read_timeout,
+                            server_name=server_name,
+                            tool_list_changed_callback=self._handle_tool_list_changed
+                        )
+
+                    async with gen_client(
+                        server_name,
+                        server_registry=self.context.server_registry,
+                        client_session_factory=create_session
+                    ) as client:
+                        tools_result = await client.list_tools()
+                        new_tools = tools_result.tools or []
+
+                # Update tool maps
+                async with self._tool_map_lock:
+                    # Remove old tools for this server
+                    old_tools = self._server_to_tool_map.get(server_name, [])
+                    for old_tool in old_tools:
+                        if old_tool.namespaced_tool_name in self._namespaced_tool_map:
+                            del self._namespaced_tool_map[old_tool.namespaced_tool_name]
+
+                    # Add new tools
+                    self._server_to_tool_map[server_name] = []
+                    for tool in new_tools:
+                        namespaced_tool_name = create_namespaced_name(server_name, tool.name)
+                        namespaced_tool = NamespacedTool(
+                            tool=tool,
+                            server_name=server_name,
+                            namespaced_tool_name=namespaced_tool_name,
+                        )
+
+                        self._namespaced_tool_map[namespaced_tool_name] = namespaced_tool
+                        self._server_to_tool_map[server_name].append(namespaced_tool)
+
+                logger.info(
+                    f"Successfully refreshed tools for server '{server_name}'",
+                    data={
+                        "progress_action": ProgressAction.UPDATED,
+                        "server_name": server_name,
+                        "agent_name": self.agent_name,
+                        "tool_count": len(new_tools),
+                    },
+                )
+            except Exception as e:
+                logger.error(f"Failed to refresh tools for server '{server_name}': {e}")
+
     async def get_resource(
         self, resource_uri: str, server_name: str | None = None
     ) -> ReadResourceResult: