when tools/call request is complete, but notifications/progress is still sent, will get a error "rejected by transport"

[vegetable-boy]

Pre-submission Checklist

• I have checked that this question would not be more appropriate as an issue in a specific repository
• I have searched existing discussions and documentation for answers

Question Category

• Protocol Specification
• SDK Usage
• Server Implementation
• General Implementation
• Documentation
• Other

Your Question

How can I solve this : after the server-side tools/call returns results, ensuring the notification request can still be sent out?

[vegetable-boy]

this error refer to https://github.com/modelcontextprotocol/go-sdk/blob/main/mcp/streamable.go#L1156

if s == nil {
// The request was made in the context of an ongoing request, but that
// request is complete.
//
// In the future, we could be less strict and allow the request to land on
// the standalone SSE stream.
return fmt.Errorf("%w: write to closed stream", jsonrpc2.ErrRejected)
}

[ryux1]

notifications/progress belongs to the request identified by its progress token. It must be sent while that request is still in progress; once the tool handler returns its tools/call result, that request is complete and sending more progress for it is no longer valid.

With Streamable HTTP, the SDK also enforces this at the transport layer. The handler context carries the related request, and the response removes that request-to-stream association. Reusing the context afterward therefore produces ErrRejected: write to closed stream, which is the branch you linked.

Keep the handler open until the work and its final progress notification finish, and check each notification error:

mcp.AddTool(server, tool, func(
    ctx context.Context,
    req *mcp.CallToolRequest,
    args Input,
) (*mcp.CallToolResult, Output, error) {
    token := req.Params.GetProgressToken()

    for i := range steps {
        // Perform this step synchronously, or wait for its worker here.
        if err := runStep(ctx, steps[i]); err != nil {
            return nil, Output{}, err
        }

        if token != nil {
            if err := req.Session.NotifyProgress(ctx, &mcp.ProgressNotificationParams{
                ProgressToken: token,
                Progress:      float64(i + 1),
                Total:         float64(len(steps)),
            }); err != nil {
                return nil, Output{}, err
            }
        }
    }

    return &mcp.CallToolResult{}, Output{/* ... */}, nil
})

Do not launch a goroutine that keeps using the handler's ctx or progress token after returning. If the operation must outlive tools/call, return an application-level job ID and expose a separate status/cancel tool or resource; notifications about that job need their own protocol/application contract and should not be represented as progress for the completed call.

The SDK's current progress example sends all notifications before returning, and the closed-stream check documents that related messages are rejected after the response.