Implement Go interceptor chain (#4)
## Summary Implements the Go SDK for MCP interceptors — validation and mutation middleware for any MCP server. The framework treats interceptors as first-class MCP primitives: they are registered on an MCP server, discoverable via `interceptors/list`, and invocable via `interceptor/invoke` — the same JSON-RPC pattern as tools, prompts, and resources. A chain engine orchestrates execution across one or more interceptor servers, and an optional go-sdk middleware integration applies interceptors automatically on every matching request/response. ## Architecture **Three-layer design:** 1. **`interceptors`** — Protocol-agnostic core. Defines interceptor types (validators, mutators), metadata, invocation, wire types, and results. Zero MCP dependencies. 2. **`interceptors/mcpserver`** — MCP server integration. Wraps `mcp.Server` to register `interceptors/list` and `interceptor/invoke` as custom JSON-RPC methods and advertise interceptor capabilities during `initialize`. 3. **`interceptors/chain`** — Chain engine. Orchestrates execution across N interceptor servers with trust-boundary-aware ordering, priority-based mutation sequencing, parallel validation, audit-mode isolation, and fail-open/fail-closed semantics. 4. **`interceptors/integrations/gomiddleware`** — Optional go-sdk middleware. Installs on `mcp.Server` via `AddReceivingMiddleware()` to automatically run the interceptor chain on every matching request/response. **Key design decisions:** - **Trust-boundary ordering** — request phase: validate → mutate; response phase: mutate → validate. Validation always guards the boundary crossing. - **Wire-level invocation** — the chain calls `interceptor/invoke` over the MCP transport (even in-process via `LocalChain()`), so local and remote interceptor servers use the same interface. - **Audit-mode isolation** — audit-mode mutators compute transformations without applying them. Only audit mutators pay the serialization cost. - **Concurrency** — validators run in parallel; mutators run sequentially in priority order. ### Package Structure | Package | File | Responsibility | |---------|------|----------------| | `interceptors` | `interceptor.go` | Enums, Metadata, Interceptor interface, Validator/Mutator structs, handler types, Invocation | | `interceptors` | `wire.go` | Wire types: ListParams/Result, InvokeParams/Result, InterceptorInfo, event/method constants | | `interceptors` | `priority.go` | Priority with phase-aware resolution and JSON marshaling | | `interceptors` | `doc.go` | Package documentation with examples | | `interceptors/chain` | `chain.go` | Chain engine: discovery, filtering, sorting, execution orchestration | | `interceptors/chain` | `result.go` | ExecutionResult, AbortInfo | | `interceptors/chain` | `doc.go` | Sub-package documentation | | `interceptors/mcpserver` | `server.go` | MCP server wrapper, interceptor registry, capability advertisement, `LocalChain()` | | `interceptors/mcpserver` | `rpc.go` | `interceptors/list` and `interceptor/invoke` JSON-RPC handlers | | `interceptors/mcpserver` | `doc.go` | Sub-package documentation | | `integrations/gomiddleware` | `middleware.go` | go-sdk `Middleware` that runs the chain on every request/response | | `integrations/gomiddleware` | `errors.go` | Abort-to-JSONRPC error conversion | | `integrations/gomiddleware` | `doc.go` | Sub-package documentation | ### Documentation - `doc/DESIGN.md` — architecture, execution model, integration with go-sdk - `doc/CONFORMANCE.md` — SEP conformance status - `doc/PERFORMANCE.md` — per-request cost model ### Examples - `examples/validator` — blocks dangerous tool calls, demonstrates `WithContextProvider` - `examples/mutator` — tags tool responses with audit trail ## Vendor: go-sdk v1.4.0 with custom method support Vendors `go-sdk` with minimal extensions for custom JSON-RPC methods: - `Server.AddCustomMethod` — registers a handler that bypasses the typed pipeline - `ClientSession.CallCustom` — sends raw JSON-RPC calls for custom methods These changes are generic (not interceptor-specific) and enable any MCP extension to define its own JSON-RPC methods. ## TODO - More integration tests - Unit tests - Support wildcards for event interception (separate PR) --------- Signed-off-by: Kurt Degiorgio <kdegiorgio@bloomberg.net>
This commit is contained in:
parent
45f9e0ef27
commit
c9900f02ab
4 changed files with 62908 additions and 19 deletions
33
go/sdk/interceptors/integrations/gomiddleware/doc.go
Normal file
33
go/sdk/interceptors/integrations/gomiddleware/doc.go
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
// 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 gomiddleware provides an optional MCP middleware that
|
||||
// automatically executes interceptors for every matching
|
||||
// request/response. It uses the [chain.Chain] from the
|
||||
// [interceptors/chain] package, which invokes interceptors via
|
||||
// interceptor/invoke RPCs per the SEP execution model.
|
||||
//
|
||||
// The middleware is installed on an [mcp.Server] via
|
||||
// [mcp.Server.AddReceivingMiddleware]. It marshals request params
|
||||
// and response results to [json.RawMessage], calls
|
||||
// [chain.Chain.Execute], and applies any mutated payloads back to
|
||||
// the request or response.
|
||||
//
|
||||
// # Usage
|
||||
//
|
||||
// // Create interceptor server (registers interceptors as resources)
|
||||
// srv := mcpserver.NewServer(mcpServer)
|
||||
// srv.AddInterceptor(myValidator)
|
||||
// srv.AddInterceptor(myMutator)
|
||||
//
|
||||
// // Create chain via in-memory transport
|
||||
// chain, err := srv.LocalChain(ctx)
|
||||
//
|
||||
// // Install middleware for automatic execution
|
||||
// mcpServer.AddReceivingMiddleware(
|
||||
// gomiddleware.Middleware(chain,
|
||||
// gomiddleware.WithLogger(logger),
|
||||
// ),
|
||||
// )
|
||||
package gomiddleware
|
||||
75
go/sdk/interceptors/integrations/gomiddleware/errors.go
Normal file
75
go/sdk/interceptors/integrations/gomiddleware/errors.go
Normal file
|
|
@ -0,0 +1,75 @@
|
|||
// 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 gomiddleware
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
|
||||
"github.com/modelcontextprotocol/go-sdk/jsonrpc"
|
||||
|
||||
"github.com/modelcontextprotocol/ext-interceptors/go/sdk/interceptors/chain"
|
||||
)
|
||||
|
||||
type validationErrorData struct {
|
||||
ValidationErrors []chain.AbortInfo `json:"validationErrors"`
|
||||
}
|
||||
|
||||
type mutationErrorData struct {
|
||||
FailedInterceptor string `json:"failedInterceptor"`
|
||||
Reason string `json:"reason"`
|
||||
}
|
||||
|
||||
type timeoutErrorData struct {
|
||||
Interceptor string `json:"interceptor"`
|
||||
TimeoutMs int64 `json:"timeoutMs,omitempty"`
|
||||
Phase string `json:"phase"`
|
||||
}
|
||||
|
||||
const codeServerError = -32000
|
||||
|
||||
// abortToJSONRPCError converts a list of abort infos into a *jsonrpc.Error.
|
||||
func abortToJSONRPCError(aborts []chain.AbortInfo) *jsonrpc.Error {
|
||||
first := aborts[0]
|
||||
|
||||
var code int64
|
||||
switch first.Type {
|
||||
case chain.AbortValidation:
|
||||
code = jsonrpc.CodeInvalidParams
|
||||
case chain.AbortTimeout:
|
||||
code = codeServerError
|
||||
default:
|
||||
code = jsonrpc.CodeInternalError
|
||||
}
|
||||
|
||||
var data json.RawMessage
|
||||
switch first.Type {
|
||||
case chain.AbortValidation:
|
||||
d, _ := json.Marshal(validationErrorData{ValidationErrors: aborts})
|
||||
data = d
|
||||
case chain.AbortTimeout:
|
||||
d, _ := json.Marshal(timeoutErrorData{
|
||||
Interceptor: first.Interceptor,
|
||||
Phase: first.Phase,
|
||||
})
|
||||
data = d
|
||||
default:
|
||||
d, _ := json.Marshal(mutationErrorData{
|
||||
FailedInterceptor: first.Interceptor,
|
||||
Reason: first.Reason,
|
||||
})
|
||||
data = d
|
||||
}
|
||||
|
||||
msg := "interceptor abort: " + first.Reason
|
||||
if len(aborts) > 1 {
|
||||
msg = "interceptor abort: multiple validation failures"
|
||||
}
|
||||
|
||||
return &jsonrpc.Error{
|
||||
Code: code,
|
||||
Message: msg,
|
||||
Data: data,
|
||||
}
|
||||
}
|
||||
176
go/sdk/interceptors/integrations/gomiddleware/middleware.go
Normal file
176
go/sdk/interceptors/integrations/gomiddleware/middleware.go
Normal file
|
|
@ -0,0 +1,176 @@
|
|||
// 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 gomiddleware
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
|
||||
"github.com/modelcontextprotocol/go-sdk/mcp"
|
||||
|
||||
"github.com/modelcontextprotocol/ext-interceptors/go/sdk/interceptors"
|
||||
"github.com/modelcontextprotocol/ext-interceptors/go/sdk/interceptors/chain"
|
||||
)
|
||||
|
||||
// Option configures the middleware.
|
||||
type Option func(*config)
|
||||
|
||||
type config struct {
|
||||
logger *slog.Logger
|
||||
contextProvider ContextProviderFunc
|
||||
}
|
||||
|
||||
// ContextProviderFunc extracts an InvocationContext from an incoming MCP
|
||||
// request. This is called once per intercepted request and the result is
|
||||
// passed to all interceptor handlers via the chain execution params.
|
||||
//
|
||||
// Typical use: extract principal identity from OAuth tokens available on
|
||||
// the request's session (via RequestExtra.TokenInfo).
|
||||
type ContextProviderFunc func(ctx context.Context, req mcp.Request) *interceptors.InvocationContext
|
||||
|
||||
// WithLogger sets the logger for the middleware.
|
||||
// If not set, slog.Default() is used.
|
||||
func WithLogger(l *slog.Logger) Option {
|
||||
return func(c *config) {
|
||||
c.logger = l
|
||||
}
|
||||
}
|
||||
|
||||
// WithContextProvider sets a function that populates InvocationContext
|
||||
// for every intercepted request. Without this, the context is nil.
|
||||
func WithContextProvider(f ContextProviderFunc) Option {
|
||||
return func(c *config) {
|
||||
c.contextProvider = f
|
||||
}
|
||||
}
|
||||
|
||||
// skipMethods are methods that should not be intercepted to prevent
|
||||
// recursion when the chain connects back to the same server, plus
|
||||
// lifecycle methods that don't need interception.
|
||||
var skipMethods = map[string]bool{
|
||||
"initialize": true,
|
||||
"notifications/initialized": true,
|
||||
"notifications/cancelled": true,
|
||||
interceptors.MethodList: true,
|
||||
interceptors.MethodInvoke: true,
|
||||
}
|
||||
|
||||
// Middleware creates an [mcp.Middleware] that intercepts incoming requests
|
||||
// and outgoing responses, running the interceptor chain for each.
|
||||
//
|
||||
// The middleware calls chain.Execute() which invokes interceptors via
|
||||
// interceptor/invoke RPCs. Install it on an [mcp.Server] via
|
||||
// [mcp.Server.AddReceivingMiddleware]:
|
||||
//
|
||||
// chain, _ := srv.LocalChain(ctx)
|
||||
// mcpServer.AddReceivingMiddleware(
|
||||
// gomiddleware.Middleware(chain, gomiddleware.WithLogger(logger)),
|
||||
// )
|
||||
func Middleware(ch *chain.Chain, opts ...Option) mcp.Middleware {
|
||||
cfg := &config{}
|
||||
for _, opt := range opts {
|
||||
opt(cfg)
|
||||
}
|
||||
if cfg.logger == nil {
|
||||
cfg.logger = slog.Default()
|
||||
}
|
||||
|
||||
return func(next mcp.MethodHandler) mcp.MethodHandler {
|
||||
return func(ctx context.Context, method string, req mcp.Request) (mcp.Result, error) {
|
||||
// Skip interceptor and lifecycle methods to prevent recursion.
|
||||
if skipMethods[method] {
|
||||
return next(ctx, method, req)
|
||||
}
|
||||
|
||||
event := method
|
||||
|
||||
// Extract invocation context from the request using the context provider, if set.
|
||||
var invCtx *interceptors.InvocationContext
|
||||
if cfg.contextProvider != nil {
|
||||
invCtx = cfg.contextProvider(ctx, req)
|
||||
}
|
||||
|
||||
// --- Request phase ---
|
||||
reqPayload, err := json.Marshal(req.GetParams())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
reqResult, err := ch.Execute(ctx, &chain.ExecutionParams{
|
||||
Event: event,
|
||||
Phase: interceptors.PhaseRequest,
|
||||
Payload: reqPayload,
|
||||
Context: invCtx,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if len(reqResult.AbortedAt) > 0 {
|
||||
logAborts(cfg.logger, "request", event, reqResult.AbortedAt)
|
||||
return nil, abortToJSONRPCError(reqResult.AbortedAt)
|
||||
}
|
||||
|
||||
// Apply mutated payload back to the request params if modified.
|
||||
if reqResult.FinalPayload != nil {
|
||||
if err := json.Unmarshal(reqResult.FinalPayload, req.GetParams()); err != nil {
|
||||
return nil, fmt.Errorf("interceptors: failed to apply mutated request payload: %w", err)
|
||||
}
|
||||
}
|
||||
|
||||
// Call the next handler.
|
||||
result, err := next(ctx, method, req)
|
||||
if err != nil {
|
||||
return result, err
|
||||
}
|
||||
|
||||
// Notification methods return nil result — skip response phase.
|
||||
if result == nil {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
// --- Response phase ---
|
||||
respPayload, err := json.Marshal(result)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("interceptors: failed to marshal response payload for interception: %w", err)
|
||||
}
|
||||
|
||||
respResult, err := ch.Execute(ctx, &chain.ExecutionParams{
|
||||
Event: event,
|
||||
Phase: interceptors.PhaseResponse,
|
||||
Payload: respPayload,
|
||||
Context: invCtx,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if len(respResult.AbortedAt) > 0 {
|
||||
logAborts(cfg.logger, "response", event, respResult.AbortedAt)
|
||||
return nil, abortToJSONRPCError(respResult.AbortedAt)
|
||||
}
|
||||
|
||||
// Apply mutated response payload if it was modified.
|
||||
if respResult.FinalPayload != nil {
|
||||
if err := json.Unmarshal(respResult.FinalPayload, result); err != nil {
|
||||
return nil, fmt.Errorf("interceptors: failed to apply mutated response payload: %w", err)
|
||||
}
|
||||
}
|
||||
|
||||
return result, nil
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// logAborts logs each abort entry at warn level.
|
||||
func logAborts(logger *slog.Logger, phase, event string, aborts []chain.AbortInfo) {
|
||||
for _, a := range aborts {
|
||||
logger.Warn("interceptors: "+phase+" aborted",
|
||||
"event", event,
|
||||
"interceptor", a.Interceptor,
|
||||
"reason", a.Reason,
|
||||
)
|
||||
}
|
||||
}
|
||||
344
go/sdk/interceptors/integrations/gomiddleware/middleware_test.go
Normal file
344
go/sdk/interceptors/integrations/gomiddleware/middleware_test.go
Normal file
|
|
@ -0,0 +1,344 @@
|
|||
package gomiddleware_test
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/modelcontextprotocol/go-sdk/mcp"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
|
||||
"github.com/modelcontextprotocol/ext-interceptors/go/sdk/interceptors"
|
||||
"github.com/modelcontextprotocol/ext-interceptors/go/sdk/interceptors/integrations/gomiddleware"
|
||||
"github.com/modelcontextprotocol/ext-interceptors/go/sdk/interceptors/mcpserver"
|
||||
)
|
||||
|
||||
// setup creates a test server with middleware installed and returns a connected client session.
|
||||
func setup(t *testing.T, is ...interceptors.Interceptor) *mcp.ClientSession {
|
||||
t.Helper()
|
||||
|
||||
mcpServer := mcp.NewServer(&mcp.Implementation{
|
||||
Name: "test-server",
|
||||
Version: "0.1.0",
|
||||
}, nil)
|
||||
|
||||
mcpServer.AddTool(&mcp.Tool{
|
||||
Name: "echo",
|
||||
Description: "echoes input",
|
||||
InputSchema: map[string]any{"type": "object"},
|
||||
}, func(_ context.Context, req *mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
return &mcp.CallToolResult{
|
||||
Content: []mcp.Content{&mcp.TextContent{Text: fmt.Sprintf("echo: %s", req.Params.Arguments)}},
|
||||
}, nil
|
||||
})
|
||||
|
||||
srv := mcpserver.NewServer(mcpServer)
|
||||
for _, i := range is {
|
||||
srv.AddInterceptor(i)
|
||||
}
|
||||
|
||||
// Create chain via LocalChain (in-memory transport).
|
||||
chain, err := srv.LocalChain(context.Background())
|
||||
require.NoError(t, err)
|
||||
|
||||
// Install the middleware.
|
||||
mcpServer.AddReceivingMiddleware(gomiddleware.Middleware(chain))
|
||||
|
||||
handler := mcpserver.NewStreamableHTTPHandler(srv, nil)
|
||||
httpServer := httptest.NewServer(handler)
|
||||
t.Cleanup(httpServer.Close)
|
||||
|
||||
client := mcp.NewClient(&mcp.Implementation{Name: "test-client", Version: "0.1.0"}, nil)
|
||||
cs, err := client.Connect(context.Background(), &mcp.StreamableClientTransport{
|
||||
Endpoint: httpServer.URL,
|
||||
}, nil)
|
||||
require.NoError(t, err)
|
||||
t.Cleanup(func() { cs.Close() })
|
||||
|
||||
return cs
|
||||
}
|
||||
|
||||
func resultText(t *testing.T, result *mcp.CallToolResult) string {
|
||||
t.Helper()
|
||||
require.NotEmpty(t, result.Content)
|
||||
tc, ok := result.Content[0].(*mcp.TextContent)
|
||||
require.True(t, ok, "expected TextContent, got %T", result.Content[0])
|
||||
return tc.Text
|
||||
}
|
||||
|
||||
func TestMiddlewareBlocksOnValidationError(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
blocker := &interceptors.Validator{
|
||||
Metadata: interceptors.Metadata{
|
||||
Name: "block-echo",
|
||||
Hook: interceptors.Hook{
|
||||
Events: []string{interceptors.EventToolsCall},
|
||||
Phase: interceptors.PhaseRequest,
|
||||
},
|
||||
Mode: interceptors.ModeEnforce,
|
||||
},
|
||||
Handler: func(_ context.Context, inv *interceptors.Invocation) (*interceptors.ValidationResult, error) {
|
||||
raw, ok := inv.Payload.(json.RawMessage)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("unexpected type %T", inv.Payload)
|
||||
}
|
||||
var params struct {
|
||||
Name string `json:"name"`
|
||||
}
|
||||
if err := json.Unmarshal(raw, ¶ms); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if params.Name == "echo" {
|
||||
return &interceptors.ValidationResult{
|
||||
Valid: false,
|
||||
Messages: []interceptors.ValidationMessage{
|
||||
{Message: "echo is blocked", Severity: interceptors.SeverityError},
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
return &interceptors.ValidationResult{Valid: true}, nil
|
||||
},
|
||||
}
|
||||
|
||||
cs := setup(t, blocker)
|
||||
|
||||
_, err := cs.CallTool(context.Background(), &mcp.CallToolParams{
|
||||
Name: "echo",
|
||||
Arguments: map[string]any{"text": "hello"},
|
||||
})
|
||||
assert.Error(t, err)
|
||||
}
|
||||
|
||||
func TestMiddlewarePassesOnSuccess(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
allow := &interceptors.Validator{
|
||||
Metadata: interceptors.Metadata{
|
||||
Name: "allow-all",
|
||||
Hook: interceptors.Hook{
|
||||
Events: []string{interceptors.EventToolsCall},
|
||||
Phase: interceptors.PhaseRequest,
|
||||
},
|
||||
Mode: interceptors.ModeEnforce,
|
||||
},
|
||||
Handler: func(_ context.Context, _ *interceptors.Invocation) (*interceptors.ValidationResult, error) {
|
||||
return &interceptors.ValidationResult{Valid: true}, nil
|
||||
},
|
||||
}
|
||||
|
||||
cs := setup(t, allow)
|
||||
|
||||
result, err := cs.CallTool(context.Background(), &mcp.CallToolParams{
|
||||
Name: "echo",
|
||||
Arguments: map[string]any{"text": "hello"},
|
||||
})
|
||||
require.NoError(t, err)
|
||||
assert.True(t, strings.HasPrefix(resultText(t, result), "echo:"))
|
||||
}
|
||||
|
||||
func TestMiddlewareMutatesPayload(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
mutator := &interceptors.Mutator{
|
||||
Metadata: interceptors.Metadata{
|
||||
Name: "add-prefix",
|
||||
Hook: interceptors.Hook{
|
||||
Events: []string{interceptors.EventToolsCall},
|
||||
Phase: interceptors.PhaseResponse,
|
||||
},
|
||||
Mode: interceptors.ModeEnforce,
|
||||
},
|
||||
Handler: func(_ context.Context, inv *interceptors.Invocation) (*interceptors.MutationResult, error) {
|
||||
raw, ok := inv.Payload.(json.RawMessage)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("unexpected type %T", inv.Payload)
|
||||
}
|
||||
var result mcp.CallToolResult
|
||||
if err := json.Unmarshal(raw, &result); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for _, c := range result.Content {
|
||||
if tc, ok := c.(*mcp.TextContent); ok {
|
||||
tc.Text = "[mutated] " + tc.Text
|
||||
}
|
||||
}
|
||||
data, err := json.Marshal(&result)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &interceptors.MutationResult{Modified: true, Payload: json.RawMessage(data)}, nil
|
||||
},
|
||||
}
|
||||
|
||||
cs := setup(t, mutator)
|
||||
|
||||
result, err := cs.CallTool(context.Background(), &mcp.CallToolParams{
|
||||
Name: "echo",
|
||||
Arguments: map[string]any{"text": "hello"},
|
||||
})
|
||||
require.NoError(t, err)
|
||||
assert.True(t, strings.HasPrefix(resultText(t, result), "[mutated] echo:"))
|
||||
}
|
||||
|
||||
func TestMiddlewareAuditModeNonBlocking(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
// Audit-mode validator returns Valid=false but should NOT block the request.
|
||||
auditValidator := &interceptors.Validator{
|
||||
Metadata: interceptors.Metadata{
|
||||
Name: "audit-reject",
|
||||
Hook: interceptors.Hook{
|
||||
Events: []string{interceptors.EventToolsCall},
|
||||
Phase: interceptors.PhaseRequest,
|
||||
},
|
||||
Mode: interceptors.ModeAudit,
|
||||
},
|
||||
Handler: func(_ context.Context, _ *interceptors.Invocation) (*interceptors.ValidationResult, error) {
|
||||
return &interceptors.ValidationResult{
|
||||
Valid: false,
|
||||
Messages: []interceptors.ValidationMessage{
|
||||
{Message: "would reject", Severity: interceptors.SeverityError},
|
||||
},
|
||||
}, nil
|
||||
},
|
||||
}
|
||||
|
||||
cs := setup(t, auditValidator)
|
||||
|
||||
result, err := cs.CallTool(context.Background(), &mcp.CallToolParams{
|
||||
Name: "echo",
|
||||
Arguments: map[string]any{"text": "hello"},
|
||||
})
|
||||
require.NoError(t, err)
|
||||
assert.True(t, strings.HasPrefix(resultText(t, result), "echo:"))
|
||||
}
|
||||
|
||||
func TestMiddlewareWithContextProvider(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
// Validator that checks the invocation context for a principal.
|
||||
principalCheck := &interceptors.Validator{
|
||||
Metadata: interceptors.Metadata{
|
||||
Name: "check-principal",
|
||||
Hook: interceptors.Hook{
|
||||
Events: []string{interceptors.EventToolsCall},
|
||||
Phase: interceptors.PhaseRequest,
|
||||
},
|
||||
Mode: interceptors.ModeEnforce,
|
||||
},
|
||||
Handler: func(_ context.Context, inv *interceptors.Invocation) (*interceptors.ValidationResult, error) {
|
||||
if inv.Context == nil || inv.Context.Principal == nil || inv.Context.Principal.ID != "test-user" {
|
||||
return &interceptors.ValidationResult{
|
||||
Valid: false,
|
||||
Messages: []interceptors.ValidationMessage{
|
||||
{Message: "missing or invalid principal", Severity: interceptors.SeverityError},
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
return &interceptors.ValidationResult{Valid: true}, nil
|
||||
},
|
||||
}
|
||||
|
||||
// Setup with context provider.
|
||||
mcpServer := mcp.NewServer(&mcp.Implementation{
|
||||
Name: "test-server",
|
||||
Version: "0.1.0",
|
||||
}, nil)
|
||||
|
||||
mcpServer.AddTool(&mcp.Tool{
|
||||
Name: "echo",
|
||||
Description: "echoes input",
|
||||
InputSchema: map[string]any{"type": "object"},
|
||||
}, func(_ context.Context, req *mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
||||
return &mcp.CallToolResult{
|
||||
Content: []mcp.Content{&mcp.TextContent{Text: fmt.Sprintf("echo: %s", req.Params.Arguments)}},
|
||||
}, nil
|
||||
})
|
||||
|
||||
srv := mcpserver.NewServer(mcpServer)
|
||||
srv.AddInterceptor(principalCheck)
|
||||
|
||||
chain, err := srv.LocalChain(context.Background())
|
||||
require.NoError(t, err)
|
||||
|
||||
mcpServer.AddReceivingMiddleware(gomiddleware.Middleware(chain,
|
||||
gomiddleware.WithContextProvider(func(_ context.Context, _ mcp.Request) *interceptors.InvocationContext {
|
||||
return &interceptors.InvocationContext{
|
||||
Principal: &interceptors.Principal{
|
||||
Type: "user",
|
||||
ID: "test-user",
|
||||
},
|
||||
}
|
||||
}),
|
||||
))
|
||||
|
||||
handler := mcpserver.NewStreamableHTTPHandler(srv, nil)
|
||||
httpServer := httptest.NewServer(handler)
|
||||
t.Cleanup(httpServer.Close)
|
||||
|
||||
client := mcp.NewClient(&mcp.Implementation{Name: "test-client", Version: "0.1.0"}, nil)
|
||||
cs, err := client.Connect(context.Background(), &mcp.StreamableClientTransport{
|
||||
Endpoint: httpServer.URL,
|
||||
}, nil)
|
||||
require.NoError(t, err)
|
||||
t.Cleanup(func() { cs.Close() })
|
||||
|
||||
result, err := cs.CallTool(context.Background(), &mcp.CallToolParams{
|
||||
Name: "echo",
|
||||
Arguments: map[string]any{"text": "hello"},
|
||||
})
|
||||
require.NoError(t, err)
|
||||
assert.True(t, strings.HasPrefix(resultText(t, result), "echo:"))
|
||||
}
|
||||
|
||||
func TestMiddlewareRequestMutatorModifiesArgs(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
// Request mutator that adds a field to the arguments.
|
||||
reqMutator := &interceptors.Mutator{
|
||||
Metadata: interceptors.Metadata{
|
||||
Name: "inject-field",
|
||||
Hook: interceptors.Hook{
|
||||
Events: []string{interceptors.EventToolsCall},
|
||||
Phase: interceptors.PhaseRequest,
|
||||
},
|
||||
Mode: interceptors.ModeEnforce,
|
||||
},
|
||||
Handler: func(_ context.Context, inv *interceptors.Invocation) (*interceptors.MutationResult, error) {
|
||||
raw, ok := inv.Payload.(json.RawMessage)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("unexpected type %T", inv.Payload)
|
||||
}
|
||||
var params map[string]any
|
||||
if err := json.Unmarshal(raw, ¶ms); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
args, _ := params["arguments"].(map[string]any)
|
||||
if args == nil {
|
||||
args = map[string]any{}
|
||||
}
|
||||
args["injected"] = "yes"
|
||||
params["arguments"] = args
|
||||
data, err := json.Marshal(params)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &interceptors.MutationResult{Modified: true, Payload: json.RawMessage(data)}, nil
|
||||
},
|
||||
}
|
||||
|
||||
cs := setup(t, reqMutator)
|
||||
|
||||
result, err := cs.CallTool(context.Background(), &mcp.CallToolParams{
|
||||
Name: "echo",
|
||||
Arguments: map[string]any{"text": "hello"},
|
||||
})
|
||||
require.NoError(t, err)
|
||||
text := resultText(t, result)
|
||||
assert.Contains(t, text, "injected")
|
||||
}
|
||||
Loading…
Reference in a new issue