Remove caching from stateful. Underlying server can handle it

Author: tconley1428

temporalio/contrib/openai_agents/_mcp.py

@@ -208,7 +208,6 @@ def __init__(
         server: str,
         config: Optional[ActivityConfig],
         server_session_config: Optional[ActivityConfig],
-        cache_tools_list: bool,
     ):
         self._name = server + "-stateful"
         self._config = config or ActivityConfig(
@@ -219,8 +218,6 @@ def __init__(
             start_to_close_timeout=timedelta(hours=1),
         )
         self._connect_handle: Optional[ActivityHandle] = None
-        self._cache_tools_list = cache_tools_list
-        self._tools = None
         super().__init__()
 
     @property
@@ -259,22 +256,16 @@ async def list_tools(
         run_context: Optional[RunContextWrapper[Any]] = None,
         agent: Optional[AgentBase] = None,
     ) -> list[MCPTool]:
-        if self._tools:
-            return self._tools
-
         if not self._connect_handle:
             raise ApplicationError(
                 "Stateful MCP Server not connected. Call connect first."
             )
-        tools = await workflow.execute_activity(
+        return await workflow.execute_activity(
             self.name + "-list-tools",
             args=[],
             result_type=list[MCPTool],
             **self._config,
         )
-        if self._cache_tools_list:
-            self._tools = tools
-        return tools
 
     @_handle_worker_failure
     async def call_tool(

temporalio/contrib/openai_agents/workflow.py

@@ -276,7 +276,6 @@ def stateful_mcp_server(
     name: str,
     config: Optional[ActivityConfig] = None,
     server_session_config: Optional[ActivityConfig] = None,
-    cache_tools_list: bool = False,
 ) -> AbstractAsyncContextManager["MCPServer"]:
     """A stateful MCP server implementation for Temporal workflows.
 
@@ -301,15 +300,12 @@ def stateful_mcp_server(
                Defaults to 1-minute start-to-close and 30-second schedule-to-start timeouts.
         server_session_config: Optional activity configuration for the connection activity.
                        Defaults to 1-hour start-to-close timeout.
-        cache_tools_list: If true, the list of tools will be cached for the duration of the server
     """
     from temporalio.contrib.openai_agents._mcp import (
         _StatefulMCPServerReference,
     )
 
-    return _StatefulMCPServerReference(
-        name, config, server_session_config, cache_tools_list
-    )
+    return _StatefulMCPServerReference(name, config, server_session_config)
 
 
 class ToolSerializationError(TemporalError):

tests/contrib/openai_agents/test_openai.py

@@ -2289,7 +2289,7 @@ async def test_output_type(client: Client):
 @workflow.defn
 class McpServerWorkflow:
     @workflow.run
-    async def run(self, timeout: timedelta, caching: bool) -> str:
+    async def run(self, caching: bool) -> str:
         from agents.mcp import MCPServer
 
         server: MCPServer = openai_agents.workflow.stateless_mcp_server(
@@ -2309,14 +2309,13 @@ async def run(self, timeout: timedelta, caching: bool) -> str:
 @workflow.defn
 class McpServerStatefulWorkflow:
     @workflow.run
-    async def run(self, timeout: timedelta, caching: bool) -> str:
+    async def run(self, timeout: timedelta) -> str:
         async with openai_agents.workflow.stateful_mcp_server(
             "HelloServer",
             config=ActivityConfig(
                 schedule_to_start_timeout=timeout,
                 start_to_close_timeout=timedelta(seconds=30),
             ),
-            cache_tools_list=caching,
         ) as server:
             agent = Agent[str](
                 name="MCP ServerWorkflow",
@@ -2355,6 +2354,9 @@ async def test_mcp_server(
     if sys.version_info < (3, 10):
         pytest.skip("Mcp not supported on Python 3.9")
 
+    if stateful and caching:
+        pytest.skip("Caching is only supported for stateless MCP servers")
+
     from agents.mcp import MCPServer
     from mcp import GetPromptResult, ListPromptsResult  # type: ignore
     from mcp import Tool as MCPTool  # type: ignore
@@ -2447,15 +2449,15 @@ async def get_prompt(
         if stateful:
             result = await client.execute_workflow(
                 McpServerStatefulWorkflow.run,
-                args=[timedelta(seconds=30), caching],
+                args=[timedelta(seconds=30)],
                 id=f"mcp-server-{uuid.uuid4()}",
                 task_queue=worker.task_queue,
                 execution_timeout=timedelta(seconds=30),
             )
         else:
             result = await client.execute_workflow(
                 McpServerWorkflow.run,
-                args=[timedelta(seconds=30), caching],
+                args=[caching],
                 id=f"mcp-server-{uuid.uuid4()}",
                 task_queue=worker.task_queue,
                 execution_timeout=timedelta(seconds=30),
@@ -2465,24 +2467,15 @@ async def get_prompt(
     if use_local_model:
         print(tracking_server.calls)
         if stateful:
-            if caching:
-                assert tracking_server.calls == [
-                    "connect",
-                    "list_tools",
-                    "call_tool",
-                    "call_tool",
-                    "cleanup",
-                ]
-            else:
-                assert tracking_server.calls == [
-                    "connect",
-                    "list_tools",
-                    "call_tool",
-                    "list_tools",
-                    "call_tool",
-                    "list_tools",
-                    "cleanup",
-                ]
+            assert tracking_server.calls == [
+                "connect",
+                "list_tools",
+                "call_tool",
+                "list_tools",
+                "call_tool",
+                "list_tools",
+                "cleanup",
+            ]
             assert len(cast(StatefulMCPServerProvider, server)._servers) == 0
         else:
             if caching: