The “SendNotificationToSpecificClient” interface quickly sends a disconnect notification to the client

[f1025211271]

hello, In streamable mode, I frequently send notifications to a client. When the client disconnects, how can I quickly detect that it has terminated—so I stop sending notifications immediately? Currently, SendNotificationToSpecificClient only fails when the notification chan becomes full, but by then the client may have already disconnected long ago, and I’m still sending unnecessarily.
My code:
————————————————————
notifyOnce := func() error {
now := time.Now()
payload := map[string]any{
"stream_id": streamID, // 对应关系关键字段
"timestamp": now.Format(time.RFC3339Nano),
"unix": now.Unix(),
"session_id": sessionID, // 可选：便于调试
}

	// 打印发送 notify 的日志
	log.Printf("[Notify] Sending tick to session_id=%s, stream_id=%s, time=%s\n", sessionID, streamID, payload["timestamp"])

	return srv.SendNotificationToSpecificClient(sessionID, tickNotifyMethod, payload)
}

go func() {
	ticker := time.NewTicker(time.Duration(intervalSec) * time.Second)
	defer ticker.Stop()

	if err := notifyOnce(); err != nil {
		log.Printf("[Notify Error] Initial notify failed, stopping stream: %v\n", err)
		m.stop(sessionID, streamID)
		return
	}

	for {
		select {
		case <-runCtx.Done():
			return
		case <-ticker.C:
			if err := notifyOnce(); err != nil {
				log.Printf("[Notify Error] Tick notify failed, stopping stream: %v\n", err)
				m.stop(sessionID, streamID)
				return
			}
		}
	}
}()

——————————
i see streamable_http.go
go func() {
for {
select {
case nt := <-session.notificationChannel:
select {
case writeChan <- &nt:
case <-done:
return
}
case samplingReq := <-session.samplingRequestChan:
// Send sampling request to client via SSE
jsonrpcRequest := mcp.JSONRPCRequest{
JSONRPC: "2.0",
ID: mcp.NewRequestId(samplingReq.requestID),
Request: mcp.Request{
Method: string(mcp.MethodSamplingCreateMessage),
},
Params: samplingReq.request.CreateMessageParams,
}
select {
case writeChan <- jsonrpcRequest:
case <-done:
return
}
case elicitationReq := <-session.elicitationRequestChan:
// Send elicitation request to client via SSE
jsonrpcRequest := mcp.JSONRPCRequest{
JSONRPC: "2.0",
ID: mcp.NewRequestId(elicitationReq.requestID),
Request: mcp.Request{
Method: string(mcp.MethodElicitationCreate),
},
Params: elicitationReq.request.Params,
}
select {
case writeChan <- jsonrpcRequest:
case <-done:
return
}
case rootsReq := <-session.rootsRequestChan:
// Send list roots request to client via SSE
jsonrpcRequest := mcp.JSONRPCRequest{
JSONRPC: "2.0",
ID: mcp.NewRequestId(rootsReq.requestID),
Request: mcp.Request{
Method: string(mcp.MethodListRoots),
},
}
select {
case writeChan <- jsonrpcRequest:
case <-done:
return
}
case <-done:
return //*** here Exited but without any cleanup******
}
}
}()
——————————————
Is there a way for me to quickly retrieve exceptions for this session?