internal/jsonrpc2: remove unused server, network, and framing infrastructure

Remove code inherited from x/tools/internal/jsonrpc2_v2 that is not used
by MCP transports. MCP transports implement their own framing and
connection management, using only the Connection engine and message
encode/decode from this package.

Removed files:
- serve.go: Server, Listener, Dialer, idleListener, Dial, NewServer
- net.go: NetListener, NetDialer, NetPipeListener
- serve_test.go, jsonrpc2_test.go: tests for removed infrastructure

Removed from remaining files:
- frame.go: Framer interface, RawFramer, HeaderFramer implementations
- conn.go: Binder, BinderFunc, ConnectionOptions, bindConnection
- jsonrpc2.go: ErrIdleTimeout, PreempterFunc, defaultHandler, async helper
- wire.go: ErrServerOverloaded
- conn.go: AsyncCall.IsReady (unused method)

Author: maciej-kisiel

internal/jsonrpc2/conn.go

@@ -16,45 +16,6 @@ import (
 	"github.com/modelcontextprotocol/go-sdk/internal/json"
 )
 
-// Binder builds a connection configuration.
-// This may be used in servers to generate a new configuration per connection.
-// ConnectionOptions itself implements Binder returning itself unmodified, to
-// allow for the simple cases where no per connection information is needed.
-type Binder interface {
-	// Bind returns the ConnectionOptions to use when establishing the passed-in
-	// Connection.
-	//
-	// The connection is not ready to use when Bind is called,
-	// but Bind may close it without reading or writing to it.
-	Bind(context.Context, *Connection) ConnectionOptions
-}
-
-// A BinderFunc implements the Binder interface for a standalone Bind function.
-type BinderFunc func(context.Context, *Connection) ConnectionOptions
-
-func (f BinderFunc) Bind(ctx context.Context, c *Connection) ConnectionOptions {
-	return f(ctx, c)
-}
-
-var _ Binder = BinderFunc(nil)
-
-// ConnectionOptions holds the options for new connections.
-type ConnectionOptions struct {
-	// Framer allows control over the message framing and encoding.
-	// If nil, HeaderFramer will be used.
-	Framer Framer
-	// Preempter allows registration of a pre-queue message handler.
-	// If nil, no messages will be preempted.
-	Preempter Preempter
-	// Handler is used as the queued message handler for inbound messages.
-	// If nil, all responses will be ErrNotHandled.
-	Handler Handler
-	// OnInternalError, if non-nil, is called with any internal errors that occur
-	// while serving the connection, such as protocol errors or invariant
-	// violations. (If nil, internal errors result in panics.)
-	OnInternalError func(error)
-}
-
 // Connection manages the jsonrpc2 protocol, connecting responses back to their
 // calls. Connection is bidirectional; it does not have a designated server or
 // client end.
@@ -197,11 +158,6 @@ type incomingRequest struct {
 	cancel   context.CancelFunc
 }
 
