"""MCP over streamable HTTP: session ids, SSE responses, pagination, a request the server sends in the middle of a call, the GET stream and its list changes, resuming a dropped stream, and a 2026-07-28 stateless server.""" import json import time import unittest from fake_mcp_http_server import MODERN, SCHEMA, SESSION, TOOLS, Server from harness import Albedo, Provider, Reply, exclusive, text class HttpFixture(unittest.TestCase): """One fake server configured as "web" and a session that can call its echo tool with ``self.message``.""" server_options: dict = {} def setUp(self): self.message = "hi" self.calls = 1 self.server = Server(**self.server_options).start() self.addCleanup(self.server.stop) def script(request): tools = sorted(tool["name"] for tool in request.get("tools", [])) answered = ( sum( item.get("type") == "function_call_output" for item in request["input"] ) >= self.calls ) echo = next( (name for name in tools if name.startswith("mcp_web_echo_")), None ) if echo and not answered: return Reply( "python", tool_name=echo, tool_arguments={"message": self.message} ) return text("done") self.provider = Provider(script) self.addCleanup(self.provider.close) def prepare(app): self.configure(app, call_timeout=15000) app.store_secrets( "mcp", {"web": {"headers": {"x-fake-token": "stored-token"}}} ) self.app = Albedo(self.provider, protocol="responses", prepare=prepare) self.app.__enter__() self.addCleanup(self.app.__exit__, None, None, None) self.session = self.app.session() def configure(self, app, call_timeout): path = app.home / "extensions.json" settings = json.loads(path.read_text()) if path.exists() else {} settings.setdefault("models", {"refreshHours": 0}) settings["mcp"] = { "servers": { "web": { "type": "http", "url": self.server.url, "startupTimeoutMs": 10000, "callTimeoutMs": call_timeout, } } } path.write_text(json.dumps(settings)) def output(self, requests): return [ item["output"] for item in requests[-1]["input"] if item.get("type") == "function_call_output" ][-1] def echoed(self, requests): return json.loads(json.loads(self.output(requests))["content"][0]["text"]) def tools(self, requests): return sorted( tool["name"] for tool in requests[0]["tools"] if tool["name"].startswith("mcp_") ) def set_mcp(self, enabled): route = f"/sessions/{self.session}?view=configuration" with self.app.api(route) as response: json.load(response) etag = response.headers["ETag"] self.app.api( route, {"selection": {"extensions": {"mcp": enabled}}}, method="PATCH", headers={"If-Match": etag}, ).close() with self.app.api( f"/sessions/{self.session}/reload", {"target": "session"} ) as response: return json.load(response) def turn(self, prompt): before = len(self.provider.requests) self.app.prompt(self.session, prompt).close() self.app.idle(self.session, timeout=60) return [entry["request"] for entry in self.provider.requests[before:]] def seen(self, verb): return [entry for entry in self.server.seen if entry["verb"] == verb] def wait_until(self, check, message, timeout=10): deadline = time.monotonic() + timeout while not check(): self.assertLess(time.monotonic(), deadline, message) time.sleep(0.05) def push_changed_tools(self, tools): """Changes the server's tools, says so on its stream, and waits for the session to advertise them.""" self.assertTrue(self.server.wait_for_stream(), "no stream was opened") self.server.tools = tools self.server.push( {"jsonrpc": "2.0", "method": "notifications/tools/list_changed"} ) deadline = time.monotonic() + 20 advertised = [] while len(advertised) != len(tools): self.assertLess(time.monotonic(), deadline, "the session never refreshed") time.sleep(0.2) advertised = self.tools(self.turn("has it changed?")) self.assertIn( "capabilities changed", json.dumps(self.app.history(self.session)) ) return advertised # exclusive: fixture configures global MCP servers and credentials @exclusive class McpHttpTests(HttpFixture): def test_session_pages_and_a_server_request_during_a_call(self): self.assertEqual(self.set_mcp(True)["session"]["state"], "applied") requests = self.turn("use the http server") advertised = self.tools(requests) self.assertEqual(len(advertised), 2, advertised) self.assertTrue(advertised[0].startswith("mcp_web_echo_")) self.assertTrue(advertised[1].startswith("mcp_web_shout_")) self.assertEqual( self.echoed(requests), {"echoed": "hi", "tool": "echo", "roots": -32601} ) # The server/discover probe is refused the way session-based SDK # servers refuse a request before initialize, so albedo falls back. posts = self.seen("POST") methods = [entry["message"].get("method") for entry in posts] self.assertEqual( methods[:3], ["server/discover", "initialize", "notifications/initialized"] ) self.assertEqual(posts[0]["version"], MODERN) self.assertIsNone(posts[1]["session"]) for entry in posts: self.assertEqual(entry["token"], "stored-token") for entry in posts[2:]: self.assertEqual(entry["session"], SESSION) self.assertEqual(entry["version"], "2025-06-18") self.wait_until(lambda: self.seen("GET"), "the GET stream never opened") self.assertEqual(self.seen("GET")[0]["session"], SESSION) self.assertEqual(self.set_mcp(False)["session"]["state"], "applied") self.wait_until(lambda: self.seen("DELETE"), "closing never ended the session") self.assertEqual(self.seen("DELETE")[0]["session"], SESSION) def test_a_call_that_times_out_is_cancelled_and_the_next_one_works(self): self.configure(self.app, call_timeout=1500) self.assertEqual(self.set_mcp(True)["session"]["state"], "applied") self.message = "hang" self.assertIn("timed out", json.loads(self.output(self.turn("hang")))["error"]) call = next( entry["message"] for entry in self.server.seen if entry["message"] and entry["message"].get("method") == "tools/call" ) cancelled = [ entry["message"]["params"] for entry in self.server.seen if entry["message"] and entry["message"].get("method") == "notifications/cancelled" ] self.assertEqual([c["requestId"] for c in cancelled], [call["id"]]) self.message, self.calls = "again", 2 self.assertEqual(self.echoed(self.turn("again"))["echoed"], "again") def test_the_get_stream_refreshes_changed_tools_and_answers_a_ping(self): self.server.tools = TOOLS[:1] self.set_mcp(True) self.assertEqual(len(self.tools(self.turn("one tool"))), 1) self.assertTrue(self.server.wait_for_stream(), "the GET stream never opened") self.server.push({"jsonrpc": "2.0", "id": "ping-1", "method": "ping"}) answer = self.server.answer("ping-1") self.assertIsNotNone(answer, "the ping on the GET stream was not answered") self.assertEqual(answer.get("result"), {}) advertised = self.push_changed_tools(TOOLS) self.assertTrue(advertised[1].startswith("mcp_web_shout_")) def test_a_dropped_call_stream_resumes_with_last_event_id(self): self.set_mcp(True) self.message = "drop" self.assertEqual(self.echoed(self.turn("drop the stream"))["echoed"], "drop") call = next( entry["message"]["id"] for entry in self.server.seen if entry["message"] and entry["message"].get("method") == "tools/call" ) resumed = [ entry for entry in self.seen("GET") if entry["last_event"] is not None ] self.assertEqual(len(resumed), 1, resumed) self.assertEqual(resumed[0]["last_event"], f"call-{call}-2") self.assertEqual(resumed[0]["session"], SESSION) # exclusive: fixture configures global MCP servers and credentials @exclusive class McpHttpWithoutGetTests(HttpFixture): server_options = {"get": False} def test_a_server_without_a_get_stream_is_not_asked_again(self): self.set_mcp(True) self.assertEqual(self.echoed(self.turn("no stream"))["echoed"], "hi") self.wait_until(lambda: self.seen("GET"), "the GET stream was never tried") time.sleep(1.5) self.assertEqual(len(self.seen("GET")), 1) MIRRORED = { "type": "object", "required": ["message"], "properties": {"message": {"type": "string", "x-mcp-header": "Message"}}, } # x-mcp-header may only sit on a property reached through `properties`. BROKEN = { "type": "object", "properties": { "list": {"type": "array", "items": {"type": "string", "x-mcp-header": "X"}} }, } # exclusive: fixture configures global MCP servers and credentials @exclusive class McpModernHttpTests(HttpFixture): server_options = { "modern": True, "tools": [ {"name": "echo", "description": "echo", "inputSchema": MIRRORED}, {"name": "broken", "description": "broken", "inputSchema": BROKEN}, ], } def test_a_stateless_server_is_spoken_to_without_a_handshake(self): self.assertEqual(self.set_mcp(True)["session"]["state"], "applied") requests = self.turn("use the modern server") advertised = self.tools(requests) self.assertEqual(len(advertised), 1, advertised) self.assertTrue(advertised[0].startswith("mcp_web_echo_")) self.assertEqual(self.echoed(requests)["echoed"], "hi") posts = self.seen("POST") methods = [entry["message"]["method"] for entry in posts] self.assertEqual(methods[0], "server/discover") self.assertNotIn("initialize", methods) self.assertIn("subscriptions/listen", methods) for entry in posts: self.assertIsNone(entry["session"]) self.assertEqual(entry["version"], MODERN) self.assertEqual(entry["method"], entry["message"]["method"]) meta = entry["message"]["params"]["_meta"] self.assertEqual(meta["io.modelcontextprotocol/protocolVersion"], MODERN) self.assertEqual(meta["io.modelcontextprotocol/clientCapabilities"], {}) call = next(e for e in posts if e["message"]["method"] == "tools/call") self.assertEqual((call["name"], call["param"]), ("echo", "hi")) self.assertEqual(self.seen("GET"), []) def test_list_changes_arrive_on_the_subscription(self): self.set_mcp(True) self.assertEqual(len(self.tools(self.turn("one tool"))), 1) shout = {"name": "shout", "description": "shout", "inputSchema": SCHEMA} advertised = self.push_changed_tools([self.server.tools[0], shout]) self.assertTrue(advertised[1].startswith("mcp_web_shout_"))