Agent Mesh
Go a2aa2a-protocolagent-meshagentic-aiinferencemcpmeshmesh-networknetwork-securitynetworking-aip2p-network
mcp dumb pipe so we are agnostic of the protocol versions
Antonio Ojea91b01def2af9
diff --git a/cmd/sam-node/gate.go b/cmd/sam-node/gate.goindex ff43b990..4bf7e82b 100644--- a/cmd/sam-node/gate.go+++ b/cmd/sam-node/gate.go@@ -18,7 +18,6 @@ import ("context""fmt"- "github.com/google/sam/api""github.com/libp2p/go-libp2p/core/connmgr""github.com/libp2p/go-libp2p/core/control""github.com/libp2p/go-libp2p/core/network"@@ -71,62 +70,58 @@ func (g *nodeConnGate) InterceptSecured(dir network.Direction, p peer.ID, n netw}// HandleMCPStream is the libp2p stream handler for the MCP protocol.-// It assumes the stream is fully authenticated by the middleware.-func (n *SamNode) HandleMCPStream(s network.Stream) {+// It routes the authenticated stream to the appropriate backend service,+// or serves the internal MCP catalog if the TargetService is empty/catalog.+func (n *SamNode) HandleMCPStream(s network.Stream, reqCtx RequestContext) {+ // If the TargetService is for a registered local backend, dumb-pipe proxy to it.+ target := reqCtx.Target+ if target != "" && target != "/sam/catalog" {+ svc, ok := n.services.Get(target)+ if ok {+ mcpSvc, isMcp := svc.(*MCPService)+ if isMcp {+ mcpSvc.HandleStreamPassThrough(s)+ return+ }+ }+ // If service not found or not an MCPService, we fall through or close it.+ // For now, close the stream if target is invalid.+ logger.Warnf("[MCP] Client requested unknown target service %q, closing stream", target)+ _ = s.Reset()+ return+ }++ // Target is catalog/internal tools. We spin up an MCP server for these local mesh tools.defer func() {if err := s.Close(); err != nil {- fmt.Printf("Failed to close MCP stream: %v\n", err)+ logger.Debugf("[MCP] Failed to close MCP stream: %v", err)}}()- // Handoff to SDK using custom transporttransport := NewStreamTransport(s)server := mcp.NewServer(&mcp.Implementation{- Name: "sam-node-mcp",+ Name: "sam-node-catalog",Version: "0.1.0",}, nil)- // Add the send_message tool.mcp.AddTool(server, &mcp.Tool{Name: "send_message",Description: "Send a message to another agent in the mesh",}, n.handleSendMessage)- // Add list_local_services toolmcp.AddTool(server, &mcp.Tool{Name: "list_local_services",Description: "List services registered on the local node. Optionally filter by type.",}, n.handleListLocalServices)- // Add the get_mesh_info tool.mcp.AddTool(server, &mcp.Tool{Name: "get_mesh_info",Description: "Get information about the mesh network",}, n.handleGetMeshInfo)- // Add the describe_local_tool tool.- mcp.AddTool(server, &mcp.Tool{- Name: "describe_local_tool",- Description: "Return the description, input schema, and output schema for a named aggregated tool on this node.",- }, n.handleDescribeLocalTool)-- // Register aggregated hosted-service tools from MCP services.- infos := n.services.List(api.ServiceType_SERVICE_TYPE_MCP)- for _, info := range infos {- svc, ok := n.services.Get(info.Name)- if !ok {- continue- }- mcpSvc, ok := svc.(*MCPService)- if !ok {- continue- }- mcpSvc.RegisterAggregatedTools(server)- }-ctx := context.Background()if err := server.Run(ctx, transport); err != nil {- fmt.Printf("MCP server error on stream from %s: %v\n", s.Conn().RemotePeer(), err)+ logger.Errorf("[MCP] Catalog server error on stream from %s: %v", s.Conn().RemotePeer(), err)}}func (g *nodeConnGate) InterceptUpgraded(n network.Conn) (allow bool, cc control.DisconnectReason) {diff --git a/cmd/sam-node/gate_test.go b/cmd/sam-node/gate_test.goindex d00a899b..25a0241a 100644--- a/cmd/sam-node/gate_test.go+++ b/cmd/sam-node/gate_test.go@@ -139,7 +139,7 @@ func startBareNode(t *testing.T, ctx context.Context) (*SamNode, func()) {const testMCPProtocol = protocol.ID("/sam-test/mcp/1.0.0")-func TestHandleMCPStream_RegistersAggregatedTools(t *testing.T) {+func TestHandleMCPStream_DumbPipeProxy(t *testing.T) {ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)defer cancel()@@ -167,7 +167,9 @@ func TestHandleMCPStream_RegistersAggregatedTools(t *testing.T) {t.Cleanup(func() { _ = svc.Teardown() })// Bypass biscuit auth by exposing HandleMCPStream on a test-only protocol.- nodeA.Host.SetStreamHandler(testMCPProtocol, nodeA.HandleMCPStream)+ nodeA.Host.SetStreamHandler(testMCPProtocol, func(s network.Stream) {+ nodeA.HandleMCPStream(s, RequestContext{Target: "code-reviewer"})+ })if err := nodeB.Host.Connect(ctx, peer.AddrInfo{ID: nodeA.Host.ID(), Addrs: nodeA.Host.Addrs()}); err != nil {t.Fatalf("connect: %v", err)@@ -197,26 +199,21 @@ func TestHandleMCPStream_RegistersAggregatedTools(t *testing.T) {}found := falsefor _, n := range names {- if n == "code-reviewer.review_pr" {+ if n == "review_pr" {found = truebreak}}if !found {- t.Errorf("expected tools/list to include %q; got %v", "code-reviewer.review_pr", names)+ t.Errorf("expected tools/list to include %q; got %v", "review_pr", names)}- // Sanity: at least one infra tool is still present.- infraFound := false+ // Dumb pipe: infra tools are NOT present.for _, n := range names {if n == "send_message" {- infraFound = true- break+ t.Errorf("expected infra tool send_message to be absent in dumb pipe; got %v", names)}}- if !infraFound {- t.Errorf("expected infra tool send_message to be present; got %v", names)- }}func TestHandleMCPStream_ForwarderRoutesCalls(t *testing.T) {@@ -244,7 +241,9 @@ func TestHandleMCPStream_ForwarderRoutesCalls(t *testing.T) {nodeA.services.insertService(svc)t.Cleanup(func() { _ = svc.Teardown() })- nodeA.Host.SetStreamHandler(testMCPProtocol, nodeA.HandleMCPStream)+ nodeA.Host.SetStreamHandler(testMCPProtocol, func(s network.Stream) {+ nodeA.HandleMCPStream(s, RequestContext{Target: "svc"})+ })if err := nodeB.Host.Connect(ctx, peer.AddrInfo{ID: nodeA.Host.ID(), Addrs: nodeA.Host.Addrs()}); err != nil {t.Fatalf("connect: %v", err)@@ -264,7 +263,7 @@ func TestHandleMCPStream_ForwarderRoutesCalls(t *testing.T) {defer func() { _ = session.Close() }()res, err := session.CallTool(ctx, &mcp.CallToolParams{- Name: "svc.echo",+ Name: "echo",Arguments: map[string]any{"unused": true},})if err != nil {diff --git a/cmd/sam-node/mcp.go b/cmd/sam-node/mcp.goindex 32adf2e9..36edc45a 100644--- a/cmd/sam-node/mcp.go+++ b/cmd/sam-node/mcp.go@@ -197,9 +197,11 @@ func (n *SamNode) callMCPToolOnce(ctx context.Context, targetPeer peer.ID, toolN}// Extract target service if it's a federated tool call (service.tool)- targetService := toolName+ targetService := "/sam/catalog"+ originalToolName := toolNameif parts := strings.SplitN(toolName, ".", 2); len(parts) == 2 {targetService = parts[0]+ originalToolName = parts[1]}// Marshal AuthFrame@@ -253,7 +255,7 @@ func (n *SamNode) callMCPToolOnce(ctx context.Context, targetPeer peer.ID, toolN// We don't need to marshall the params, the SDK takes care of it// Passing pre-marshaled []byte triggers encoding/json's base64 which gets rejectedcallParams := &mcp.CallToolParams{- Name: toolName,+ Name: originalToolName,Arguments: params,}diff --git a/cmd/sam-node/mcp_handlers.go b/cmd/sam-node/mcp_handlers.goindex 4bd418dd..2c78381d 100644--- a/cmd/sam-node/mcp_handlers.go+++ b/cmd/sam-node/mcp_handlers.go@@ -322,59 +322,75 @@ func (n *SamNode) handleFindRemoteTools(ctx context.Context, req *mcp.CallToolRe}, nil, nil}-// fetchRemoteToolCatalogue opens a libp2p MCP stream to the target peer-// (with the same auth handshake callMCPToolOnce uses), calls tools/list,-// and returns the result.+// fetchRemoteToolCatalogue gets the remote node's service catalogue,+// then opens a separate libp2p stream to each MCP service to fetch its tools.func (n *SamNode) fetchRemoteToolCatalogue(ctx context.Context, targetPeer peer.ID) ([]*mcp.Tool, error) {- s, err := n.Host.NewStream(ctx, targetPeer, api.MCPProtocolID)+ services, err := n.fetchRemoteServiceCatalog(ctx, targetPeer, "MCP")if err != nil {- return nil, fmt.Errorf("open stream: %w", err)+ return nil, fmt.Errorf("fetch remote service catalog: %w", err)}- defer func() {- _ = s.Close()- }()+ var allTools []*mcp.ToolbiscuitBytes, err := n.Store.LoadIdentity()if err != nil {return nil, fmt.Errorf("load identity: %w", err)}- authFrame := api.AuthFrame{Biscuit: biscuitBytes}- authBytes, _ := proto.Marshal(&authFrame)- writer := msgio.NewVarintWriter(s)- if err := writer.WriteMsg(authBytes); err != nil {- return nil, fmt.Errorf("write auth frame: %w", err)- }+ for _, svc := range services {+ if svc.Type != api.ServiceType_SERVICE_TYPE_MCP {+ continue+ }- // TODO: Consider increasing this to 1MB to allocate large MCP tool catalogues- reader := msgio.NewVarintReaderSize(s, 1024*64)- respMsg, err := reader.ReadMsg()- if err != nil {- return nil, fmt.Errorf("read auth response: %w", err)- }- defer reader.ReleaseMsg(respMsg)+ s, err := n.Host.NewStream(ctx, targetPeer, api.MCPProtocolID)+ if err != nil {+ logger.Debugf("Failed to open stream for service %s: %v", svc.Name, err)+ continue+ }- var resp api.AuthResponse- if err := proto.Unmarshal(respMsg, &resp); err != nil {- return nil, fmt.Errorf("parse auth response: %w", err)- }- if !resp.Success {- return nil, fmt.Errorf("auth rejected by %s: %s", targetPeer, resp.Error)- }+ authFrame := api.AuthFrame{Biscuit: biscuitBytes, TargetService: svc.Name}+ authBytes, _ := proto.Marshal(&authFrame)- transport := NewStreamTransport(s)- client := mcp.NewClient(&mcp.Implementation{Name: "sam-node-find", Version: "0.1.0"}, nil)- session, err := client.Connect(ctx, transport, nil)- if err != nil {- return nil, fmt.Errorf("mcp connect: %w", err)- }- defer func() { _ = session.Close() }()+ writer := msgio.NewVarintWriter(s)+ if err := writer.WriteMsg(authBytes); err != nil {+ _ = s.Close()+ continue+ }- listRes, err := session.ListTools(ctx, nil)- if err != nil {- return nil, fmt.Errorf("list tools: %w", err)+ reader := msgio.NewVarintReaderSize(s, 1024*64)+ respMsg, err := reader.ReadMsg()+ if err != nil {+ _ = s.Close()+ continue+ }+ defer reader.ReleaseMsg(respMsg)++ var resp api.AuthResponse+ if err := proto.Unmarshal(respMsg, &resp); err != nil || !resp.Success {+ _ = s.Close()+ continue+ }++ transport := NewStreamTransport(s)+ client := mcp.NewClient(&mcp.Implementation{Name: "sam-node-find", Version: "0.1.0"}, nil)+ session, err := client.Connect(ctx, transport, nil)+ if err != nil {+ _ = s.Close()+ continue+ }++ listRes, err := session.ListTools(ctx, nil)+ if err == nil {+ for _, t := range listRes.Tools {+ t.Name = svc.Name + "." + t.Name+ allTools = append(allTools, t)+ }+ }++ _ = session.Close()+ _ = s.Close()}- return listRes.Tools, nil++ return allTools, nil}// appendFilteredRows appends rows for tools that have a namespaced name@@ -452,55 +468,6 @@ type remoteToolDescription struct {OutputSchema any `json:"output_schema,omitempty"`}-// DescribeLocalToolParams defines parameters for the describe_local_tool-// peer-facing infra tool.-type DescribeLocalToolParams struct {- ToolName string `json:"tool_name" jsonschema:"Namespaced tool name (e.g. 'code-reviewer.review_pr'). Required."`-}--// handleDescribeLocalTool implements the describe_local_tool peer-facing-// infra tool. It scans MCP-typed services in the registry for an aggregated-// tool whose namespaced Name matches params.ToolName and returns its-// description + schemas as JSON in a TextContent.-//-// Errors: empty tool name → invalid argument; no match → "tool not found".-// Both surface to the caller as MCP errors.-func (n *SamNode) handleDescribeLocalTool(ctx context.Context, req *mcp.CallToolRequest, params DescribeLocalToolParams) (*mcp.CallToolResult, any, error) {- if params.ToolName == "" {- return nil, nil, fmt.Errorf("tool_name is required")- }- svcInfos := n.services.List(api.ServiceType_SERVICE_TYPE_MCP)- for _, info := range svcInfos {- svc, ok := n.services.Get(info.Name)- if !ok {- continue- }- mcpSvc, ok := svc.(*MCPService)- if !ok {- continue- }- for _, tool := range mcpSvc.Tools() {- if tool == nil || tool.Name != params.ToolName {- continue- }- payload := remoteToolDescription{- ToolName: tool.Name,- Description: tool.Description,- InputSchema: tool.InputSchema,- OutputSchema: tool.OutputSchema,- }- body, err := json.Marshal(payload)- if err != nil {- return nil, nil, fmt.Errorf("marshal description: %w", err)- }- return &mcp.CallToolResult{- Content: []mcp.Content{&mcp.TextContent{Text: string(body)}},- }, nil, nil- }- }- return nil, nil, fmt.Errorf("tool not found: %s", params.ToolName)-}-// DescribeRemoteToolParams defines parameters for the describe_remote_tool// sidecar tool.type DescribeRemoteToolParams struct {@@ -508,14 +475,7 @@ type DescribeRemoteToolParams struct {ToolName string `json:"tool_name" jsonschema:"Namespaced tool name as returned by find_remote_tools (e.g. 'code-reviewer.review_pr'). Required."`}-// handleDescribeRemoteTool implements the describe_remote_tool sidecar-// tool: validate inputs, open a libp2p MCP stream to the peer, call its-// describe_local_tool, decorate the response with peer_id, and return.-//-// Validation: peer_id and tool_name must both be set; peer_id cannot equal-// this node's own peer ID; tool_name must contain "." (describe_remote_tool-// is for namespaced aggregated tools only); peer_id must parse as a libp2p-// peer.ID.+// handleDescribeRemoteTool implements the describe_remote_tool client-facing tool.func (n *SamNode) handleDescribeRemoteTool(ctx context.Context, req *mcp.CallToolRequest, params DescribeRemoteToolParams) (*mcp.CallToolResult, any, error) {if params.PeerID == "" {return nil, nil, fmt.Errorf("peer_id is required")@@ -523,59 +483,81 @@ func (n *SamNode) handleDescribeRemoteTool(ctx context.Context, req *mcp.CallTooif params.ToolName == "" {return nil, nil, fmt.Errorf("tool_name is required")}- if !strings.Contains(params.ToolName, ".") {- return nil, nil, fmt.Errorf("tool_name %q must be namespaced (contain '.'); describe_remote_tool is for aggregated tools only", params.ToolName)++ pid, err := peer.Decode(params.PeerID)+ if err != nil {+ return nil, nil, fmt.Errorf("invalid peer_id: %w", err)}- selfID := n.Host.ID().String()- if params.PeerID == selfID {- return nil, nil, fmt.Errorf("peer_id %q is this node; cross-mesh describe cannot target self", params.PeerID)++ parts := strings.SplitN(params.ToolName, ".", 2)+ if len(parts) != 2 {+ return nil, nil, fmt.Errorf("invalid tool_name format, expected 'service.tool'")}- targetPeer, err := peer.Decode(params.PeerID)+ serviceName := parts[0]+ actualToolName := parts[1]++ biscuitBytes, err := n.Store.LoadIdentity()if err != nil {- return nil, nil, fmt.Errorf("invalid peer_id %q: %w", params.PeerID, err)+ return nil, nil, err}- res, err := n.CallMCPTool(ctx, targetPeer, "describe_local_tool", DescribeLocalToolParams{- ToolName: params.ToolName,- })+ s, err := n.Host.NewStream(ctx, pid, api.MCPProtocolID)if err != nil {- return nil, nil, fmt.Errorf("describe_local_tool on %s: %w", targetPeer, err)- }- if res == nil {- return nil, nil, fmt.Errorf("nil response from %s", targetPeer)- }- // The Go SDK packs handler-returned errors into CallToolResult.IsError- // rather than propagating them as Go errors from session.CallTool. Check- // IsError before the empty-content guard so an errored response with no- // body still surfaces as a describe_local_tool error rather than an- // ambiguous "empty response".- if res.IsError {- errText := "(no detail)"- if len(res.Content) > 0 {- if tc, ok := res.Content[0].(*mcp.TextContent); ok && tc.Text != "" {- errText = tc.Text- }- }- return nil, nil, fmt.Errorf("describe_local_tool on %s: %s", targetPeer, errText)+ return nil, nil, fmt.Errorf("open stream: %w", err)}- if len(res.Content) == 0 {- return nil, nil, fmt.Errorf("empty response from %s", targetPeer)+ defer func() { _ = s.Close() }()++ authFrame := api.AuthFrame{Biscuit: biscuitBytes, TargetService: serviceName}+ authBytes, _ := proto.Marshal(&authFrame)++ writer := msgio.NewVarintWriter(s)+ if err := writer.WriteMsg(authBytes); err != nil {+ return nil, nil, err}- tc, ok := res.Content[0].(*mcp.TextContent)- if !ok {- return nil, nil, fmt.Errorf("unexpected content type from %s: %T", targetPeer, res.Content[0])++ reader := msgio.NewVarintReaderSize(s, 1024*64)+ respMsg, err := reader.ReadMsg()+ if err != nil {+ return nil, nil, err}- var remoteToolDesc remoteToolDescription- if err := json.Unmarshal([]byte(tc.Text), &remoteToolDesc); err != nil {- return nil, nil, fmt.Errorf("parse describe response from %s: %w", targetPeer, err)+ defer reader.ReleaseMsg(respMsg)++ var authResp api.AuthResponse+ if err := proto.Unmarshal(respMsg, &authResp); err != nil || !authResp.Success {+ return nil, nil, fmt.Errorf("auth rejected")}- remoteToolDesc.PeerID = params.PeerID- mRemoteToolDesc, err := json.Marshal(remoteToolDesc)+ transport := NewStreamTransport(s)+ client := mcp.NewClient(&mcp.Implementation{Name: "sam-node-describe", Version: "0.1.0"}, nil)+ session, err := client.Connect(ctx, transport, nil)if err != nil {- return nil, nil, fmt.Errorf("marshal description: %w", err)+ return nil, nil, err}- return &mcp.CallToolResult{- Content: []mcp.Content{&mcp.TextContent{Text: string(mRemoteToolDesc)}},- }, nil, nil+ defer func() { _ = session.Close() }()++ listRes, err := session.ListTools(ctx, nil)+ if err != nil {+ return nil, nil, err+ }++ for _, t := range listRes.Tools {+ if t.Name == actualToolName {+ payload := remoteToolDescription{+ PeerID: pid.String(),+ ToolName: params.ToolName,+ Description: t.Description,+ InputSchema: t.InputSchema,+ OutputSchema: t.OutputSchema,+ }+ data, err := json.Marshal(payload)+ if err != nil {+ return nil, nil, err+ }+ return &mcp.CallToolResult{+ Content: []mcp.Content{&mcp.TextContent{Text: string(data)}},+ }, nil, nil+ }+ }++ return nil, nil, fmt.Errorf("tool not found on peer")}diff --git a/cmd/sam-node/mcp_handlers_test.go b/cmd/sam-node/mcp_handlers_test.goindex f118bc73..998e0ad1 100644--- a/cmd/sam-node/mcp_handlers_test.go+++ b/cmd/sam-node/mcp_handlers_test.go@@ -6,7 +6,8 @@ import ("crypto/ed25519""crypto/rand""encoding/json"- "fmt"++ "net/http""net/http/httptest""strings""testing"@@ -464,115 +465,6 @@ func TestNewMCPHandler_RegistersFindRemoteTools(t *testing.T) {}}-func TestHandleDescribeLocalTool_HappyPath(t *testing.T) {- ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)- defer cancel()-- tools := []*mcp.Tool{- {- Name: "review_pr",- Description: "Run a code review",- InputSchema: map[string]any{"type": "object", "properties": map[string]any{"pr_url": map[string]any{"type": "string"}}, "required": []any{"pr_url"}},- OutputSchema: map[string]any{"type": "object", "properties": map[string]any{"summary": map[string]any{"type": "string"}}},- },- }- upstream := httptest.NewServer(newFakeMCPHandler(t, tools))- defer upstream.Close()-- node, cleanup := startBareNode(t, ctx)- defer cleanup()-- svc := &MCPService{baseService: baseService{- info: &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: "code-reviewer"},- backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: upstream.URL},- }}- if err := svc.Init(ctx); err != nil {- t.Fatalf("MCPService.Init: %v", err)- }- node.services.insertService(svc)- t.Cleanup(func() { _ = svc.Teardown() })-- res, _, err := node.handleDescribeLocalTool(ctx, &mcp.CallToolRequest{}, DescribeLocalToolParams{- ToolName: "code-reviewer.review_pr",- })- if err != nil {- t.Fatalf("handleDescribeLocalTool: %v", err)- }- if len(res.Content) == 0 {- t.Fatal("expected non-empty Content")- }- tc, ok := res.Content[0].(*mcp.TextContent)- if !ok {- t.Fatalf("expected TextContent, got %T", res.Content[0])- }- var desc remoteToolDescription- if err := json.Unmarshal([]byte(tc.Text), &desc); err != nil {- t.Fatalf("response not JSON: %v (text: %q)", err, tc.Text)- }- if desc.ToolName != "code-reviewer.review_pr" {- t.Errorf("ToolName = %q, want %q", desc.ToolName, "code-reviewer.review_pr")- }- if desc.Description != "Run a code review" {- t.Errorf("Description = %q, want %q", desc.Description, "Run a code review")- }- if desc.InputSchema == nil {- t.Error("InputSchema is nil; expected the schema declared on the tool")- }- if desc.OutputSchema == nil {- t.Error("OutputSchema is nil; expected the schema declared on the tool")- }- if desc.PeerID != "" {- t.Errorf("PeerID should be empty on the peer-side payload, got %q", desc.PeerID)- }-}--func TestHandleDescribeLocalTool_NotFound(t *testing.T) {- ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)- defer cancel()-- tools := []*mcp.Tool{- {Name: "review_pr", Description: "x", InputSchema: map[string]any{"type": "object"}},- }- upstream := httptest.NewServer(newFakeMCPHandler(t, tools))- defer upstream.Close()-- node, cleanup := startBareNode(t, ctx)- defer cleanup()-- svc := &MCPService{baseService: baseService{- info: &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: "code-reviewer"},- backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: upstream.URL},- }}- if err := svc.Init(ctx); err != nil {- t.Fatalf("MCPService.Init: %v", err)- }- node.services.insertService(svc)- t.Cleanup(func() { _ = svc.Teardown() })-- _, _, err := node.handleDescribeLocalTool(ctx, &mcp.CallToolRequest{}, DescribeLocalToolParams{- ToolName: "code-reviewer.does-not-exist",- })- if err == nil {- t.Fatal("expected error for unknown tool")- }- if !strings.Contains(err.Error(), "tool not found") {- t.Errorf("error %q does not mention 'tool not found'", err.Error())- }-}--func TestHandleDescribeLocalTool_EmptyToolName(t *testing.T) {- ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)- defer cancel()-- node, cleanup := startBareNode(t, ctx)- defer cleanup()-- _, _, err := node.handleDescribeLocalTool(ctx, &mcp.CallToolRequest{}, DescribeLocalToolParams{})- if err == nil {- t.Fatal("expected error for empty tool_name")- }-}-func TestHandleDescribeRemoteTool_EmptyPeerID(t *testing.T) {ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)defer cancel()@@ -611,13 +503,13 @@ func TestHandleDescribeRemoteTool_NonNamespacedRejected(t *testing.T) {defer cleanup()_, _, err := node.handleDescribeRemoteTool(ctx, &mcp.CallToolRequest{}, DescribeRemoteToolParams{- PeerID: "12D3KooWFakePeerID",+ PeerID: node.Host.ID().String(),ToolName: "send_message", // no dot})if err == nil {t.Fatal("expected error for tool_name without '.'")}- if !strings.Contains(err.Error(), "namespaced") {+ if !strings.Contains(err.Error(), "service.tool") {t.Errorf("error %q does not explain the namespacing requirement", err.Error())}}@@ -794,13 +686,9 @@ func TestHandleDescribeRemoteTool_RoundTrip_UnknownTool(t *testing.T) {if err == nil {t.Fatal("expected error from peer when tool is not registered")}- // Pin the exact wrapper format produced by handleDescribeRemoteTool's- // IsError branch. Matching the full prefix guarantees we exercised the- // IsError codepath, not a transport-level retry timeout or a JSON-parse- // fallback that happens to mention "tool not found".- wantPrefix := fmt.Sprintf("describe_local_tool on %s: tool not found:", nodeB.Host.ID())- if !strings.HasPrefix(err.Error(), wantPrefix) {- t.Errorf("error %q does not start with %q", err.Error(), wantPrefix)+ wantError := "tool not found on peer"+ if err.Error() != wantError {+ t.Errorf("error %q != %q", err.Error(), wantError)}}@@ -840,3 +728,19 @@ func TestNewMCPHandler_RegistersDescribeRemoteTool(t *testing.T) {t.Errorf("describe_remote_tool missing from sidecar tools/list; got %v", names)}}++// newFakeMCPHandler returns an http.Handler serving a tiny MCP server over+// streamable-http with the given tools registered.+func newFakeMCPHandler(t *testing.T, tools []*mcp.Tool) http.Handler {+ t.Helper()+ srv := mcp.NewServer(&mcp.Implementation{Name: "fake", Version: "0.0.1"}, nil)+ for _, tool := range tools {+ toolCopy := tool+ srv.AddTool(toolCopy, func(ctx context.Context, req *mcp.CallToolRequest) (*mcp.CallToolResult, error) {+ return &mcp.CallToolResult{+ Content: []mcp.Content{&mcp.TextContent{Text: "fake-result:" + toolCopy.Name}},+ }, nil+ })+ }+ return mcp.NewStreamableHTTPHandler(func(*http.Request) *mcp.Server { return srv }, nil)+}diff --git a/cmd/sam-node/mcp_service.go b/cmd/sam-node/mcp_service.goindex 61d9c02d..4da8cf67 100644--- a/cmd/sam-node/mcp_service.go+++ b/cmd/sam-node/mcp_service.go@@ -16,149 +16,107 @@ package mainimport ("context"- "fmt"- "strings"- "time""github.com/google/sam/api"+ "github.com/libp2p/go-libp2p/core/network""github.com/modelcontextprotocol/go-sdk/mcp")-// MCPService extends baseService with an MCP ClientSession used to aggregate-// the backend's tools at Init time. Other parts of the codebase reach the-// tool list via type assertion (svc.(*MCPService)).+// MCPService extends baseService to handle MCP protocol proxying.type MCPService struct {baseService- session *mcp.ClientSession- aggregatedTools []*mcp.Tool}-// Init builds the ingress handler via baseService.Init, then opens an MCP-// session over the appropriate native transport (StreamableClient for URL,-// bridgeTransport for stdio). ListTools is best-effort: failures are logged-// and the service still registers.+// Init initializes the base service.func (m *MCPService) Init(ctx context.Context) error {- if err := m.baseService.Init(ctx); err != nil {- return err- }- success := false+ return m.baseService.Init(ctx)+}++// Teardown chains to baseService.Teardown.+func (m *MCPService) Teardown() error {+ return m.baseService.Teardown()+}++// HandleStreamPassThrough connects to the backend and proxies JSON-RPC messages.+func (m *MCPService) HandleStreamPassThrough(s network.Stream) {defer func() {- if !success {- _ = m.baseService.Teardown()+ if err := s.Close(); err != nil {+ logger.Debugf("[MCPService] Failed to close MCP stream: %v", err)}}()- var transport mcp.Transport+ var backendTransport mcp.Transport+ var closeTransport func()+switch x := m.backend.(type) {case *api.RegisterServiceRequest_TargetUrl:- // TODO: Consider routing URL-backed MCP ingress through the session- // (as the stdio path effectively does via the bridge) so we can- // decode/inspect MCP payloads and add per-tool-call observability- // or policy enforcement at this boundary.- transport = &mcp.StreamableClientTransport{Endpoint: x.TargetUrl}+ backendTransport = &mcp.StreamableClientTransport{Endpoint: x.TargetUrl}+ closeTransport = func() {} // ClientTransport Close is handled by Connect's returned Connectioncase *api.RegisterServiceRequest_Command:bridge, ok := m.handler.(*StdioBridge)if !ok {- return fmt.Errorf("expected *StdioBridge handler for command-backed MCP service, got %T", m.handler)+ logger.Errorf("[MCPService] %s: expected *StdioBridge handler for command-backed MCP service, got %T", m.info.Name, m.handler)+ return}- transport = newBridgeTransport(bridge)+ backendTransport = newBridgeTransport(bridge)+ closeTransport = func() {} // Do not close the shared bridgedefault:- return fmt.Errorf("unsupported backend type %T", m.backend)+ logger.Errorf("[MCPService] %s: unsupported backend type %T", m.info.Name, m.backend)+ return}- client := mcp.NewClient(&mcp.Implementation{Name: "sam-node-aggregator", Version: "0.1.0"}, nil)-- var s *mcp.ClientSession- var err error-- // Retry connection for up to 60 seconds to handle slow-starting sidecars like OpenClaw.- // We only retry on "connection refused" which indicates the server hasn't bound the port yet.- deadline := time.Now().Add(60 * time.Second)- delay := 500 * time.Millisecond- for {- s, err = client.Connect(ctx, transport, nil)- if err == nil {- break- }- if time.Now().After(deadline) || ctx.Err() != nil {- break- }- if !strings.Contains(err.Error(), "connection refused") {- break- }- select {- case <-ctx.Done():- case <-time.After(delay):- }- delay *= 2- if delay > 10*time.Second {- delay = 10 * time.Second+ ctx, cancel := context.WithCancel(context.Background())+ defer cancel()+ defer func() {+ if closeTransport != nil {+ closeTransport()}- }+ }()+ backendConn, err := backendTransport.Connect(ctx)if err != nil {- // Best-effort: backend may not speak MCP (e.g. a plain HTTP service,- // or `cat` used as a stdio echo). Ingress proxy still works.- logger.Warnf("[MCPService] %s: mcp connect failed, registering without tool aggregation: %v", m.info.Name, err)- success = true- return nil+ logger.Errorf("[MCPService] %s: failed to connect to backend: %v", m.info.Name, err)+ return}- m.session = s+ defer func() { _ = backendConn.Close() }()- listCtx, cancel := context.WithTimeout(ctx, 10*time.Second)- defer cancel()- res, err := s.ListTools(listCtx, nil)+ clientTransport := NewStreamTransport(s)+ clientConn, err := clientTransport.Connect(ctx)if err != nil {- logger.Warnf("[MCPService] %s: tools/list failed: %v", m.info.Name, err)- success = true- return nil- }- aggregated := make([]*mcp.Tool, 0, len(res.Tools))- for _, tool := range res.Tools {- namespaced := *tool- namespaced.Name = fmt.Sprintf("%s.%s", m.info.Name, tool.Name)- aggregated = append(aggregated, &namespaced)+ logger.Errorf("[MCPService] %s: failed to connect to client: %v", m.info.Name, err)+ return}- m.aggregatedTools = aggregated- success = true- return nil-}--// Teardown closes the MCP session and chains to baseService.Teardown.-func (m *MCPService) Teardown() error {- if m.session != nil {- _ = m.session.Close()- m.session = nil- }- m.aggregatedTools = nil- return m.baseService.Teardown()-}+ // Dumb pipe: Proxy JSON-RPC messages between client and backend+ errc := make(chan error, 2)-// Tools returns the namespaced aggregated tool list.-func (m *MCPService) Tools() []*mcp.Tool { return m.aggregatedTools }+ go func() {+ for {+ msg, err := clientConn.Read(ctx)+ if err != nil {+ errc <- err+ return+ }+ if err := backendConn.Write(ctx, msg); err != nil {+ errc <- err+ return+ }+ }+ }()-// RegisterAggregatedTools adds this service's aggregated tools to the given-// MCP server. Each tool's invocation is forwarded to the underlying session-// with the service-name prefix stripped. No-op if aggregation produced-// nothing (e.g. ListTools failed at Init time).-func (m *MCPService) RegisterAggregatedTools(server *mcp.Server) {- if m.session == nil {- return- }- sess := m.session- for _, tool := range m.aggregatedTools {- toolCopy := tool- parts := strings.SplitN(toolCopy.Name, ".", 2)- if len(parts) != 2 {- continue+ go func() {+ for {+ msg, err := backendConn.Read(ctx)+ if err != nil {+ errc <- err+ return+ }+ if err := clientConn.Write(ctx, msg); err != nil {+ errc <- err+ return+ }}- originalName := parts[1]- server.AddTool(toolCopy, func(ctx context.Context, req *mcp.CallToolRequest) (*mcp.CallToolResult, error) {- return sess.CallTool(ctx, &mcp.CallToolParams{- Name: originalName,- Arguments: req.Params.Arguments,- })- })- }+ }()++ <-errc}diff --git a/cmd/sam-node/mcp_service_test.go b/cmd/sam-node/mcp_service_test.godeleted file mode 100644index 3b50eafc..00000000--- a/cmd/sam-node/mcp_service_test.go+++ /dev/null@@ -1,127 +0,0 @@-// Copyright 2026 Google LLC-//-// Licensed under the Apache License, Version 2.0 (the "License");-// you may not use this file except in compliance with the License.-// You may obtain a copy of the License at-//-// http://www.apache.org/licenses/LICENSE-2.0-//-// Unless required by applicable law or agreed to in writing, software-// distributed under the License is distributed on an "AS IS" BASIS,-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.-// See the License for the specific language governing permissions and-// limitations under the License.-package main--import (- "context"- "net/http"- "net/http/httptest"- "testing"- "time"-- "github.com/google/sam/api"- "github.com/modelcontextprotocol/go-sdk/mcp"-)--// newFakeMCPHandler returns an http.Handler serving a tiny MCP server over-// streamable-http with the given tools registered.-func newFakeMCPHandler(t *testing.T, tools []*mcp.Tool) http.Handler {- t.Helper()- srv := mcp.NewServer(&mcp.Implementation{Name: "fake", Version: "0.0.1"}, nil)- for _, tool := range tools {- toolCopy := tool- srv.AddTool(toolCopy, func(ctx context.Context, req *mcp.CallToolRequest) (*mcp.CallToolResult, error) {- return &mcp.CallToolResult{- Content: []mcp.Content{&mcp.TextContent{Text: "fake-result:" + toolCopy.Name}},- }, nil- })- }- return mcp.NewStreamableHTTPHandler(func(*http.Request) *mcp.Server { return srv }, nil)-}--func TestMCPService_InitURL_AggregatesNamespacedTools(t *testing.T) {- ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)- defer cancel()-- tools := []*mcp.Tool{- {Name: "review_pr", Description: "Run a code review", InputSchema: map[string]any{"type": "object"}},- {Name: "add_comment", Description: "Add a comment", InputSchema: map[string]any{"type": "object"}},- }- upstream := httptest.NewServer(newFakeMCPHandler(t, tools))- defer upstream.Close()-- svc := &MCPService{baseService: baseService{- info: &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: "code-reviewer"},- backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: upstream.URL},- }}-- if err := svc.Init(ctx); err != nil {- t.Fatalf("Init: %v", err)- }- defer func() { _ = svc.Teardown() }()-- got := svc.Tools()- if len(got) != 2 {- t.Fatalf("Tools length: got %d, want 2", len(got))- }- names := map[string]bool{}- for _, tool := range got {- names[tool.Name] = true- }- for _, want := range []string{"code-reviewer.review_pr", "code-reviewer.add_comment"} {- if !names[want] {- t.Errorf("expected namespaced tool %q in %v", want, names)- }- }- if svc.handler == nil {- t.Errorf("Handler is nil after Init")- }-}--func TestMCPService_InitURL_InvalidURLRollsBack(t *testing.T) {- svc := &MCPService{baseService: baseService{- info: &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: "broken"},- backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: "::not a url::"},- }}- if err := svc.Init(context.Background()); err == nil {- t.Fatal("Init: expected error for invalid URL, got nil")- }- if svc.cmd != nil {- t.Errorf("rollback failed: cmd should be nil, got %v", svc.cmd)- }- if svc.session != nil {- t.Errorf("rollback failed: session should be nil")- }-}--func TestMCPService_InitURL_ListToolsFailureBestEffort(t *testing.T) {- ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)- defer cancel()-- // Handler that 500s on every request: Connect may succeed, ListTools won't.- upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {- w.WriteHeader(http.StatusInternalServerError)- }))- defer upstream.Close()-- svc := &MCPService{baseService: baseService{- info: &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: "broken"},- backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: upstream.URL},- }}- // Init may return nil (best-effort) OR an error from Connect. Both are acceptable.- // Only assert no panic and clean Teardown.- _ = svc.Init(ctx)- if err := svc.Teardown(); err != nil {- t.Errorf("Teardown: %v", err)- }-}--func TestMCPService_Teardown_NilSafe(t *testing.T) {- svc := &MCPService{baseService: baseService{- info: &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: "x"},- }}- if err := svc.Teardown(); err != nil {- t.Fatalf("Teardown on uninitialised MCPService: %v", err)- }-}diff --git a/cmd/sam-node/middleware.go b/cmd/sam-node/middleware.goindex 83ddb54f..1f36f4d5 100644--- a/cmd/sam-node/middleware.go+++ b/cmd/sam-node/middleware.go@@ -75,7 +75,7 @@ type RequestContext struct {}// WithBiscuitAuth enforces a Protobuf handshake on a stream before calling the next handler.-func (n *SamNode) WithBiscuitAuth(next network.StreamHandler) network.StreamHandler {+func (n *SamNode) WithBiscuitAuth(next func(network.Stream, RequestContext)) network.StreamHandler {return func(s network.Stream) {defer func() {if err := s.Close(); err != nil {@@ -155,7 +155,7 @@ func (n *SamNode) WithBiscuitAuth(next network.StreamHandler) network.StreamHandlogger.Errorf("[Auth] Failed to write ACK to %s: %v", remotePeer, err)return}- next(s)+ next(s, reqCtx)return}}@@ -247,7 +247,7 @@ func (n *SamNode) WithBiscuitAuth(next network.StreamHandler) network.StreamHandreturn}- next(s)+ next(s, reqCtx)}}diff --git a/cmd/sam-node/middleware_test.go b/cmd/sam-node/middleware_test.goindex b3aebb49..05323769 100644--- a/cmd/sam-node/middleware_test.go+++ b/cmd/sam-node/middleware_test.go@@ -371,7 +371,7 @@ func TestRevocation(t *testing.T) {// Run handler in goroutinego func() {- handler := node.WithBiscuitAuth(func(s network.Stream) {+ handler := node.WithBiscuitAuth(func(s network.Stream, reqCtx RequestContext) {t.Error("Handler should not be called for revoked peer")})handler(serverStream)diff --git a/cmd/sam-node/sidecar_test.go b/cmd/sam-node/sidecar_test.goindex d2dec027..12d26d3e 100644--- a/cmd/sam-node/sidecar_test.go+++ b/cmd/sam-node/sidecar_test.go@@ -27,7 +27,7 @@ import ("github.com/google/sam/api""github.com/libp2p/go-libp2p"dht "github.com/libp2p/go-libp2p-kad-dht"- "github.com/libp2p/go-libp2p/core/crypto"+"github.com/libp2p/go-libp2p/core/peer""github.com/modelcontextprotocol/go-sdk/mcp""google.golang.org/protobuf/encoding/protojson"@@ -477,141 +477,3 @@ func TestStartSidecarServer_TokenMandatory(t *testing.T) {}}}--func TestRegisterService_PopulatesAggregatedTools(t *testing.T) {- ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)- defer cancel()-- tools := []*mcp.Tool{- {Name: "do_thing", Description: "x", InputSchema: map[string]any{"type": "object"}},- }- handler := newFakeMCPHandler(t, tools)- hostedSrv := httptest.NewServer(handler)- defer hostedSrv.Close()-- dir := t.TempDir()- store, err := NewStore(dir)- if err != nil {- t.Fatal(err)- }- defer func() { _ = store.Close() }()-- priv, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1)- if err != nil {- t.Fatal(err)- }- node, err := NewSamNode(ctx, SamNodeConfig{- PrivKey: priv,- HubAddrs: nil,- Store: store,- MeshID: "test-mesh",- DiscoveryInterval: "1s",- ListenAddrs: []string{"/ip4/127.0.0.1/tcp/0"},- EnableRelay: false,- NodeConfig: &NodeConfigComplete{},- KeyGracePeriod: 24 * time.Hour,- AllowLoopback: true,- MonitorBootstrap: 2 * time.Minute,- MonitorInterval: 1 * time.Minute,- })- if err != nil {- t.Fatal(err)- }- defer func() { _ = node.Teardown() }()-- req := &api.RegisterServiceRequest{- Service: &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: "svc"},- Backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: hostedSrv.URL},- }- _ = node.RegisterService(ctx, req) // DHT.Provide may fail in isolated test; aggregation is independent.-- svc, ok := node.services.Get("svc")- if !ok {- t.Fatal("service was not stored in registry")- }- mcpSvc, ok := svc.(*MCPService)- if !ok {- t.Fatalf("expected *MCPService, got %T", svc)- }- aggregated := mcpSvc.Tools()- if len(aggregated) != 1 {- t.Fatalf("expected 1 aggregated tool, got %d", len(aggregated))- }- if got := aggregated[0].Name; got != "svc.do_thing" {- t.Errorf("aggregated tool name: got %q, want %q", got, "svc.do_thing")- }-}--func TestUnregisterService_DetachesAggregation(t *testing.T) {- ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)- defer cancel()-- tools := []*mcp.Tool{- {Name: "do_thing", Description: "x", InputSchema: map[string]any{"type": "object"}},- }- handler := newFakeMCPHandler(t, tools)- hostedSrv := httptest.NewServer(handler)- defer hostedSrv.Close()-- dir := t.TempDir()- store, err := NewStore(dir)- if err != nil {- t.Fatal(err)- }- defer func() { _ = store.Close() }()-- priv, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1)- if err != nil {- t.Fatal(err)- }- node, err := NewSamNode(ctx, SamNodeConfig{- PrivKey: priv,- HubAddrs: nil,- Store: store,- MeshID: "test-mesh",- DiscoveryInterval: "1s",- ListenAddrs: []string{"/ip4/127.0.0.1/tcp/0"},- EnableRelay: false,- NodeConfig: &NodeConfigComplete{},- KeyGracePeriod: 24 * time.Hour,- AllowLoopback: true,- MonitorBootstrap: 2 * time.Minute,- MonitorInterval: 1 * time.Minute,- })- if err != nil {- t.Fatal(err)- }- defer func() { _ = node.Teardown() }()-- req := &api.RegisterServiceRequest{- Service: &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: "svc"},- Backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: hostedSrv.URL},- }- _ = node.RegisterService(ctx, req)-- svc, ok := node.services.Get("svc")- if !ok {- t.Fatal("expected service registered")- }- mcpSvc, ok := svc.(*MCPService)- if !ok {- t.Fatalf("expected *MCPService, got %T", svc)- }- if mcpSvc.session == nil {- t.Fatal("expected active MCP session before unregister")- }-- if err := node.UnregisterService(ctx, "svc"); err != nil {- t.Fatalf("UnregisterService: %v", err)- }-- if mcpSvc.session != nil {- t.Error("session should be nil after Unregister")- }- if mcpSvc.Tools() != nil {- t.Error("aggregatedTools should be nil after Unregister")- }- if _, stillThere := node.services.Get("svc"); stillThere {- t.Error("service should be removed from registry")- }-}diff --git a/tests/e2e/kubernetes.bats b/tests/e2e/kubernetes.batsindex 646558d7..f307fee8 100644--- a/tests/e2e/kubernetes.bats+++ b/tests/e2e/kubernetes.bats@@ -155,7 +155,7 @@ import urllib.requestimport jsondata = {'service': {- 'type': 3,+ 'type': 1,'name': 'echo-tool','description': 'test'},@@ -178,7 +178,7 @@ with urllib.request.urlopen(req) as response:local outputlocal ifor ((i=0; i<60; i++)); do- output=$(docker run --rm --network container:external-sam-node alpine wget -q -O- --timeout=2 --header="Authorization: Bearer secret-token" "http://127.0.0.1:8080/sam/${cluster_node_peer_id}/a2a/echo-tool" || true)+ output=$(docker run --rm --network container:external-sam-node alpine wget -q -O- --timeout=2 --header="Authorization: Bearer secret-token" "http://127.0.0.1:8080/sam/${cluster_node_peer_id}/mcp/echo-tool" || true)if [ "$output" == "OK" ]; thenbreakfi