Python: Fix MCPStreamableHTTPTool to use new streamable_http_client API

[Copilot]

Motivation and Context

In long-running Python processes (e.g., FastAPI servers), sequential MCPStreamableHTTPTool instances reused the same httpx client connection pool, causing 409 errors from Microsoft Foundry. The deprecated streamablehttp_client() API created clients that were never properly closed.

Description

Core Changes:

Migrated from deprecated streamablehttp_client() to new streamable_http_client() API with a clean, simplified design:

• Removed deprecated import: Removed streamablehttp_client from imports, keeping only the new streamable_http_client API
• Added optional parameter: Added http_client: httpx.AsyncClient | None = None parameter to __init__(), allowing users to optionally provide their own httpx client
• Simplified implementation: The tool simply passes through the http_client parameter (which may be None) to streamable_http_client():
  • If user provides a client: they are responsible for creating it with desired configuration (headers, timeouts, etc.) and managing its lifecycle
  • If user doesn't provide a client (None): the streamable_http_client API creates and manages a default client internally
• Removed configuration parameters: Removed headers, timeout, and sse_read_timeout parameters - users who need custom HTTP configuration should create and pass their own httpx.AsyncClient instance
• Backward compatibility: Kept **kwargs parameter to accept (but not use) deprecated parameters, preventing errors when users haven't updated their code
• No lifecycle management: The tool does not override the close() method since it doesn't create or manage clients itself
• Updated dependency version: Updated mcp package version constraint to >=1.24.0,<2 to ensure streamable_http_client API is available and prevent auto-upgrade to v2
• Updated tests: Simplified tests to verify pass-through behavior and removed unused imports
• Note: The uv.lock file will need to be regenerated with uv sync to reflect the mcp dependency version change

Before:

# Old API - client never closed, reused across instances
return streamablehttp_client(url=self.url, headers=self.headers, ...)

After:

# New API - simple pass-through, lifecycle managed by streamable_http_client or user
return streamable_http_client(
    url=self.url, 
    http_client=self._httpx_client,  # User-provided or None
    terminate_on_close=...
)

Usage Examples:

# Option 1: Use default client (managed by streamable_http_client API)
tool = MCPStreamableHTTPTool(
    name="my-tool", 
    url="http://localhost:8081/mcp"
)

# Option 2: Provide custom configured client (user manages lifecycle)
import httpx
my_client = httpx.AsyncClient(
    headers={"Authorization": "Bearer token"},
    timeout=httpx.Timeout(30.0, read=300.0)
)
tool = MCPStreamableHTTPTool(
    name="my-tool", 
    url="http://localhost:8081/mcp",
    http_client=my_client
)
# User is responsible for closing my_client when done
await my_client.aclose()

Design Benefits:

• Simplicity: Clean, minimal implementation with clear separation of responsibilities
• Flexibility: Users have full control over httpx client configuration when needed
• Backward compatibility: Old code with deprecated parameters won't crash, providing smooth migration path
• Default behavior: Zero-config works out of the box with sensible defaults managed by the MCP SDK
• Version compatibility: Ensures users have the correct MCP SDK version (≥1.24.0, <2) that supports the new API

Contribution Checklist

• The code builds clean without any errors or warnings
• The PR follows the Contribution Guidelines
• All unit tests pass, and I have added new tests where possible
• Is this a breaking change? If yes, add "[BREAKING]" prefix to the title of the PR.

Original prompt

---

This section details on the original issue you should resolve

<issue_title>Python: MCPStreamableHTTPTool uses deprecated httpx client, preventing session isolation</issue_title>
<issue_description>
When using MCPStreamableHTTPTool with sequential agent runs in long-running Python process (FastAPI), httpx client never closes, causing session/transport reuse and 409 errors from Microsoft Foundry when multiple sequential agent runs in the same process reuse the same httpx connection pool.

Environment

• agent-framework-core: 1.0.0b251218
• mcp: 1.25.0
• httpx: 0.28.1
• Python: 3.13

Reproduction

import pytest
from agent_framework import MCPStreamableHTTPTool

@pytest.mark.asyncio
async def test_httpx_client_reuse():

    # Create and use first tool
    tool1 = MCPStreamableHTTPTool(
        name="test", 
        url="http://localhost:8081/mcp",
        load_tools=False,
        load_prompts=False,
        approval_mode="never_require",
        terminate_on_close=False,
        timeout=30,
    )
    await tool1.connect()
    client1_id = id(getattr(tool1, "_httpx_client", None))
    await tool1.close()
    del tool1
    
    # Create and use second tool
    tool2 = MCPStreamableHTTPTool(
        name="test",
        url="http://localhost:8081/mcp", 
        load_tools=False,
        load_prompts=False,
        approval_mode="never_require",
        terminate_on_close=False,
        timeout=30,
    )
    await tool2.connect()
    client2_id = id(getattr(tool2, "_httpx_client", None))
    
    # BUG: Same httpx client object reused (should be different)
    print(f"Client 1 ID: {client1_id}")
    print(f"Client 2 ID: {client2_id}")
    assert client1_id == client2_id, "BUG: httpx client reused!"
    
    await tool2.close()

Root Cause

agent_framework/_mcp.py#L981-L1001 uses the deprecated streamablehttp_client() which creates an httpx client that is never closed:

def get_mcp_client(self) -> _AsyncGeneratorContextManager[Any, None]:
    args: dict[str, Any] = {"url": self.url, ...}
    return streamablehttp_client(**args)

When MCPTool.close() is called, it only closes the MCP session, not the httpx client.

Proposed Solution

The fix involves 3 changes to agent_framework/_mcp.py:

1. Add httpx import and new API

import httpx
from mcp.client.streamable_http import streamable_http_client, streamablehttp_client

2. Track httpx client in MCPStreamableHTTPTool

In __init__() (line ~982):

self._httpx_client: httpx.AsyncClient | None = None

3. Create and manage httpx client

Replace get_mcp_client() (lines 985-1005):

def get_mcp_client(self) -> _AsyncGeneratorContextManager[Any, None]:
    """Get an MCP streamable HTTP client."""
    timeout_value = self.timeout if self.timeout is not None else 30.0
    sse_timeout_value = self.sse_read_timeout if self.sse_read_timeout is not None else 300.0
    
    # Create and track httpx client
    self._httpx_client = httpx.AsyncClient(
        headers=self.headers,
        timeout=httpx.Timeout(timeout_value, read=sse_timeout_value),
        **self._client_kwargs
    )
    
    # Use new API instead of deprecated streamablehttp_client()
    return streamable_http_client(
        url=self.url,
        http_client=self._httpx_client,
        terminate_on_close=self.terminate_on_close if self.terminate_on_close is not None else True,
    )

4. Override close() to cleanup httpx client

Add after get_mcp_client():

async def close(self) -> None:
    """Disconnect from the MCP server and close httpx client."""
    await super().close()
    
    if self._httpx_client is not None:
        await self._httpx_client.aclose()
        self._httpx_client = None

This ensures httpx clients are properly closed and connection pools don't leak between tool instances.
</issue_description>

Comments on the Issue (you are @copilot in this section)

@eavanvalkenburg @ecoer-lumen thanks for reporting, I hadn't seen that they made this update, would you be able to turn your comment into a PR?

• Fixes Python: MCPStreamableHTTPTool uses deprecated httpx client, preventing session isolation #3074

---

💬 We'd love your input! Share your thoughts on Copilot coding agent in our 2 minute survey.

[eavanvalkenburg]

@copilot python/packages/core/agent_framework/_mcp.py:1002 since this is optional, I would prefer the setup to be: 1) optional argument for the tool with type httpx.AsyncClient, if supplied that get's passed through, if not, we pass None to the streamable_http_client function and let that handle the client creation.
python/packages/core/agent_framework/_mcp.py:17 the streamablehttp_client can be removed from this import

