variants: simplify dispatch and session by reducing method boilerplate (#8)

Simplify variant dispatch and session by replacing per-method
boilerplate with generic handlers backed by reflect.

## Motivation and Context
The dispatcher and backend session had separate handler functions for
every MCP method (ListTools, ListResources, CallTool, Subscribe, etc.),
each following an identical pattern: extract params, inject metadata,
call inner handler, cast result. This meant ~250 lines of near-identical
code across dispatch.go and session.go, and every new MCP method
required adding another copy.

## How Has This Been Tested?
All existing unit and integration tests pass (go test -v ./...)

## Breaking Changes
None. All changes are internal to the variants package. Public API is
unchanged.

## Types of changes
Refactor (non-breaking change which fixes an issue)
This commit is contained in:
Steven Chen 2026-05-01 12:29:10 +01:00 • committed by GitHub
commit b95923d172
No known key found for this signature in database
GPG key ID: B5690EEEBB952194

View file

@ -6,7 +6,8 @@ package variants
import (
"context"
"fmt"
"errors"
"reflect"
"sync"
"github.com/modelcontextprotocol/go-sdk/mcp"
@ -42,110 +43,34 @@ type backendSession struct {
mcpMethodHandler mcp.MethodHandler
}
func (s *backendSession) ListTools(ctx context.Context, p *mcp.ListToolsParams, extra *mcp.RequestExtra) (*mcp.ListToolsResult, error) {
result, err := s.mcpMethodHandler(ctx, "tools/list", &mcp.ListToolsRequest{Session: s.serverSession, Params: p, Extra: extra})
if err != nil {
return nil, err
// handleReceive invokes mcpMethodHandler for any MCP method by modifying the request's
// Session field to point to the inner server session. This replaces the explicit
// per-method functions (ListTools, CallTool, etc.) with a single generic handler.
//
// The dispatcher is responsible for modifying params (metadata injection,
// cursor unwrapping) before calling this method.
func (s *backendSession) handleReceive(ctx context.Context, method string, req mcp.Request) (mcp.Result, error) {
// Shallow-copy the concrete request struct so we don't mutate the caller's object
// while replacing the Session field with our inner server session.
// We can't use a wrapper (like the sending side's sessionSwappedRequest) because
// the SDK's receiving handler does type assertions on the concrete request type.
reqVal := reflect.ValueOf(req)
if reqVal.Kind() != reflect.Ptr {
return nil, errors.New("variants: expected pointer to request struct")
}
r, ok := result.(*mcp.ListToolsResult)
if !ok && result != nil {
return nil, fmt.Errorf("unexpected result type %T for tools/list", result)
}
return r, nil
}
func (s *backendSession) ListResources(ctx context.Context, p *mcp.ListResourcesParams, extra *mcp.RequestExtra) (*mcp.ListResourcesResult, error) {
result, err := s.mcpMethodHandler(ctx, "resources/list", &mcp.ListResourcesRequest{Session: s.serverSession, Params: p, Extra: extra})
if err != nil {
return nil, err
}
r, ok := result.(*mcp.ListResourcesResult)
if !ok && result != nil {
return nil, fmt.Errorf("unexpected result type %T for resources/list", result)
}
return r, nil
}
// Allocate a new struct of the same concrete type and shallow-copy all fields.
copyPtr := reflect.New(reqVal.Elem().Type())
copyPtr.Elem().Set(reqVal.Elem())
func (s *backendSession) ListPrompts(ctx context.Context, p *mcp.ListPromptsParams, extra *mcp.RequestExtra) (*mcp.ListPromptsResult, error) {
result, err := s.mcpMethodHandler(ctx, "prompts/list", &mcp.ListPromptsRequest{Session: s.serverSession, Params: p, Extra: extra})
if err != nil {
return nil, err
// Set Session on the copy to point to the inner server session.
sessionField := copyPtr.Elem().FieldByName("Session")
if !sessionField.IsValid() || !sessionField.CanSet() {
return nil, errors.New("variants: request type missing settable Session field")
}
r, ok := result.(*mcp.ListPromptsResult)
if !ok && result != nil {
return nil, fmt.Errorf("unexpected result type %T for prompts/list", result)
}
return r, nil
}
sessionField.Set(reflect.ValueOf(s.serverSession))
func (s *backendSession) ListResourceTemplates(ctx context.Context, p *mcp.ListResourceTemplatesParams, extra *mcp.RequestExtra) (*mcp.ListResourceTemplatesResult, error) {
result, err := s.mcpMethodHandler(ctx, "resources/templates/list", &mcp.ListResourceTemplatesRequest{Session: s.serverSession, Params: p, Extra: extra})
if err != nil {
return nil, err
}
r, ok := result.(*mcp.ListResourceTemplatesResult)
if !ok && result != nil {
return nil, fmt.Errorf("unexpected result type %T for resources/templates/list", result)
}
return r, nil
}
func (s *backendSession) CallTool(ctx context.Context, p *mcp.CallToolParamsRaw, extra *mcp.RequestExtra) (*mcp.CallToolResult, error) {
result, err := s.mcpMethodHandler(ctx, "tools/call", &mcp.CallToolRequest{Session: s.serverSession, Params: p, Extra: extra})
if err != nil {
return nil, err
}
r, ok := result.(*mcp.CallToolResult)
if !ok && result != nil {
return nil, fmt.Errorf("unexpected result type %T for tools/call", result)
}
return r, nil
}
func (s *backendSession) ReadResource(ctx context.Context, p *mcp.ReadResourceParams, extra *mcp.RequestExtra) (*mcp.ReadResourceResult, error) {
result, err := s.mcpMethodHandler(ctx, "resources/read", &mcp.ReadResourceRequest{Session: s.serverSession, Params: p, Extra: extra})
if err != nil {
return nil, err
}
r, ok := result.(*mcp.ReadResourceResult)
if !ok && result != nil {
return nil, fmt.Errorf("unexpected result type %T for resources/read", result)
}
return r, nil
}
func (s *backendSession) GetPrompt(ctx context.Context, p *mcp.GetPromptParams, extra *mcp.RequestExtra) (*mcp.GetPromptResult, error) {
result, err := s.mcpMethodHandler(ctx, "prompts/get", &mcp.GetPromptRequest{Session: s.serverSession, Params: p, Extra: extra})
if err != nil {
return nil, err
}
r, ok := result.(*mcp.GetPromptResult)
if !ok && result != nil {
return nil, fmt.Errorf("unexpected result type %T for prompts/get", result)
}
return r, nil
}
func (s *backendSession) Subscribe(ctx context.Context, p *mcp.SubscribeParams, extra *mcp.RequestExtra) error {
_, err := s.mcpMethodHandler(ctx, "resources/subscribe", &mcp.SubscribeRequest{Session: s.serverSession, Params: p, Extra: extra})
return err
}
func (s *backendSession) Unsubscribe(ctx context.Context, p *mcp.UnsubscribeParams, extra *mcp.RequestExtra) error {
_, err := s.mcpMethodHandler(ctx, "resources/unsubscribe", &mcp.UnsubscribeRequest{Session: s.serverSession, Params: p, Extra: extra})
return err
}
func (s *backendSession) Complete(ctx context.Context, p *mcp.CompleteParams, extra *mcp.RequestExtra) (*mcp.CompleteResult, error) {
result, err := s.mcpMethodHandler(ctx, "completion/complete", &mcp.CompleteRequest{Session: s.serverSession, Params: p, Extra: extra})
if err != nil {
return nil, err
}
r, ok := result.(*mcp.CompleteResult)
if !ok && result != nil {
return nil, fmt.Errorf("unexpected result type %T for completion/complete", result)
}
return r, nil
return s.mcpMethodHandler(ctx, method, copyPtr.Interface().(mcp.Request))
}
// sessionState holds all per-session state for one front client.