RuntimeError: Attempted to exit cancel scope in a different task than it was entered in with AsyncExitStack #79

Activity

1. rectalogic

   added

   bugSomething isn't workingSomething isn't working

   on Nov 28, 2024
2. rectalogic commented on Nov 28, 2024

   

   rectalogic

   on Nov 28, 2024

   Author

   More actions

   Looks like an anyio issue and this is probably not the correct approach, closing.
3. rectalogic

   closed this as completedon Nov 28, 2024
4. docshun commented on Mar 21, 2025

   

   docshun

   on Mar 21, 2025

   More actions

   I met the same problem, how did you solve it
5. WikiHkz commented on Apr 1, 2025

   

   WikiHkz

   on Apr 1, 2025

   More actions

   I met the same problem, how did you solve it?
6. fuhuiking commented on Apr 4, 2025

   

   fuhuiking

   on Apr 4, 2025

   More actions

   I met the same problem, how did you solve it?
7. rectalogic commented on Apr 4, 2025

   

   rectalogic

   on Apr 4, 2025

   Author

   More actions

   Solve it by not doing this asyncio.create_task(exit_stack.aclose())
8. liudonghua123 commented on Apr 7, 2025

   

   liudonghua123

   on Apr 7, 2025

   More actions

   I have the similar problems when trying to extract the session creation into a separate module.

   Run it with python openai_function_calling_with_mcp.py.

   # openai_function_calling_with_mcp.py
   from mcp_client import McpClient
   from openai import OpenAI
   import os
   import json
   from dotenv import load_dotenv
   import asyncio
   
   load_dotenv()
   
   # Initialize OpenAI client with environment variables
   client = OpenAI(
       api_key=os.getenv("OPENAI_API_KEY"), base_url=os.getenv("OPENAI_BASE_URL")
   )
   
   async def run_conversation():
       messages = [
           {
               "role": "user",
               "content": "What's the weather in Shanghai and what's the current date and time?",
           }
       ]
   
       async with McpClient.get_mcp_client() as mcp_client:
           # Get available tools
           mcp_tools = await mcp_client.list_tools()
           tools = [
               {
                   "type": "function",
                   "function": {
                       "name": tool.name,
                       "description": tool.description,
                       "parameters": tool.inputSchema,
                   },
               }
               for tool in mcp_tools.tools
           ]
           print(f"Available tools: {[t.name for t in mcp_tools.tools]}")
   
           response = client.chat.completions.create(
               model=os.getenv("OPENAI_MODEL_NAME"),
               messages=messages,
               tools=tools,
               tool_choice="auto",
           )
   
           # Handle function calling
           while response.choices[0].finish_reason == "tool_calls":
               tool_call = response.choices[0].message.tool_calls[0]
               function_name = tool_call.function.name
               arguments = json.loads(tool_call.function.arguments)
   
               # Call MCP tool
               function_response = await mcp_client.call_tool(
                   name=function_name, arguments=arguments
               )
   
               messages.append(response.choices[0].message)
               messages.append(
                   {
                       "role": "tool",
                       "content": function_response.content[0].text,
                       "tool_call_id": tool_call.id,
                   }
               )
   
               response = client.chat.completions.create(
                   model=os.getenv("OPENAI_MODEL_NAME"),
                   messages=messages,
                   tools=tools,
                   tool_choice="auto",
               )
   
           print(response.choices[0].message.content)
   
   
   if __name__ == "__main__":
       asyncio.run(run_conversation())

   # mcp_client.py
   from contextlib import asynccontextmanager, AsyncExitStack
   from types import TracebackType
   from mcp import ClientSession, StdioServerParameters, stdio_client
   
   class McpClient:
       def __init__(self, server_command="python", server_args=["mcp_server.py"]):
           self.server = StdioServerParameters(
               command=server_command,
               args=server_args
           )
           self._client_session = None
           self._exit_stack = None
   
       @asynccontextmanager
       async def initialize(self):
           """Initialize the client connection using AsyncExitStack"""
           # Not works, RuntimeError: Attempted to exit cancel scope in a different task than it was entered in
           self._exit_stack = AsyncExitStack()
           try:
               read, write = await self._exit_stack.enter_async_context(stdio_client(self.server))
               mcp_client = await self._exit_stack.enter_async_context(ClientSession(read, write))
               await mcp_client.initialize()
               self._client_session = mcp_client
               yield mcp_client
               # self._exit_stack.pop_all() # This line does not fix the issue too.
           except Exception as e:
               await self._exit_stack.aclose()
               
           # works without errors
           # async with AsyncExitStack() as stack:
           #     read, write = await stack.enter_async_context(stdio_client(self.server))
           #     mcp_client = await stack.enter_async_context(ClientSession(read, write))
           #     await mcp_client.initialize()
           #     self._client_session = mcp_client
           #     yield mcp_client
   
       async def call_tool(self, name, arguments):
           """Call a tool by name with given arguments"""
           if not self._client_session:
               raise RuntimeError("Client not initialized")
           return await self._client_session.call_tool(name=name, arguments=arguments)
   
       async def list_tools(self):
           """List available tools"""
           if not self._client_session:
               raise RuntimeError("Client not initialized")
           return await self._client_session.list_tools()
   
       @classmethod
       @asynccontextmanager
       async def get_mcp_client(cls):
           """Backward compatible context manager"""
           client = cls()
           async with client.initialize() as session:
             yield session
   
       
       async def __aexit__(
           self,
           exc_type: type[BaseException] | None,
           exc_val: BaseException | None,
           exc_tb: TracebackType | None,
       ) -> None:
           print("Exiting MCP Client")
           await self._exit_stack.aclose()

   And If I changed initialize of mcp_client to use async with AsyncExitStack() as stack, then no problems.

   🎉React with 🎉4Reacted by Ritesh Kumar, MC Kim, Milind Tataria and Easonshi

   ❤️React with ❤️1Reacted by strawberrymelonpanda
9. npkanaka commented on May 15, 2025

   

   npkanaka

   on May 15, 2025

   More actions

   Just checking if there are any plans to address the RuntimeError when exiting AsyncExitStack across tasks.

   👀React with 👀1Reacted by Easonshi