@@ -3431,6 +3431,110 @@ def string
34313431 assert_equal "ok" , result [ :content ] [ :text ]
34323432 end
34333433
3434+ test "refuses a POST reusing an in-flight request id and keeps the original stream" do
3435+ server = Server . new ( name : "test" , tools : [ ] , prompts : [ ] , resources : [ ] )
3436+ transport = StreamableHTTPTransport . new ( server )
3437+ server . transport = transport
3438+
3439+ gate = Queue . new
3440+ server . define_tool ( name : "victim_tool" ) do |server_context :|
3441+ server_context . report_progress ( 1 , message : "first-frame" )
3442+ gate . pop
3443+ server_context . report_progress ( 2 , message : "second-frame" )
3444+ Tool ::Response . new ( [ { type : "text" , text : "done" } ] )
3445+ end
3446+
3447+ session_id , server_session = start_session ( transport )
3448+
3449+ victim = transport . handle_request ( colliding_tool_call ( session_id , "req-1" ) )
3450+ victim_stream = TestStream . new
3451+ victim_thread = Thread . new { victim [ 2 ] . call ( victim_stream ) }
3452+ sleep ( 0.01 ) until server_session . lookup_in_flight ( "req-1" )
3453+
3454+ attacker = transport . handle_request ( colliding_tool_call ( session_id , "req-1" ) )
3455+
3456+ assert_equal 409 , attacker [ 0 ]
3457+ assert_equal (
3458+ JsonRpcHandler ::ErrorCode ::INVALID_REQUEST ,
3459+ JSON . parse ( attacker [ 2 ] [ 0 ] ) . dig ( "error" , "code" ) ,
3460+ )
3461+
3462+ gate << :go
3463+ victim_thread . join
3464+
3465+ # The registration survived the refusal, so the frame emitted after it still reaches
3466+ # the request that asked for it.
3467+ assert_includes victim_stream . string , "first-frame"
3468+ assert_includes victim_stream . string , "second-frame"
3469+ end
3470+
3471+ test "a finishing request leaves a stream another request registered under the same id" do
3472+ server = Server . new ( name : "test" , tools : [ ] , prompts : [ ] , resources : [ ] )
3473+ transport = StreamableHTTPTransport . new ( server )
3474+ server . transport = transport
3475+
3476+ gate = Queue . new
3477+ server . define_tool ( name : "victim_tool" ) do |server_context :|
3478+ gate . pop
3479+ Tool ::Response . new ( [ { type : "text" , text : "done" } ] )
3480+ end
3481+
3482+ session_id , server_session = start_session ( transport )
3483+
3484+ victim = transport . handle_request ( colliding_tool_call ( session_id , "req-1" ) )
3485+ victim_stream = TestStream . new
3486+ victim_thread = Thread . new { victim [ 2 ] . call ( victim_stream ) }
3487+ sleep ( 0.01 ) until server_session . lookup_in_flight ( "req-1" )
3488+
3489+ # Stand in for a stream that won the registration in a race the pre-dispatch refusal normally prevents.
3490+ # Finishing the other request must not unregister it.
3491+ foreign_stream = TestStream . new
3492+ sessions = transport . instance_variable_get ( :@sessions )
3493+ sessions [ session_id ] [ :post_request_streams ] [ "req-1" ] = foreign_stream
3494+
3495+ gate << :go
3496+ victim_thread . join
3497+
3498+ assert_same foreign_stream , sessions [ session_id ] [ :post_request_streams ] [ "req-1" ]
3499+ end
3500+
3501+ test "a broken request-scoped stream drops only itself, even when it is not the registered one" do
3502+ server = Server . new ( name : "test" , tools : [ ] , prompts : [ ] , resources : [ ] )
3503+ transport = StreamableHTTPTransport . new ( server )
3504+ server . transport = transport
3505+
3506+ session_id , = start_session ( transport )
3507+ sessions = transport . instance_variable_get ( :@sessions )
3508+ registered = TestStream . new
3509+ sessions [ session_id ] [ :post_request_streams ] = { "req-1" => registered }
3510+
3511+ transport . send ( :drop_broken_stream , session_id , TestStream . new , "req-1" )
3512+
3513+ assert sessions . key? ( session_id ) , "a request-scoped failure must not tear down the session"
3514+ assert_same registered , sessions [ session_id ] [ :post_request_streams ] [ "req-1" ]
3515+ end
3516+
3517+ test "allows a request id to be reused once the earlier request has finished" do
3518+ server = Server . new ( name : "test" , tools : [ ] , prompts : [ ] , resources : [ ] )
3519+ transport = StreamableHTTPTransport . new ( server )
3520+ server . transport = transport
3521+
3522+ server . define_tool ( name : "victim_tool" ) do |server_context :|
3523+ Tool ::Response . new ( [ { type : "text" , text : "done" } ] )
3524+ end
3525+
3526+ session_id , = start_session ( transport )
3527+
3528+ 2 . times do
3529+ response = transport . handle_request ( colliding_tool_call ( session_id , "req-1" ) )
3530+
3531+ assert_equal 200 , response [ 0 ]
3532+ stream = TestStream . new
3533+ response [ 2 ] . call ( stream )
3534+ assert_includes stream . string , "done"
3535+ end
3536+ end
3537+
34343538 test "JSON response mode returns accepted when cancellation suppresses response" do
34353539 server = Server . new ( name : "test" , tools : [ ] , prompts : [ ] , resources : [ ] )
34363540 transport = StreamableHTTPTransport . new ( server , enable_json_response : true )
@@ -6199,6 +6303,36 @@ def install_mutex_probe_stream(session_id, related_request_id: nil)
61996303 writes
62006304 end
62016305
6306+ # Initializes `transport` and returns its session id together with the `ServerSession`,
6307+ # which the in-flight request id tests poll to know when a request has really started.
6308+ def start_session ( transport )
6309+ request = create_rack_request (
6310+ "POST" ,
6311+ "/" ,
6312+ { "CONTENT_TYPE" => "application/json" } ,
6313+ { jsonrpc : "2.0" , method : "initialize" , id : "init" , params : initialize_params } . to_json ,
6314+ )
6315+ session_id = transport . handle_request ( request ) [ 1 ] [ "mcp-session-id" ]
6316+
6317+ [ session_id , transport . instance_variable_get ( :@sessions ) [ session_id ] [ :server_session ] ]
6318+ end
6319+
6320+ # A `tools/call` for `victim_tool` under a caller-chosen request id, with a progress token so
6321+ # the tool's `report_progress` has somewhere to go.
6322+ def colliding_tool_call ( session_id , request_id )
6323+ create_rack_request (
6324+ "POST" ,
6325+ "/" ,
6326+ { "CONTENT_TYPE" => "application/json" , "HTTP_MCP_SESSION_ID" => session_id } ,
6327+ {
6328+ jsonrpc : "2.0" ,
6329+ id : request_id ,
6330+ method : "tools/call" ,
6331+ params : { name : "victim_tool" , arguments : { } , _meta : { progressToken : "tok" } } ,
6332+ } . to_json ,
6333+ )
6334+ end
6335+
62026336 def create_rack_request ( method , path , headers , body = nil )
62036337 default_accept = case method
62046338 when "POST"
0 commit comments