-// Bind returns the options unmodified.
-func (o ConnectionOptions) Bind(context.Context, *Connection) ConnectionOptions {
-	return o
-}
-
 // A ConnectionConfig configures a bidirectional jsonrpc2 connection.
 type ConnectionConfig struct {
 	Reader          Reader                    // required
@@ -230,59 +186,16 @@ func NewConnection(ctx context.Context, cfg ConnectionConfig) *Connection {
 	return c
 }
 
-// bindConnection creates a new connection and runs it.
-//
-// This is used by the Dial and Serve functions to build the actual connection.
-//
-// The connection is closed automatically (and its resources cleaned up) when
-// the last request has completed after the underlying ReadWriteCloser breaks,
-// but it may be stopped earlier by calling Close (for a clean shutdown).
-func bindConnection(bindCtx context.Context, rwc io.ReadWriteCloser, binder Binder, onDone func()) *Connection {
-	// TODO: Should we create a new event span here?
-	// This will propagate cancellation from ctx; should it?
-	ctx := notDone{bindCtx}
-
-	c := &Connection{
-		state:  inFlightState{closer: rwc},
-		done:   make(chan struct{}),
-		onDone: onDone,
-	}
-	// It's tempting to set a finalizer on c to verify that the state has gone
-	// idle when the connection becomes unreachable. Unfortunately, the Binder
-	// interface makes that unsafe: it allows the Handler to close over the
-	// Connection, which could create a reference cycle that would cause the
-	// Connection to become uncollectable.
-
-	options := binder.Bind(bindCtx, c)
-	framer := options.Framer
-	if framer == nil {
-		framer = HeaderFramer()
-	}
-	c.handler = options.Handler
-	if c.handler == nil {
-		c.handler = defaultHandler{}
-	}
-	c.onInternalError = options.OnInternalError
-
-	c.writer = framer.Writer(rwc)
-	reader := framer.Reader(rwc)
-	c.start(ctx, reader, options.Preempter)
-	return c
-}
-
 func (c *Connection) start(ctx context.Context, reader Reader, preempter Preempter) {
 	c.updateInFlight(func(s *inFlightState) {
 		select {
 		case <-c.done:
-			// Bind already closed the connection; don't start a goroutine to read it.
+			// The connection was already closed; don't start a goroutine to read it.
 			return
 		default:
 		}
 
 		// The goroutine started here will continue until the underlying stream is closed.
-		//
-		// (If the Binder closed the Connection already, this should error out and
-		// return almost immediately.)
 		s.reading = true
 		go c.readIncoming(ctx, reader, preempter)
 	})
@@ -439,18 +352,6 @@ type AsyncCall struct {
 // This can be used to cancel the call if needed.
 func (ac *AsyncCall) ID() ID { return ac.id }
 
-// IsReady can be used to check if the result is already prepared.
-// This is guaranteed to return true on a result for which Await has already
-// returned, or a call that failed to send in the first place.
-func (ac *AsyncCall) IsReady() bool {
-	select {
-	case <-ac.ready:
-		return true
-	default:
-		return false
-	}
-}
-
 // retire processes the response to the call.
 //
 // It is an error to call retire more than once: retire is guarded by the

internal/jsonrpc2/frame.go

@@ -4,16 +4,7 @@
 
 package jsonrpc2
 
-import (
-	"bufio"
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"strconv"
-	"strings"
-	"sync"
-)
+import "context"
 
 // Reader abstracts the transport mechanics from the JSON RPC protocol.
 // A Conn reads messages from the reader it was provided on construction,
@@ -38,171 +29,3 @@ type Writer interface {
 	// Write sends a message to the stream.
 	Write(context.Context, Message) error
 }
-
-// Framer wraps low level byte readers and writers into jsonrpc2 message
-// readers and writers.
-// It is responsible for the framing and encoding of messages into wire form.
-//
-// TODO(rfindley): rethink the framer interface, as with JSONRPC2 batching
-// there is a need for Reader and Writer to be correlated, and while the
-// implementation of framing here allows that, it is not made explicit by the
-// interface.
-//
-// Perhaps a better interface would be
-//
-//	Frame(io.ReadWriteCloser) (Reader, Writer).
-type Framer interface {
-	// Reader wraps a byte reader into a message reader.
-	Reader(io.Reader) Reader
-	// Writer wraps a byte writer into a message writer.
-	Writer(io.Writer) Writer
-}
-
-// RawFramer returns a new Framer.
-// The messages are sent with no wrapping, and rely on json decode consistency
-// to determine message boundaries.
-func RawFramer() Framer { return rawFramer{} }
-
-type rawFramer struct{}
-type rawReader struct{ in *json.Decoder }
-type rawWriter struct {
-	mu  sync.Mutex
-	out io.Writer
-}
-
-func (rawFramer) Reader(rw io.Reader) Reader {
-	return &rawReader{in: json.NewDecoder(rw)}
-}
-
-func (rawFramer) Writer(rw io.Writer) Writer {
-	return &rawWriter{out: rw}
-}
-
-func (r *rawReader) Read(ctx context.Context) (Message, error) {
-	select {
-	case <-ctx.Done():
-		return nil, ctx.Err()
-	default:
-	}
-	var raw json.RawMessage
-	if err := r.in.Decode(&raw); err != nil {
-		return nil, err
-	}
-	msg, err := DecodeMessage(raw)
-	return msg, err
-}
-
-func (w *rawWriter) Write(ctx context.Context, msg Message) error {
-	select {
-	case <-ctx.Done():
-		return ctx.Err()
-	default:
-	}
-
-	data, err := EncodeMessage(msg)
-	if err != nil {
-		return fmt.Errorf("marshaling message: %v", err)
-	}
-
-	w.mu.Lock()
-	defer w.mu.Unlock()
-	_, err = w.out.Write(data)
-	return err
-}
-
-// HeaderFramer returns a new Framer.
-// The messages are sent with HTTP content length and MIME type headers.
-// This is the format used by LSP and others.
-func HeaderFramer() Framer { return headerFramer{} }
-
-type headerFramer struct{}
-type headerReader struct{ in *bufio.Reader }
-type headerWriter struct {
-	mu  sync.Mutex
-	out io.Writer
-}
-
-func (headerFramer) Reader(rw io.Reader) Reader {
-	return &headerReader{in: bufio.NewReader(rw)}
-}
-
-func (headerFramer) Writer(rw io.Writer) Writer {
-	return &headerWriter{out: rw}
-}
-
-func (r *headerReader) Read(ctx context.Context) (Message, error) {
-	select {
-	case <-ctx.Done():
-		return nil, ctx.Err()
-	default:
-	}
-
-	firstRead := true // to detect a clean EOF below
-	var contentLength int64
-	// read the header, stop on the first empty line
-	for {
-		line, err := r.in.ReadString('\n')
-		if err != nil {
-			if err == io.EOF {
-				if firstRead && line == "" {
-					return nil, io.EOF // clean EOF
-				}
-				err = io.ErrUnexpectedEOF
-			}
-			return nil, fmt.Errorf("failed reading header line: %w", err)
-		}
-		firstRead = false
-
-		line = strings.TrimSpace(line)
-		// check we have a header line
-		if line == "" {
-			break
-		}
-		colon := strings.IndexRune(line, ':')
-		if colon < 0 {
-			return nil, fmt.Errorf("invalid header line %q", line)
-		}
-		name, value := line[:colon], strings.TrimSpace(line[colon+1:])
-		switch {
-		case strings.EqualFold(name, "Content-Length"):
-			if contentLength, err = strconv.ParseInt(value, 10, 32); err != nil {
-				return nil, fmt.Errorf("failed parsing Content-Length: %v", value)
-			}
-			if contentLength <= 0 {
-				return nil, fmt.Errorf("invalid Content-Length: %v", contentLength)
-			}
-		default:
-			// ignoring unknown headers
-		}
-	}
-	if contentLength == 0 {
-		return nil, fmt.Errorf("missing Content-Length header")
-	}
-	data := make([]byte, contentLength)
-	_, err := io.ReadFull(r.in, data)
-	if err != nil {
-		return nil, err
-	}
-	msg, err := DecodeMessage(data)
-	return msg, err
-}
-
-func (w *headerWriter) Write(ctx context.Context, msg Message) error {
-	select {
-	case <-ctx.Done():
-		return ctx.Err()
-	default:
-	}
-	w.mu.Lock()
-	defer w.mu.Unlock()
-
-	data, err := EncodeMessage(msg)
-	if err != nil {
-		return fmt.Errorf("marshaling message: %v", err)
-	}
-	_, err = fmt.Fprintf(w.out, "Content-Length: %v\r\n\r\n", len(data))
-	if err == nil {
-		_, err = w.out.Write(data)
-	}
-	return err
-}