revert: remove additional async method and just keep sync

Author: dbschmigelski

src/strands/tools/mcp/mcp_client.py

@@ -191,31 +191,6 @@ async def _list_prompts_async() -> ListPromptsResult:
 
         return list_prompts_response
 
-    async def list_prompts_async(self, pagination_token: Optional[str] = None) -> ListPromptsResult:
-        """Asynchronously retrieves the list of available prompts from the MCP server.
-
-        This method calls the asynchronous list_prompts method on the MCP session
-        and returns the raw ListPromptsResult with pagination support.
-
-        Args:
-            pagination_token: Optional token for pagination
-
-        Returns:
-            ListPromptsResult: The raw MCP response containing prompts and pagination info
-        """
-        self._log_debug_with_thread("listing MCP prompts asynchronously")
-        if not self._is_session_active():
-            raise MCPClientInitializationError(CLIENT_SESSION_NOT_RUNNING_ERROR_MESSAGE)
-
-        async def _list_prompts_async() -> ListPromptsResult:
-            return await self._background_thread_session.list_prompts(cursor=pagination_token)
-
-        future = self._invoke_on_background_thread(_list_prompts_async())
-        list_prompts_response: ListPromptsResult = await asyncio.wrap_future(future)
-        self._log_debug_with_thread("received %d prompts from MCP server", len(list_prompts_response.prompts))
-
-        return list_prompts_response
-
     def get_prompt_sync(self, prompt_id: str, args: dict[str, Any]) -> GetPromptResult:
         """Synchronously retrieves a prompt from the MCP server.
 
@@ -238,29 +213,6 @@ async def _get_prompt_async() -> GetPromptResult:
 
         return get_prompt_response
 
-    async def get_prompt_async(self, prompt_id: str, args: dict[str, Any]) -> GetPromptResult:
-        """Asynchronously retrieves a prompt from the MCP server.
-
-        Args:
-            prompt_id: The ID of the prompt to retrieve
-            args: Optional arguments to pass to the prompt
-
-        Returns:
-            GetPromptResult: The prompt response from the MCP server
-        """
-        self._log_debug_with_thread("getting MCP prompt asynchronously")
-        if not self._is_session_active():
-            raise MCPClientInitializationError(CLIENT_SESSION_NOT_RUNNING_ERROR_MESSAGE)
-
-        async def _get_prompt_async() -> GetPromptResult:
-            return await self._background_thread_session.get_prompt(prompt_id, arguments=args)
-
-        future = self._invoke_on_background_thread(_get_prompt_async())
-        get_prompt_response: GetPromptResult = await asyncio.wrap_future(future)
-        self._log_debug_with_thread("received prompt from MCP server")
-
-        return get_prompt_response
-
     def call_tool_sync(
         self,
         tool_use_id: str,

tests/strands/tools/mcp/test_mcp_client.py

@@ -401,112 +401,4 @@ def test_get_prompt_sync_session_not_active():
         client.get_prompt_sync("test_prompt_id", {})
 
 
-# Prompt Tests - Async Methods
 
-
-@pytest.mark.asyncio
-async def test_list_prompts_async(mock_transport, mock_session):
-    """Test that list_prompts_async correctly retrieves prompts."""
-    mock_prompt = Prompt(name="test_prompt", description="A test prompt", id="prompt_1")
-    mock_result = ListPromptsResult(prompts=[mock_prompt])
-    mock_session.list_prompts.return_value = mock_result
-
-    with MCPClient(mock_transport["transport_callable"]) as client:
-        with (
-            patch("asyncio.run_coroutine_threadsafe") as mock_run_coroutine_threadsafe,
-            patch("asyncio.wrap_future") as mock_wrap_future,
-        ):
-            mock_future = MagicMock()
-            mock_run_coroutine_threadsafe.return_value = mock_future
-
-            async def mock_awaitable():
-                return mock_result
-
-            mock_wrap_future.return_value = mock_awaitable()
-
-            result = await client.list_prompts_async()
-
-            mock_run_coroutine_threadsafe.assert_called_once()
-            mock_wrap_future.assert_called_once_with(mock_future)
-
-        assert len(result.prompts) == 1
-        assert result.prompts[0].name == "test_prompt"
-        assert result.nextCursor is None
-
-
-@pytest.mark.asyncio
-async def test_list_prompts_async_with_pagination(mock_transport, mock_session):
-    """Test that list_prompts_async correctly handles pagination."""
-    mock_prompt = Prompt(name="test_prompt", description="A test prompt", id="prompt_1")
-    mock_result = ListPromptsResult(prompts=[mock_prompt], nextCursor="next_token")
-    mock_session.list_prompts.return_value = mock_result
-
-    with MCPClient(mock_transport["transport_callable"]) as client:
-        with (
-            patch("asyncio.run_coroutine_threadsafe") as mock_run_coroutine_threadsafe,
-            patch("asyncio.wrap_future") as mock_wrap_future,
-        ):
-            mock_future = MagicMock()
-            mock_run_coroutine_threadsafe.return_value = mock_future
-
-            async def mock_awaitable():
-                return mock_result
-
-            mock_wrap_future.return_value = mock_awaitable()
-
-            result = await client.list_prompts_async(pagination_token="current_token")
-
-            mock_run_coroutine_threadsafe.assert_called_once()
-            mock_wrap_future.assert_called_once_with(mock_future)
-
-        assert len(result.prompts) == 1
-        assert result.prompts[0].name == "test_prompt"
-        assert result.nextCursor == "next_token"
-
-
-@pytest.mark.asyncio
-async def test_list_prompts_async_session_not_active():
-    """Test that list_prompts_async raises an error when session is not active."""
-    client = MCPClient(MagicMock())
-
-    with pytest.raises(MCPClientInitializationError, match="client session is not running"):
-        await client.list_prompts_async()
-
-
-@pytest.mark.asyncio
-async def test_get_prompt_async(mock_transport, mock_session):
-    """Test that get_prompt_async correctly retrieves a prompt."""
-    mock_message = PromptMessage(role="assistant", content=MCPTextContent(type="text", text="This is a test prompt"))
-    mock_result = GetPromptResult(messages=[mock_message])
-    mock_session.get_prompt.return_value = mock_result
-
-    with MCPClient(mock_transport["transport_callable"]) as client:
-        with (
-            patch("asyncio.run_coroutine_threadsafe") as mock_run_coroutine_threadsafe,
-            patch("asyncio.wrap_future") as mock_wrap_future,
-        ):
-            mock_future = MagicMock()
-            mock_run_coroutine_threadsafe.return_value = mock_future
-
-            async def mock_awaitable():
-                return mock_result
-
-            mock_wrap_future.return_value = mock_awaitable()
-
-            result = await client.get_prompt_async("test_prompt_id", {"key": "value"})
-
-            mock_run_coroutine_threadsafe.assert_called_once()
-            mock_wrap_future.assert_called_once_with(mock_future)
-
-        assert len(result.messages) == 1
-        assert result.messages[0].role == "assistant"
-        assert result.messages[0].content.text == "This is a test prompt"
-
-
-@pytest.mark.asyncio
-async def test_get_prompt_async_session_not_active():
-    """Test that get_prompt_async raises an error when session is not active."""
-    client = MCPClient(MagicMock())
-
-    with pytest.raises(MCPClientInitializationError, match="client session is not running"):
-        await client.get_prompt_async("test_prompt_id", {})

tests_integ/test_mcp_client.py

@@ -214,23 +214,23 @@ async def test_mcp_client_async():
     sse_mcp_client = MCPClient(lambda: sse_client("http://127.0.0.1:8005/sse"))
 
     with sse_mcp_client:
-        # Test async prompts functionality
-        prompts_result = await sse_mcp_client.list_prompts_async()
+        # Test sync prompts functionality
+        prompts_result = sse_mcp_client.list_prompts_sync()
         assert len(prompts_result.prompts) >= 2
 
         prompt_names = [prompt.name for prompt in prompts_result.prompts]
         assert "greeting_prompt" in prompt_names
         assert "math_prompt" in prompt_names
 
-        # Test get_prompt_async
-        greeting_result = await sse_mcp_client.get_prompt_async("greeting_prompt", {"name": "Bob"})
+        # Test get_prompt_sync
+        greeting_result = sse_mcp_client.get_prompt_sync("greeting_prompt", {"name": "Bob"})
         assert len(greeting_result.messages) > 0
         prompt_text = greeting_result.messages[0].content.text
         assert "Hello, Bob!" in prompt_text
         assert "How are you today?" in prompt_text
 
-        # Test async pagination for prompts
-        prompts_with_pagination = await sse_mcp_client.list_prompts_async(pagination_token="test_token")
+        # Test sync pagination for prompts
+        prompts_with_pagination = sse_mcp_client.list_prompts_sync(pagination_token="test_token")
         assert len(prompts_with_pagination.prompts) >= 0
 
         # Test async tools functionality (existing)