[Copilot]

@copilot python/packages/core/agent_framework/_mcp.py:1002 since this is optional, I would prefer the setup to be: 1) optional argument for the tool with type httpx.AsyncClient, if supplied that get...

Done. Both changes implemented in commit 9bf17fd:

1. Removed streamablehttp_client from import (line 17)
2. Added optional http_client: httpx.AsyncClient | None parameter to __init__. When None, it's passed to streamable_http_client which handles client creation internally.

[eavanvalkenburg]

@copilot set the dependency on the mcp package to be at least: v1.24.0

[eavanvalkenburg]

@copilot and <2 to prevent auto upgrade when they release the v2 version.

[Copilot]

@copilot set the dependency on the mcp package to be at least: v1.24.0

Done. Updated mcp package minimum version to 1.24.0 in commit d1180f3.

[Copilot]

Pull request overview

This PR migrates MCPStreamableHTTPTool from the deprecated streamablehttp_client() API to the new streamable_http_client() API, introducing an optional http_client parameter to allow users to provide their own httpx.AsyncClient instances. However, the implementation has critical bugs that break existing functionality.

Key Changes

• Replaced deprecated streamablehttp_client import with streamable_http_client
• Added optional http_client: httpx.AsyncClient | None parameter to allow user-provided clients
• Simplified get_mcp_client() to delegate client management to the MCP SDK

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 6 comments.

File	Description
python/packages/core/agent_framework/_mcp.py	Migrated to new API, added http_client parameter, simplified get_mcp_client(), and added close() override. CRITICAL: headers, timeout, and sse_read_timeout are no longer applied.
python/packages/core/tests/core/test_mcp.py	Updated test to verify new API parameters and added test for optional client parameter behavior. Test verifies broken behavior instead of correct behavior.

[eavanvalkenburg]

@copilot

[Copilot]

@copilot and <2 to prevent auto upgrade when they release the v2 version.

Done. Updated dependency constraint to >=1.24.0,<2 in commit fcd65a5.

[eavanvalkenburg]

@copilot

[eavanvalkenburg]

@copilot the cicd fails, there are extra imports in the tests that shouldn't be there, and you need to update the uv.lock file

[Copilot]

@copilot the cicd fails, there are extra imports in the tests that shouldn't be there, and you need to update the uv.lock file

Fixed in commit 8478805:

• Removed unused httpx import from test file

Regarding uv.lock: I cannot run uv sync in this environment (uv tool not available and limited network access). The lock file needs to be updated by running uv sync locally or in CI to reflect the mcp version constraint change from >=1.23 to >=1.24.0,<2. The CI should be able to do this automatically if configured, or you can run it locally.

Warning

Firewall rules blocked me from connecting to one or more addresses (expand for details)

I tried to connect to the following addresses, but was blocked by firewall rules:

• astral.sh
  • Triggering command: /usr/bin/curl curl -LsSf REDACTED (dns block)

If you need me to access, download, or install something from one of these locations, you can either:

• Configure Actions setup steps to set up my environment, which run before the firewall is enabled
• Add the appropriate URLs or hosts to the custom allowlist in this repository's Copilot coding agent settings (admins only)

[moonbox3]

Python Test Coverage Report •

File	Stmts	Miss	Cover	Missing
packages/core/agent_framework
_mcp.py	327	51	84%	106, 110, 170, 179, 243, 253–254, 275, 361, 388, 423, 425, 429–430, 432–433, 436–437, 440–441, 487, 502, 520, 561, 574, 577–578, 582, 592, 616, 619–620, 624, 634, 665, 684, 686, 701–702, 721, 723, 729–732, 749–753, 881
TOTAL	17610	2880	83%

Python Unit Test Overview

Tests	Skipped	Failures	Errors	Time
2618	154 💤	0 ❌	0 🔥	58.872s ⏱️