Simplify test to use streaming-http only (not SSE)

Co-authored-by: g3force <779094+g3force@users.noreply.github.com>

Author: Copilot

adk/tests/test_agent_integration.py

@@ -455,9 +455,9 @@ async def test_mcp_server_restart_causes_communication_failure(
 
         This test reproduces the issue where:
         1. Agent successfully calls an MCP server tool
-        2. MCP server restarts ungracefully (simulated by making requests return errors)
+        2. MCP server restarts (losing session state)
         3. Agent tries to call the tool again with the SAME agent instance
-        4. Communication fails because the cached MCP session uses invalid session IDs
+        4. Communication fails because the cached MCP session is no longer valid
 
         This reproduces the real-world scenario where a server restarts and loses
         all session state, but the client still has cached session objects.
@@ -482,9 +482,6 @@ async def test_mcp_server_restart_causes_communication_failure(
             final_message="Second calculation done: 30",
         )
 
-        # Track MCP session IDs to detect when sessions change
-        session_ids_seen = []
-
         # Given: MCP server with 'add' tool
         mcp = FastMCP("Calculator")
 
@@ -496,36 +493,36 @@ def add(a: int, b: int) -> int:
         mcp_server_url = "http://test-mcp-restart.local"
         mcp_app = mcp.http_app(path="/mcp")
 
-        # Control variable to simulate server state
-        server_state = {"accept_old_sessions": True, "old_session_ids": set()}
+        # Track server state to simulate restart
+        server_state: dict[str, Any] = {
+            "accept_old_sessions": True,
+            "old_session_ids": set(),
+        }
 
         async with LifespanManager(mcp_app) as mcp_manager:
-            # Custom handler that can reject old session IDs after "restart"
-            async def session_aware_handler(request: httpx.Request) -> httpx.Response:
-                # Check if this is an SSE request with a session ID in the URL
+            # Handler that can reject old session IDs after "restart"
+            async def session_handler(request: httpx.Request) -> httpx.Response:
                 url_str = str(request.url)
 
-                # Extract session ID from URL if present (format: /mcp/sse/SESSION_ID)
+                # Extract session ID from URL path (e.g., /mcp/messages/SESSION_ID)
                 session_id = None
-                if "/sse/" in url_str:
-                    parts = url_str.split("/sse/")
+                if "/messages/" in url_str:
+                    parts = url_str.split("/messages/")
                     if len(parts) > 1:
-                        session_id = parts[1].split("/")[0] if "/" in parts[1] else parts[1].split("?")[0]
-
-                # If we have a session ID and we're not accepting old sessions anymore
-                if session_id:
-                    session_ids_seen.append(session_id)
+                        session_id = parts[1].split("/")[0].split("?")[0]
 
-                    if not server_state["accept_old_sessions"] and session_id in server_state["old_session_ids"]:
-                        # Simulate server not recognizing the old session - return 404
-                        print(f"  [Server] Rejecting old session ID: {session_id}")
+                # Check if we should reject this session
+                if session_id and session_id in server_state["old_session_ids"]:
+                    if not server_state["accept_old_sessions"]:
+                        # Server has "restarted" and doesn't recognize old sessions
+                        print(f"  [Server] Rejecting old session: {session_id}")
                         return httpx.Response(
                             status_code=404,
                             json={"error": "Session not found"},
                             headers={"content-type": "application/json"},
                         )
 
-                # Normal request forwarding
+                # Forward request to MCP server
                 transport = httpx.ASGITransport(app=mcp_manager.app)
                 async with httpx.AsyncClient(transport=transport, base_url=mcp_server_url) as client:
                     response = await client.request(
@@ -535,14 +532,13 @@ async def session_aware_handler(request: httpx.Request) -> httpx.Response:
                         content=request.content,
                     )
 
-                    # Track session IDs from successful responses
+                    # Track successful session IDs
                     if session_id and response.status_code == 200:
                         server_state["old_session_ids"].add(session_id)
-                        print(f"  [Server] Accepting session ID: {session_id}")
 
                     return response
 
-            respx_mock.route(host="test-mcp-restart.local").mock(side_effect=session_aware_handler)
+            respx_mock.route(host="test-mcp-restart.local").mock(side_effect=session_handler)
 
             # When: Create agent with MCP tool
             test_agent = agent_factory("test_agent")
@@ -563,7 +559,7 @@ async def session_aware_handler(request: httpx.Request) -> httpx.Response:
 
                 # ===== SIMULATE SERVER RESTART =====
                 print("\n=== SIMULATING SERVER RESTART ===")
-                print("  Server will now reject all previously established sessions")
+                print("  Server will reject all previously established sessions")
                 server_state["accept_old_sessions"] = False
 
                 # ===== SECOND CALL =====