Thank you @jlowin for raising #680 🙏

The StreamableHTTP client was experiencing a deadlock when the server initiated sampling callbacks during request
processing. The issue occurred due to synchronous request handling in the client's post_writer function.

The Deadlock Scenario:

1. Client sends a tool call request to the server
2. Server processes the tool and needs to perform sampling, initiating a callback to the client
3. Server sends the sampling request to the client as a new JSONRPC request
4. Client's post_writer receives the sampling request but handles it synchronously
5. Client blocks waiting for the server's response to the sampling request
6. Server is blocked waiting for the sampling response before it can complete the original tool call
7. Deadlock: Both client and server are waiting for each other

The circular dependency prevented the sampling response from ever reaching the server, causing the system to hang
indefinitely.

The Solution

Concurrent request handling in the StreamableHTTP client:

1. Added TaskGroup parameter to post_writer to enable concurrent task execution
2. Modified request handling logic to process incoming JSONRPC requests (like sampling callbacks) in separate
   tasks using tg.start_soon(), while responses continue to be handled synchronously (notification need to be handled concurrently as we will have other issues like initialisation notifications )
3. Fixed SSE event handling to properly detect completion and break from the event loop

The fix ensures that request handling doesn't block the message processing pipeline, allowing the client to:

• Process server-initiated callbacks in separate tasks
• Continue listening for new messages in the main task
• Send callback responses without blocking
• Receive the server's completion of the original request

Follow ups:

• as we are working on integration tests - all tests for all the features and transports combinations