5bd7ab4d2a<!-- Provide a brief summary of your changes --> Route `interceptors/list` and `interceptor/invoke` through the receiving middleware chain so that middleware installed (audit, etc.) fires for interceptor protocol methods the same way it does for standard MCP methods. ## Motivation and Context <!-- Why is this change needed? What problem does it solve? --> Before this change, custom JSON-RPC methods were dispatched via a separate code path that bypassed receiving middleware entirely. This meant any middleware an operator installed would silently not apply to the interceptor protocol endpoints. The fix adds `AddReceivingCustomMethod[P, R, T]` as a package-level generic function to the vendored go-sdk/mcp package. Custom methods registered through it are stored in a per-server customMethods map and merged into `receivingMethodInfos()`, so `defaultReceivingMethodHandler` dispatches them exactly like built-in methods. External types satisfy the sealed `Params`/`Result` interfaces by embedding the `ParamsBase`/`ResultBase` types exported from the mcp package. ## How Has This Been Tested? <!-- Have you tested this in a real application? Which scenarios were tested? --> Existing test suites and new ones for verifying middleware paths. ## Breaking Changes <!-- Will users need to update their code or configurations? --> no. ## Types of changes <!-- What types of changes does your code introduce? Put an `x` in all the boxes that apply: --> - [x] Bug fix (non-breaking change which fixes an issue) - [ ] New feature (non-breaking change which adds functionality) - [ ] Breaking change (fix or feature that would cause existing functionality to change) - [ ] Documentation update ## Checklist <!-- Go over all the following points, and put an `x` in all the boxes that apply. --> - [x] I have read the [MCP Documentation](https://modelcontextprotocol.io) - [x] My code follows the repository's style guidelines - [x] New and existing tests pass locally - [x] I have added appropriate error handling - [x] I have added or updated documentation as needed ## Additional context <!-- Add any other context, implementation notes, or design decisions --> The changes to `vendor/go-sdk/mcp/server.go` are intentionally minimal and carry a `NOTE` comment acknowledging they are additions to the upstream SDK needed for this reference implementation. --------- Signed-off-by: Ukjae Jeong <jeongukjae@gmail.com>
107 lines
2.8 KiB
Go
107 lines
2.8 KiB
Go
// Copyright 2025 The MCP Interceptors Authors. All rights reserved.
|
|
// Use of this source code is governed by an Apache-2.0
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package extension
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"slices"
|
|
"time"
|
|
|
|
"github.com/modelcontextprotocol/go-sdk/jsonrpc"
|
|
"github.com/modelcontextprotocol/go-sdk/mcp"
|
|
|
|
"github.com/modelcontextprotocol/ext-interceptors/go/sdk/interceptors"
|
|
)
|
|
|
|
// handleList implements the "interceptors/list" JSON-RPC method.
|
|
// It returns all registered interceptors, optionally filtered by event.
|
|
func (e *Extension) handleList(_ context.Context, req *mcp.ServerRequest[*interceptors.ListParams]) (*interceptors.ListResult, error) {
|
|
var event string
|
|
if req.Params != nil {
|
|
event = req.Params.Event
|
|
}
|
|
|
|
all := e.getInterceptors()
|
|
infos := make([]interceptors.InterceptorInfo, 0, len(all))
|
|
for _, ri := range all {
|
|
if event != "" && !slices.Contains(ri.GetMetadata().Hook.Events, event) {
|
|
continue
|
|
}
|
|
infos = append(infos, interceptors.InfoFromInterceptor(ri))
|
|
}
|
|
|
|
return &interceptors.ListResult{Interceptors: infos}, nil
|
|
}
|
|
|
|
// handleInvoke implements the "interceptor/invoke" JSON-RPC method.
|
|
// It invokes a single interceptor by name and returns its result.
|
|
func (e *Extension) handleInvoke(ctx context.Context, req *mcp.ServerRequest[*interceptors.InvokeParams]) (*interceptors.InvokeResult, error) {
|
|
if req.Params == nil || req.Params.Name == "" {
|
|
return nil, &jsonrpc.Error{
|
|
Code: jsonrpc.CodeInvalidParams,
|
|
Message: "name is required",
|
|
}
|
|
}
|
|
params := req.Params
|
|
|
|
// Look up the interceptor by name.
|
|
i := e.findByName(params.Name)
|
|
if i == nil {
|
|
return nil, &jsonrpc.Error{
|
|
Code: jsonrpc.CodeInvalidParams,
|
|
Message: fmt.Sprintf("interceptor %q not found", params.Name),
|
|
}
|
|
}
|
|
|
|
// Apply timeout if specified.
|
|
if params.TimeoutMs > 0 {
|
|
var cancel context.CancelFunc
|
|
ctx, cancel = context.WithTimeout(ctx, time.Duration(params.TimeoutMs)*time.Millisecond)
|
|
defer cancel()
|
|
}
|
|
|
|
inv := &interceptors.Invocation{
|
|
Event: params.Event,
|
|
Phase: params.Phase,
|
|
Payload: params.Payload,
|
|
Config: params.Config,
|
|
Context: params.Context,
|
|
}
|
|
|
|
start := time.Now()
|
|
|
|
result := &interceptors.InvokeResult{
|
|
Interceptor: params.Name,
|
|
Type: i.GetType(),
|
|
Phase: params.Phase,
|
|
}
|
|
defer func() { result.DurationMs = time.Since(start).Milliseconds() }()
|
|
|
|
switch v := i.(type) {
|
|
case *interceptors.Validator:
|
|
vr, err := v.Handler(ctx, inv)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
result.Validation = vr
|
|
|
|
case *interceptors.Mutator:
|
|
mr, err := v.Handler(ctx, inv)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
result.Mutation = mr
|
|
result.Payload = mr.Payload
|
|
|
|
default:
|
|
return nil, &jsonrpc.Error{
|
|
Code: jsonrpc.CodeInternalError,
|
|
Message: fmt.Sprintf("unsupported interceptor type %T", i),
|
|
}
|
|
}
|
|
|
|
return result, nil
|
|
}
|