Skip to content

Agent Mesh

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.go
index 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 transport
transport := 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 tool
mcp.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.go
index 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 := false
for _, n := range names {
- if n == "code-reviewer.review_pr" {
+ if n == "review_pr" {
found = true
break
}
}
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.go
index 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 := toolName
if 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 rejected
callParams := &mcp.CallToolParams{
- Name: toolName,
+ Name: originalToolName,
Arguments: params,
}
diff --git a/cmd/sam-node/mcp_handlers.go b/cmd/sam-node/mcp_handlers.go
index 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.Tool
biscuitBytes, 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.CallToo
if 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.go
index 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.go
index 61d9c02d..4da8cf67 100644
--- a/cmd/sam-node/mcp_service.go
+++ b/cmd/sam-node/mcp_service.go
@@ -16,149 +16,107 @@ package main
import (
"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 Connection
case *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 bridge
default:
- 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.go
deleted file mode 100644
index 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.go
index 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.StreamHand
logger.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.StreamHand
return
}
- next(s)
+ next(s, reqCtx)
}
}
diff --git a/cmd/sam-node/middleware_test.go b/cmd/sam-node/middleware_test.go
index 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 goroutine
go 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.go
index 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.bats
index 646558d7..f307fee8 100644
--- a/tests/e2e/kubernetes.bats
+++ b/tests/e2e/kubernetes.bats
@@ -155,7 +155,7 @@ import urllib.request
import json
data = {
'service': {
- 'type': 3,
+ 'type': 1,
'name': 'echo-tool',
'description': 'test'
},
@@ -178,7 +178,7 @@ with urllib.request.urlopen(req) as response:
local output
local i
for ((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" ]; then
break
fi