fast-agent-mcp 0.2.23__tar.gz → 0.2.24__tar.gz

{fast_agent_mcp-0.2.23 → fast_agent_mcp-0.2.24}/.gitignore

@@ -197,7 +197,5 @@ tests/integration/prompt-state/history.json
 !tests/integration/api/fastagent.secrets.yaml
 fastagent.jsonl
 
-# JetBrains IDEs
-.idea/
 tests/e2e/smoke/base/weather_location.txt
 tests/integration/roots/fastagent.jsonl

{fast_agent_mcp-0.2.23 → fast_agent_mcp-0.2.24}/PKG-INFO

@@ -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 → fast_agent_mcp-0.2.24}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.2.23"
+version = "0.2.24"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -31,6 +31,7 @@ dependencies = [
     "opentelemetry-instrumentation-openai>=0.39.3",
     "opentelemetry-instrumentation-anthropic>=0.39.3",
     "tensorzero>=2025.4.7",
+    "opentelemetry-instrumentation-mcp>=0.40.3",
 ]
 
 [project.optional-dependencies]

{fast_agent_mcp-0.2.23 → fast_agent_mcp-0.2.24}/src/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:

{fast_agent_mcp-0.2.23 → fast_agent_mcp-0.2.24}/src/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)

{fast_agent_mcp-0.2.23 → fast_agent_mcp-0.2.24}/src/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

{fast_agent_mcp-0.2.23 → fast_agent_mcp-0.2.24}/src/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: