parent
3486f6bcaf
commit
cd7d80c591
1 changed files with 1368 additions and 104 deletions
|
|
@ -191,6 +191,13 @@ func connect[H handler, State any](ctx context.Context, t Transport, b binder[H,
|
|||
preempter.conn = conn
|
||||
return jsonrpc2.HandlerFunc(h.handle)
|
||||
}
|
||||
// Transports may opt in to propagating cancellation of ctx into request
|
||||
// handler contexts when their own lifecycle IS the cancellation signal
|
||||
// (e.g., a connection bound to a single HTTP request).
|
||||
var propagateCancellation bool
|
||||
if cp, ok := mcpConn.(cancellationPropagator); ok {
|
||||
propagateCancellation = cp.propagateCancellation()
|
||||
}
|
||||
_ = jsonrpc2.NewConnection(ctx, jsonrpc2.ConnectionConfig{
|
||||
Reader: reader,
|
||||
Writer: writer,
|
||||
|
|
@ -203,11 +210,22 @@ func connect[H handler, State any](ctx context.Context, t Transport, b binder[H,
|
|||
OnInternalError: func(err error) {
|
||||
logger.Error("jsonrpc2 internal error", "error", err)
|
||||
},
|
||||
PropagateCancellation: propagateCancellation,
|
||||
})
|
||||
assert(preempter.conn != nil, "unbound preempter")
|
||||
return h, nil
|
||||
}
|
||||
|
||||
// cancellationPropagator is an optional interface implemented by a
|
||||
// [Connection] whose own lifecycle should propagate cancellation into request
|
||||
// handler contexts. The default jsonrpc2 behavior is to suppress propagation;
|
||||
// transports that bind a connection to a single short-lived carrier (such as
|
||||
// a one-shot HTTP request) should return true here so that handlers unwind
|
||||
// when the carrier observes the peer going away.
|
||||
type cancellationPropagator interface {
|
||||
propagateCancellation() bool
|
||||
}
|
||||
|
||||
// A canceller is a jsonrpc2.Preempter that cancels in-flight requests on MCP
|
||||
// cancelled notifications.
|
||||
type canceller struct {
|
||||
|
|
@ -230,6 +248,24 @@ func (c *canceller) Preempt(ctx context.Context, req *jsonrpc.Request) (result a
|
|||
return nil, jsonrpc2.ErrNotHandled
|
||||
}
|
||||
|
||||
// callSubscriptionsListen issues a "subscriptions/listen" call (SEP-2575)
|
||||
// without awaiting its JSON-RPC response. The call's logical lifetime is the
|
||||
// stream of notifications that follow on the same channel — the empty
|
||||
// response, if ever delivered, only marks subscription teardown — so the
|
||||
// caller has nothing useful to block on.
|
||||
//
|
||||
// Cancellation is driven by ctx: when it is cancelled, a background goroutine
|
||||
// sends a "notifications/cancelled" notification referencing the listen's
|
||||
// request ID and retires the call from the connection's outgoing-calls map.
|
||||
func callSubscriptionsListen(ctx context.Context, conn *jsonrpc2.Connection, method string, params Params) {
|
||||
call := conn.Call(ctx, method, params)
|
||||
|
||||
go func() {
|
||||
<-ctx.Done()
|
||||
_ = cancelCall(ctx, conn, call)
|
||||
}()
|
||||
}
|
||||
|
||||
// call executes and awaits a jsonrpc2 call on the given connection,
|
||||
// translating errors into the mcp domain.
|
||||
func call(ctx context.Context, conn *jsonrpc2.Connection, method string, params Params, result Result) error {
|
||||
|
|
@ -240,24 +276,7 @@ func call(ctx context.Context, conn *jsonrpc2.Connection, method string, params
|
|||
case errors.Is(err, jsonrpc2.ErrClientClosing), errors.Is(err, jsonrpc2.ErrServerClosing):
|
||||
return fmt.Errorf("%w: calling %q: %v", ErrConnectionClosed, method, err)
|
||||
case ctx.Err() != nil:
|
||||
notifyCtx, cancelNotify := context.WithTimeout(context.WithoutCancel(ctx), notifyCancellationTimeout)
|
||||
defer cancelNotify()
|
||||
err := conn.Notify(notifyCtx, notificationCancelled, &CancelledParams{
|
||||
Reason: ctx.Err().Error(),
|
||||
RequestID: call.ID().Raw(),
|
||||
})
|
||||
// By default, the jsonrpc2 library waits for graceful shutdown when the
|
||||
// connection is closed, meaning it expects all outgoing and incoming
|
||||
// requests to complete. However, for MCP this expectation is unrealistic,
|
||||
// and can lead to hanging shutdown. For example, if a streamable client is
|
||||
// killed, the server will not be able to detect this event, except via
|
||||
// keepalive pings (if they are configured), and so outgoing calls may hang
|
||||
// indefinitely.
|
||||
//
|
||||
// Therefore, we choose to eagerly retire calls, removing them from the
|
||||
// outgoingCalls map, when the caller context is cancelled: if the caller
|
||||
// will never receive the response, there's no need to track it.
|
||||
conn.Retire(call, ctx.Err())
|
||||
err := cancelCall(ctx, conn, call)
|
||||
return errors.Join(ctx.Err(), err)
|
||||
case err != nil:
|
||||
return fmt.Errorf("calling %q: %w", method, err)
|
||||
|
|
@ -265,6 +284,30 @@ func call(ctx context.Context, conn *jsonrpc2.Connection, method string, params
|
|||
return nil
|
||||
}
|
||||
|
||||
// cancelCall sends a "notifications/cancelled" notification for call and eagerly
|
||||
// retires it from conn.
|
||||
//
|
||||
// By default, the jsonrpc2 library waits for graceful shutdown when the
|
||||
// connection is closed, meaning it expects all outgoing and incoming requests
|
||||
// to complete. However, for MCP this expectation is unrealistic, and can lead
|
||||
// to hanging shutdown. For example, if a streamable client is killed, the
|
||||
// server will not be able to detect this event, except via keepalive pings (if
|
||||
// they are configured), and so outgoing calls may hang indefinitely.
|
||||
//
|
||||
// Therefore, we choose to eagerly retire calls, removing them from the
|
||||
// outgoingCalls map, when the caller context is cancelled: if the caller will
|
||||
// never receive the response, there's no need to track it.
|
||||
func cancelCall(ctx context.Context, conn *jsonrpc2.Connection, call *jsonrpc2.AsyncCall) error {
|
||||
notifyCtx, cancelNotify := context.WithTimeout(context.WithoutCancel(ctx), notifyCancellationTimeout)
|
||||
defer cancelNotify()
|
||||
err := conn.Notify(notifyCtx, notificationCancelled, &CancelledParams{
|
||||
Reason: ctx.Err().Error(),
|
||||
RequestID: call.ID().Raw(),
|
||||
})
|
||||
conn.Retire(call, ctx.Err())
|
||||
return err
|
||||
}
|
||||
|
||||
// A LoggingTransport is a [Transport] that delegates to another transport,
|
||||
// writing RPC logs to an io.Writer.
|
||||
type LoggingTransport struct {
|
||||
|
|
|
|||
Loading…
Reference in a new issue