Skip to content

Agent Mesh

Allow discovering remote services by type

Tomas Tormo0f43a276f871
diff --git a/api/sam.pb.go b/api/sam.pb.go
index e80bc9a2..d3a34561 100644
--- a/api/sam.pb.go
+++ b/api/sam.pb.go
@@ -650,11 +650,13 @@ func (*RegisterServiceRequest_TargetUrl) isRegisterServiceRequest_Backend() {}
func (*RegisterServiceRequest_Command) isRegisterServiceRequest_Backend() {}
type DiscoveredProvider struct {
- state protoimpl.MessageState `protogen:"open.v1"`
- PeerId string `protobuf:"bytes,1,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
- LocalProxyUrl string `protobuf:"bytes,2,opt,name=local_proxy_url,json=localProxyUrl,proto3" json:"local_proxy_url,omitempty"`
- unknownFields protoimpl.UnknownFields
- sizeCache protoimpl.SizeCache
+ state protoimpl.MessageState `protogen:"open.v1"`
+ PeerId string `protobuf:"bytes,1,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
+ LocalProxyUrl string `protobuf:"bytes,2,opt,name=local_proxy_url,json=localProxyUrl,proto3" json:"local_proxy_url,omitempty"`
+ SrvName string `protobuf:"bytes,3,opt,name=srv_name,json=srvName,proto3" json:"srv_name,omitempty"`
+ SrvDescription string `protobuf:"bytes,4,opt,name=srv_description,json=srvDescription,proto3" json:"srv_description,omitempty"`
+ unknownFields protoimpl.UnknownFields
+ sizeCache protoimpl.SizeCache
}
func (x *DiscoveredProvider) Reset() {
@@ -701,6 +703,20 @@ func (x *DiscoveredProvider) GetLocalProxyUrl() string {
return ""
}
+func (x *DiscoveredProvider) GetSrvName() string {
+ if x != nil {
+ return x.SrvName
+ }
+ return ""
+}
+
+func (x *DiscoveredProvider) GetSrvDescription() string {
+ if x != nil {
+ return x.SrvDescription
+ }
+ return ""
+}
+
var File_api_sam_proto protoreflect.FileDescriptor
const file_api_sam_proto_rawDesc = "" +
@@ -751,10 +767,12 @@ const file_api_sam_proto_rawDesc = "" +
"\n" +
"target_url\x18\x02 \x01(\tH\x00R\ttargetUrl\x122\n" +
"\acommand\x18\x03 \x01(\v2\x16.sam.v1.CommandBackendH\x00R\acommandB\t\n" +
- "\abackend\"U\n" +
+ "\abackend\"\x99\x01\n" +
"\x12DiscoveredProvider\x12\x17\n" +
"\apeer_id\x18\x01 \x01(\tR\x06peerId\x12&\n" +
- "\x0flocal_proxy_url\x18\x02 \x01(\tR\rlocalProxyUrl*s\n" +
+ "\x0flocal_proxy_url\x18\x02 \x01(\tR\rlocalProxyUrl\x12\x19\n" +
+ "\bsrv_name\x18\x03 \x01(\tR\asrvName\x12'\n" +
+ "\x0fsrv_description\x18\x04 \x01(\tR\x0esrvDescription*s\n" +
"\vServiceType\x12\x1c\n" +
"\x18SERVICE_TYPE_UNSPECIFIED\x10\x00\x12\x14\n" +
"\x10SERVICE_TYPE_MCP\x10\x01\x12\x1a\n" +
diff --git a/api/sam.proto b/api/sam.proto
index 66db58b6..e6b0eaae 100644
--- a/api/sam.proto
+++ b/api/sam.proto
@@ -85,5 +85,7 @@ message RegisterServiceRequest {
message DiscoveredProvider {
string peer_id = 1;
- string local_proxy_url = 2;
+ string local_proxy_url = 2;
+ string srv_name = 3;
+ string srv_description = 4;
}
diff --git a/cmd/sam-node/gate.go b/cmd/sam-node/gate.go
index cd5c8755..a2ab3a4c 100644
--- a/cmd/sam-node/gate.go
+++ b/cmd/sam-node/gate.go
@@ -19,6 +19,8 @@ import (
"encoding/json"
"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"
@@ -28,7 +30,6 @@ import (
"github.com/modelcontextprotocol/go-sdk/jsonrpc"
"github.com/modelcontextprotocol/go-sdk/mcp"
-
)
var _ connmgr.ConnectionGater = (*nodeConnGate)(nil)
@@ -134,6 +135,34 @@ func (n *SamNode) HandleMCPStream(s network.Stream) {
}, nil, nil
})
+ // Add list_local_services tool
+ // TODO: Commonize this function since is also present in mcp.go
+ mcp.AddTool(server, &mcp.Tool{
+ Name: "list_local_services",
+ Description: "List services registered on the local node. Optionally filter by type.",
+ }, func(ctx context.Context, req *mcp.CallToolRequest, params struct {
+ Type string `json:"type,omitempty" jsonschema:"Optional service type filter (mcp, inference, a2a). Empty means all types."`
+ }) (*mcp.CallToolResult, any, error) {
+ typeFilter := api.ServiceType_SERVICE_TYPE_UNSPECIFIED
+ if params.Type != "" {
+ parsed, err := parseServiceType(params.Type)
+ if err != nil {
+ return nil, nil, err
+ }
+ typeFilter = parsed
+ }
+ services := n.ListLocalServices(typeFilter)
+ respData, err := json.Marshal(services)
+ if err != nil {
+ return nil, nil, err
+ }
+ return &mcp.CallToolResult{
+ Content: []mcp.Content{
+ &mcp.TextContent{Text: string(respData)},
+ },
+ }, nil, nil
+ })
+
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)
@@ -172,11 +201,7 @@ func (t *StreamTransport) Read(ctx context.Context) (jsonrpc.Message, error) {
}
defer t.r.ReleaseMsg(msg)
- var jsonRpcMsg jsonrpc.Message
- if err := json.Unmarshal(msg, &jsonRpcMsg); err != nil {
- return nil, err
- }
- return jsonRpcMsg, nil
+ return jsonrpc.DecodeMessage(msg)
}
// Close closes the stream.
@@ -194,11 +219,9 @@ func (t *StreamTransport) SessionID() string {
return t.s.Conn().RemotePeer().String()
}
-
-
// Write writes a message to the stream.
func (t *StreamTransport) Write(ctx context.Context, msg jsonrpc.Message) error {
- data, err := json.Marshal(msg)
+ data, err := jsonrpc.EncodeMessage(msg)
if err != nil {
return err
}
diff --git a/cmd/sam-node/mcp.go b/cmd/sam-node/mcp.go
index 6b926fc7..b601575f 100644
--- a/cmd/sam-node/mcp.go
+++ b/cmd/sam-node/mcp.go
@@ -63,9 +63,19 @@ func NewMCPHandler(node *SamNode) http.Handler {
// Add list_local_services tool
mcp.AddTool(mcpServer, &mcp.Tool{
Name: "list_local_services",
- Description: "List services registered on the local node",
- }, func(ctx context.Context, req *mcp.CallToolRequest, params struct{}) (*mcp.CallToolResult, any, error) {
- services := node.ListLocalServices()
+ Description: "List services registered on the local node. Optionally filter by type.",
+ }, func(ctx context.Context, req *mcp.CallToolRequest, params struct {
+ Type string `json:"type,omitempty" jsonschema:"Optional service type filter (mcp, inference, a2a). Empty means all types."`
+ }) (*mcp.CallToolResult, any, error) {
+ typeFilter := api.ServiceType_SERVICE_TYPE_UNSPECIFIED
+ if params.Type != "" {
+ parsed, err := parseServiceType(params.Type)
+ if err != nil {
+ return nil, nil, err
+ }
+ typeFilter = parsed
+ }
+ services := node.ListLocalServices(typeFilter)
respData, err := json.Marshal(services)
if err != nil {
return nil, nil, err
@@ -80,10 +90,10 @@ func NewMCPHandler(node *SamNode) http.Handler {
// Add discover_remote_services tool
mcp.AddTool(mcpServer, &mcp.Tool{
Name: "discover_remote_services",
- Description: "Discover remote services in the mesh",
+ Description: "Discover remote services in the mesh. Provide only `type` to browse every reachable service of that type (returns name + description for each); add `name` to target a specific service.",
}, func(ctx context.Context, req *mcp.CallToolRequest, params struct {
Type string `json:"type" jsonschema:"Service type (mcp, inference, a2a)"`
- Name string `json:"name" jsonschema:"Service name"`
+ Name string `json:"name,omitempty" jsonschema:"Optional service name. Omit to list all services of the given type."`
}) (*mcp.CallToolResult, any, error) {
serviceType, err := parseServiceType(params.Type)
if err != nil || serviceType == api.ServiceType_SERVICE_TYPE_UNSPECIFIED {
@@ -359,14 +369,12 @@ func (n *SamNode) callMCPToolOnce(ctx context.Context, targetPeer peer.ID, toolN
return nil, fmt.Errorf("failed to connect client: %w", err)
}
+ // 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,
- }
- paramsBytes, err := json.Marshal(params)
- if err != nil {
- return nil, fmt.Errorf("failed to marshal params for tool %s: %w", toolName, err)
+ Name: toolName,
+ Arguments: params,
}
- callParams.Arguments = paramsBytes // Assume it takes bytes or raw message!
res, err := session.CallTool(ctx, callParams)
if err != nil {
@@ -375,3 +383,25 @@ func (n *SamNode) callMCPToolOnce(ctx context.Context, targetPeer peer.ID, toolN
return res, nil
}
+
+// fetchRemoteServiceCatalog calls the remote peer's list_local_services
+// MCP tool with the type filter and returns the parsed catalog.
+func (n *SamNode) fetchRemoteServiceCatalog(ctx context.Context, peerID peer.ID, typeStr string) ([]*api.ServiceInfo, error) {
+ res, err := n.callMCPToolOnce(ctx, peerID, "list_local_services", map[string]string{"type": typeStr})
+ if err != nil {
+ return nil, err
+ }
+ if res == nil || len(res.Content) == 0 {
+ return nil, fmt.Errorf("empty response")
+ }
+ text, ok := res.Content[0].(*mcp.TextContent)
+ if !ok {
+ return nil, fmt.Errorf("unexpected content type: %T", res.Content[0])
+ }
+ var services []*api.ServiceInfo
+ if err := json.Unmarshal([]byte(text.Text), &services); err != nil {
+ logger.Warnf("[Discovery] catalog unmarshal failed; raw text from %s: %q", peerID, text.Text)
+ return nil, fmt.Errorf("unmarshal: %w", err)
+ }
+ return services, nil
+}
diff --git a/cmd/sam-node/node.go b/cmd/sam-node/node.go
index bef96814..3ac6fc96 100644
--- a/cmd/sam-node/node.go
+++ b/cmd/sam-node/node.go
@@ -230,7 +230,6 @@ func NewSamNode(ctx context.Context, privKey crypto.PrivKey, hubPubKey ed25519.P
// Register static services from config
-
// Start Ingress HTTP Server
if err := node.StartIngressServer(ctx); err != nil {
return nil, fmt.Errorf("failed to start ingress server: %w", err)
@@ -245,9 +244,9 @@ func (n *SamNode) RegisterStaticServices(ctx context.Context, services []api.Ser
// before the DHT has discovered peers.
ticker := time.NewTicker(100 * time.Millisecond)
defer ticker.Stop()
-
+
timeout := time.After(10 * time.Second) // 10 seconds timeout for DHT readiness
-
+
dhtLoop:
for {
select {
@@ -769,17 +768,30 @@ func parseServiceType(s string) (api.ServiceType, error) {
}
}
+// serviceKeyToCID hashes "sam:service[:part]..." into a DHT rendezvous CID.
+func serviceKeyToCID(parts ...string) (cid.Cid, error) {
+ srvKey := strings.Join(append([]string{"sam:service"}, parts...), ":")
+ hash, err := multihash.Sum([]byte(srvKey), multihash.SHA2_256, -1)
+ if err != nil {
+ return cid.Undef, err
+ }
+ return cid.NewCidV1(cid.Raw, hash), nil
+}
+
func serviceNameToCID(serviceType api.ServiceType, serviceName string) (cid.Cid, error) {
- typeStr, err := serviceTypeToString(serviceType)
+ srvTypeStr, err := serviceTypeToString(serviceType)
if err != nil {
return cid.Undef, err
}
- serviceKey := fmt.Sprintf("sam:service:%s:%s", typeStr, serviceName)
- hash, err := multihash.Sum([]byte(serviceKey), multihash.SHA2_256, -1)
+ return serviceKeyToCID(srvTypeStr, serviceName)
+}
+
+func serviceTypeToCID(serviceType api.ServiceType) (cid.Cid, error) {
+ srvTypeStr, err := serviceTypeToString(serviceType)
if err != nil {
return cid.Undef, err
}
- return cid.NewCidV1(cid.Raw, hash), nil
+ return serviceKeyToCID(srvTypeStr)
}
type StdioBridge struct {
@@ -907,7 +919,11 @@ func (n *SamNode) RegisterService(ctx context.Context, req *api.RegisterServiceR
if info.Type == api.ServiceType_SERVICE_TYPE_UNSPECIFIED {
return fmt.Errorf("cannot register service with unspecified type")
}
- c, err := serviceNameToCID(info.Type, info.Name)
+ srvNameCID, err := serviceNameToCID(info.Type, info.Name)
+ if err != nil {
+ return err
+ }
+ srvTypeCID, err := serviceTypeToCID(info.Type)
if err != nil {
return err
}
@@ -916,9 +932,13 @@ func (n *SamNode) RegisterService(ctx context.Context, req *api.RegisterServiceR
return fmt.Errorf("DHT not initialized")
}
- if err := n.DHT.Provide(ctx, c, true); err != nil {
+ if err := n.DHT.Provide(ctx, srvNameCID, true); err != nil {
return fmt.Errorf("failed to provide service to DHT: %w", err)
}
+ // Per-type rendezvous record so type-only discovery finds this peer.
+ if err := n.DHT.Provide(ctx, srvTypeCID, true); err != nil {
+ return fmt.Errorf("failed to provide service type to DHT: %w", err)
+ }
var handler http.Handler
var cmd *exec.Cmd
@@ -947,7 +967,7 @@ func (n *SamNode) RegisterService(ctx context.Context, req *api.RegisterServiceR
}
n.servicesMu.Unlock()
- logger.Infof("[ServiceRegistry] Registering service %s/%s (CID: %s)", info.Type, info.Name, c)
+ logger.Infof("[ServiceRegistry] Registering service %s/%s (name CID: %s, type CID: %s)", info.Type, info.Name, srvNameCID, srvTypeCID)
return nil
}
@@ -974,65 +994,152 @@ func (n *SamNode) IsServiceRegistered(serviceName string) bool {
return ok
}
-func (n *SamNode) FindProviders(ctx context.Context, serviceType api.ServiceType, serviceName string) ([]peer.AddrInfo, error) {
- c, err := serviceNameToCID(serviceType, serviceName)
- if err != nil {
- return nil, err
- }
+// Bound DHT lookups and per-peer catalog fan-out so a partially
+// reachable mesh can't wedge a discovery call indefinitely.
+const (
+ dhtLookupTimeout = 5 * time.Second
+ discoveryFanoutTimeout = 5 * time.Second
+)
+// findProvidersByCID is the shared DHT-lookup primitive; bounds the
+// lookup so FindProvidersAsync's channel is guaranteed to close.
+func (n *SamNode) findProvidersByCID(ctx context.Context, c cid.Cid) ([]peer.AddrInfo, error) {
if n.DHT == nil {
return nil, fmt.Errorf("DHT not initialized")
}
+ lookupCtx, cancel := context.WithTimeout(ctx, dhtLookupTimeout)
+ defer cancel()
+ // FindProvidersAsync can emit the same peer multiple times when the
+ // DHT walk converges from different paths; dedupe so downstream
+ // fan-out (e.g. discoverServicesByType) doesn't double-fetch.
+ providersMap := make(map[peer.ID]peer.AddrInfo)
+ for p := range n.DHT.FindProvidersAsync(lookupCtx, c, 20) {
+ providersMap[p.ID] = p
+ }
+ providers := make([]peer.AddrInfo, 0, len(providersMap))
+ for _, p := range providersMap {
+ providers = append(providers, p)
+ }
+ return providers, nil
+}
- providers := n.DHT.FindProvidersAsync(ctx, c, 20)
- var providerInfos []peer.AddrInfo
- for p := range providers {
- providerInfos = append(providerInfos, p)
+// FindProvidersByName returns peers hosting a specific {type, name} service.
+func (n *SamNode) FindProvidersByName(ctx context.Context, serviceType api.ServiceType, serviceName string) ([]peer.AddrInfo, error) {
+ c, err := serviceNameToCID(serviceType, serviceName)
+ if err != nil {
+ return nil, err
}
- return providerInfos, nil
+ return n.findProvidersByCID(ctx, c)
}
-func (n *SamNode) DiscoverRemoteServices(ctx context.Context, serviceType api.ServiceType, serviceName string) ([]*api.DiscoveredProvider, error) {
- providers, err := n.FindProviders(ctx, serviceType, serviceName)
+// FindProvidersByType returns peers hosting at least one service of the given type.
+func (n *SamNode) FindProvidersByType(ctx context.Context, serviceType api.ServiceType) ([]peer.AddrInfo, error) {
+ c, err := serviceTypeToCID(serviceType)
if err != nil {
return nil, err
}
+ return n.findProvidersByCID(ctx, c)
+}
+
+// localProxyURL builds the loopback URL clients use to reach a remote service.
+func (n *SamNode) localProxyURL(peerID peer.ID, typeStr, serviceName string) string {
+ return fmt.Sprintf("http://%s/sam/%s/%s/%s",
+ n.BoundHTTPAddr, peerID.String(), typeStr, serviceName)
+}
+// DiscoverRemoteServices dispatches to the named or type-only path
+// based on whether serviceName is provided.
+func (n *SamNode) DiscoverRemoteServices(ctx context.Context, serviceType api.ServiceType, serviceName string) ([]*api.DiscoveredProvider, error) {
typeStr, err := serviceTypeToString(serviceType)
if err != nil {
return nil, err
}
+ if serviceName == "" {
+ return n.discoverServicesByType(ctx, serviceType, typeStr)
+ }
+ return n.discoverServicesByName(ctx, serviceType, typeStr, serviceName)
+}
- var discovered []*api.DiscoveredProvider
- for _, p := range providers {
+// discoverServicesByName: targeted DHT lookup, no fan-out.
+func (n *SamNode) discoverServicesByName(ctx context.Context, serviceType api.ServiceType, typeStr, serviceName string) ([]*api.DiscoveredProvider, error) {
+ peers, err := n.FindProvidersByName(ctx, serviceType, serviceName)
+ if err != nil {
+ return nil, err
+ }
+discovered := []*api.DiscoveredProvider{}
+ for _, p := range peers {
if p.ID == n.Host.ID() {
continue
}
-
- // Construct local proxy URL
- // Format: http://localhost:<sam_port>/sam/{peer_id}/{service_type}/{service_name}
- localURL := fmt.Sprintf("http://%s/sam/%s/%s/%s",
- n.BoundHTTPAddr,
- p.ID.String(),
- typeStr,
- serviceName,
- )
-
discovered = append(discovered, &api.DiscoveredProvider{
PeerId: p.ID.String(),
- LocalProxyUrl: localURL,
+ LocalProxyUrl: n.localProxyURL(p.ID, typeStr, serviceName),
+ SrvName: serviceName,
})
}
+ return discovered, nil
+}
+// discoverServicesByType: rendezvous lookup → parallel list_local_services
+// fan-out → flat catalog. Failed peers are dropped with a log line.
+func (n *SamNode) discoverServicesByType(ctx context.Context, serviceType api.ServiceType, typeStr string) ([]*api.DiscoveredProvider, error) {
+ peers, err := n.FindProvidersByType(ctx, serviceType)
+ if err != nil {
+ return nil, err
+ }
+
+ fanoutCtx, cancel := context.WithTimeout(ctx, discoveryFanoutTimeout)
+ defer cancel()
+
+ type peerCatalog struct {
+ peerID peer.ID
+ services []*api.ServiceInfo
+ }
+ results := make(chan peerCatalog, len(peers))
+ var wg sync.WaitGroup
+ for _, p := range peers {
+ if p.ID == n.Host.ID() {
+ continue
+ }
+ wg.Add(1)
+ go func(peerID peer.ID) {
+ defer wg.Done()
+ services, err := n.fetchRemoteServiceCatalog(fanoutCtx, peerID, typeStr)
+ if err != nil {
+ logger.Warnf("[Discovery] catalog fetch from %s failed: %v", peerID, err)
+ return
+ }
+ results <- peerCatalog{peerID: peerID, services: services}
+ }(p.ID)
+ }
+ wg.Wait()
+ close(results)
+
+discovered := []*api.DiscoveredProvider{}
+ for r := range results {
+ for _, info := range r.services {
+ discovered = append(discovered, &api.DiscoveredProvider{
+ PeerId: r.peerID.String(),
+ LocalProxyUrl: n.localProxyURL(r.peerID, typeStr, info.Name),
+ SrvName: info.Name,
+ SrvDescription: info.Description,
+ })
+ }
+ }
return discovered, nil
}
-func (n *SamNode) ListLocalServices() []*api.ServiceInfo {
+// ListLocalServices returns services registered on this node. If
+// typeFilter is SERVICE_TYPE_UNSPECIFIED, all services are returned.
+func (n *SamNode) ListLocalServices(typeFilter api.ServiceType) []*api.ServiceInfo {
n.servicesMu.RLock()
defer n.servicesMu.RUnlock()
- var services []*api.ServiceInfo
+services := []*api.ServiceInfo{}
for _, manifest := range n.services {
+ if typeFilter != api.ServiceType_SERVICE_TYPE_UNSPECIFIED && manifest.Info.Type != typeFilter {
+ continue
+ }
services = append(services, manifest.Info)
}
return services
diff --git a/cmd/sam-node/sidecar_test.go b/cmd/sam-node/sidecar_test.go
index 031615b2..dfc82b19 100644
--- a/cmd/sam-node/sidecar_test.go
+++ b/cmd/sam-node/sidecar_test.go
@@ -279,13 +279,113 @@ func TestListLocalServices(t *testing.T) {
node.services["service1"] = &ServiceManifest{Info: service1}
node.services["service2"] = &ServiceManifest{Info: service2}
- services := node.ListLocalServices()
+ services := node.ListLocalServices(api.ServiceType_SERVICE_TYPE_UNSPECIFIED)
if len(services) != 2 {
t.Errorf("expected 2 services, got %d", len(services))
}
}
+func TestListLocalServices_TypeFilter(t *testing.T) {
+ node := &SamNode{
+ services: make(map[string]*ServiceManifest),
+ }
+ mcpA := &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: "mcp-a"}
+ mcpB := &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: "mcp-b"}
+ inf := &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_INFERENCE, Name: "inf-a"}
+ node.services["mcp-a"] = &ServiceManifest{Info: mcpA}
+ node.services["mcp-b"] = &ServiceManifest{Info: mcpB}
+ node.services["inf-a"] = &ServiceManifest{Info: inf}
+
+ cases := []struct {
+ name string
+ filter api.ServiceType
+ wantCount int
+ }{
+ {"unspecified returns all", api.ServiceType_SERVICE_TYPE_UNSPECIFIED, 3},
+ {"mcp filter", api.ServiceType_SERVICE_TYPE_MCP, 2},
+ {"inference filter", api.ServiceType_SERVICE_TYPE_INFERENCE, 1},
+ {"a2a filter (none registered)", api.ServiceType_SERVICE_TYPE_A2A, 0},
+ }
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ got := node.ListLocalServices(tc.filter)
+ if len(got) != tc.wantCount {
+ t.Errorf("expected %d services, got %d", tc.wantCount, len(got))
+ }
+ for _, s := range got {
+ if tc.filter != api.ServiceType_SERVICE_TYPE_UNSPECIFIED && s.Type != tc.filter {
+ t.Errorf("filter %v leaked service of type %v: %s", tc.filter, s.Type, s.Name)
+ }
+ }
+ })
+ }
+}
+
+func TestServiceTypeToCID_Properties(t *testing.T) {
+ mcp1, err := serviceTypeToCID(api.ServiceType_SERVICE_TYPE_MCP)
+ if err != nil {
+ t.Fatal(err)
+ }
+ mcp2, err := serviceTypeToCID(api.ServiceType_SERVICE_TYPE_MCP)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !mcp1.Equals(mcp2) {
+ t.Errorf("serviceTypeToCID is non-deterministic: %s vs %s", mcp1, mcp2)
+ }
+
+ inf, err := serviceTypeToCID(api.ServiceType_SERVICE_TYPE_INFERENCE)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if mcp1.Equals(inf) {
+ t.Errorf("expected distinct CIDs for distinct types, both = %s", mcp1)
+ }
+
+ named, err := serviceNameToCID(api.ServiceType_SERVICE_TYPE_MCP, "some-service")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if mcp1.Equals(named) {
+ t.Errorf("type-only CID collided with name-keyed CID: %s", mcp1)
+ }
+
+ if _, err := serviceTypeToCID(api.ServiceType_SERVICE_TYPE_UNSPECIFIED); err == nil {
+ t.Errorf("expected error for unspecified type")
+ }
+}
+
+// TestServiceKeyToCID_Equivalence pins the wire format: the public
+// helpers must compose into the same CID as a direct call to the
+// shared key builder, so optimizing the helpers later can't silently
+// shift the DHT keys.
+func TestServiceKeyToCID_Equivalence(t *testing.T) {
+ gotName, err := serviceNameToCID(api.ServiceType_SERVICE_TYPE_MCP, "svc")
+ if err != nil {
+ t.Fatal(err)
+ }
+ wantName, err := serviceKeyToCID("mcp", "svc")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !gotName.Equals(wantName) {
+ t.Errorf("serviceNameToCID != serviceKeyToCID: %s vs %s", gotName, wantName)
+ }
+
+ gotType, err := serviceTypeToCID(api.ServiceType_SERVICE_TYPE_MCP)
+ if err != nil {
+ t.Fatal(err)
+ }
+ wantType, err := serviceKeyToCID("mcp")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !gotType.Equals(wantType) {
+ t.Errorf("serviceTypeToCID != serviceKeyToCID: %s vs %s", gotType, wantType)
+ }
+}
+
func TestHandleRegisterService_Validation(t *testing.T) {
node := &SamNode{
services: make(map[string]*ServiceManifest),
diff --git a/tests/e2e/docker/calc-mcp/Dockerfile b/tests/e2e/docker/calc-mcp/Dockerfile
new file mode 100644
index 00000000..06851a1e
--- /dev/null
+++ b/tests/e2e/docker/calc-mcp/Dockerfile
@@ -0,0 +1,9 @@
+FROM python:3.12-slim
+
+WORKDIR /workspace
+COPY ./calc_server.py /workspace/calc_server.py
+COPY ./requirements.txt /workspace/requirements.txt
+RUN pip install -r requirements.txt
+
+CMD ["python3", "/workspace/calc_server.py"]
+
diff --git a/tests/e2e/docker/calc-mcp/calc_server.py b/tests/e2e/docker/calc-mcp/calc_server.py
new file mode 100644
index 00000000..8afdb528
--- /dev/null
+++ b/tests/e2e/docker/calc-mcp/calc_server.py
@@ -0,0 +1,21 @@
+"""Tiny MCP backend exposed by Node B as a 'calculator' service."""
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("calculator", host="0.0.0.0", port=7777)
+
+
+def add(a: float, b: float) -> float:
+ """Return a + b."""
+ return a + b
+
+
+def multiply(a: float, b: float) -> float:
+ """Return a * b."""
+ return a * b
+
+
+if __name__ == "__main__":
+ # Streamable-HTTP exposes a single /mcp endpoint that handles JSON-RPC.
+ mcp.run(transport="streamable-http")
diff --git a/tests/e2e/docker/calc-mcp/requirements.txt b/tests/e2e/docker/calc-mcp/requirements.txt
new file mode 100644
index 00000000..c413b608
--- /dev/null
+++ b/tests/e2e/docker/calc-mcp/requirements.txt
@@ -0,0 +1 @@
+mcp>=1.0.0
diff --git a/tests/e2e/docker/calc-mcp/sam-node-config.yaml b/tests/e2e/docker/calc-mcp/sam-node-config.yaml
new file mode 100644
index 00000000..69faf1bc
--- /dev/null
+++ b/tests/e2e/docker/calc-mcp/sam-node-config.yaml
@@ -0,0 +1,11 @@
+version: "v1alpha1"
+attenuation:
+ # Receiver-side: allow MCP only when the caller's biscuit was minted by
+ # our hub for some peer (zero-trust narrow than "any valid OIDC token").
+ policies:
+ - 'allow if operation("/sam/mcp/1.0.0"), node($peer)'
+services:
+ - type: "mcp"
+ name: "calculator"
+ description: "Simple math operations"
+ target_url: "http://calc-mcp:7777"
diff --git a/tests/e2e/lib/container_mesh.bash b/tests/e2e/lib/container_mesh.bash
index f8c46560..43899c8b 100644
--- a/tests/e2e/lib/container_mesh.bash
+++ b/tests/e2e/lib/container_mesh.bash
@@ -224,18 +224,29 @@ if [[ -z "${MESH_HELPERS_LOADED:-}" ]]; then
echo "Extracted Hub PeerID: ${peer_id}"
}
+ # Optional 3rd arg: host-relative path to a sam-node config yaml.
+ # When set, mounted into the container and passed via --config.
mesh_start_node() {
local idx="$1"
local flags="${2:-}"
+ local config_path="${3:-}"
local name="${MESH_PREFIX}-node-${idx}"
local hub_peer_id
hub_peer_id=$(cat "/tmp/${MESH_PREFIX}-hub-peer-id")
+ local mount_args=()
+ local config_args=()
+ if [[ -n "${config_path}" ]]; then
+ mount_args+=(-v "$(pwd)/${config_path}:/etc/sam/node-config.yaml:ro")
+ config_args+=(--config /etc/sam/node-config.yaml)
+ fi
+
docker run -d \
--name "${name}" \
--network "${MESH_NETWORK}" \
--network-alias "sam-node-${idx}" \
+ "${mount_args[@]}" \
"${MESH_RUNTIME_IMAGE}" \
/usr/local/bin/sam-node run \
${flags} \
@@ -247,7 +258,8 @@ if [[ -z "${MESH_HELPERS_LOADED:-}" ]]; then
--listen "/ip4/0.0.0.0/tcp/5002" \
--bind-addr "0.0.0.0:8080" \
--api-token "secret-token" \
- --mesh "e2e-mesh" >/dev/null
+ --mesh "e2e-mesh" \
+ "${config_args[@]}" >/dev/null
MESH_CONTAINERS+=("${name}")
}
diff --git a/tests/e2e/services.bats b/tests/e2e/services.bats
new file mode 100644
index 00000000..301010f2
--- /dev/null
+++ b/tests/e2e/services.bats
@@ -0,0 +1,106 @@
+#!/usr/bin/env bats
+
+load "lib/container_mesh.bash"
+
+CALC_MCP_IMAGE="sam-calc-mcp:local"
+
+build_calc_mcp_image() {
+ if ! docker image inspect "${CALC_MCP_IMAGE}" >/dev/null 2>&1; then
+ docker build -t "${CALC_MCP_IMAGE}" \
+ -f tests/e2e/docker/calc-mcp/Dockerfile \
+ tests/e2e/docker/calc-mcp >/dev/null
+ fi
+}
+
+start_calc_mcp() {
+ local name="${MESH_PREFIX}-calc-mcp"
+ docker run -d \
+ --name "${name}" \
+ --network "${MESH_NETWORK}" \
+ --network-alias calc-mcp \
+ "${CALC_MCP_IMAGE}" >/dev/null
+ MESH_CONTAINERS+=("${name}")
+}
+
+setup() {
+ if ! mesh_require_docker; then
+ skip "docker not available or daemon not running"
+ fi
+
+ if [[ ! -x "./bin/sam-node" || ! -x "./bin/sam-hub" || ! -x "./bin/mcp-client" ]]; then
+ skip "missing binaries; run: make build"
+ fi
+
+ mesh_setup_env
+ build_calc_mcp_image
+}
+
+teardown() {
+ mesh_cleanup_env
+}
+
+@test "Services: remote service is discoverable by type" {
+ run mesh_start_mock_oidc
+ [[ "$status" -eq 0 ]]
+
+ mesh_start_hub
+
+ echo "[$(date +%T)] Starting Node 1"
+ run mesh_start_node 1 "--discovery-interval 100ms --log-level debug"
+ [[ "$status" -eq 0 ]]
+ local node1_name="${MESH_PREFIX}-node-1"
+ mesh_wait_for_log "${node1_name}" "SAM Node Online" 60
+ mesh_wait_for_mcp_ready 1 20
+
+ echo "[$(date +%T)] Starting calc-mcp backend"
+ start_calc_mcp
+
+ echo "[$(date +%T)] Starting Node 2 (with calculator service config)"
+ run mesh_start_node 2 \
+ "--discovery-interval 100ms --log-level debug" \
+ "tests/e2e/docker/calc-mcp/sam-node-config.yaml"
+ [[ "$status" -eq 0 ]]
+ local node2_name="${MESH_PREFIX}-node-2"
+ mesh_wait_for_log "${node2_name}" "SAM Node Online" 20
+ mesh_wait_for_mcp_ready 2 20
+
+ local node2_peer_id
+ node2_peer_id=$(docker logs "${node2_name}" 2>&1 | grep "PeerID:" | head -n 1 | awk '{print $2}' | tr -d '\r')
+
+ echo "[$(date +%T)] Connecting Node 1 to Node 2"
+ local node2_addr="/dns4/sam-node-2/tcp/5002/p2p/${node2_peer_id}"
+ run docker run --rm --network "${MESH_NETWORK}" \
+ -v "$(pwd)/bin/mcp-client:/mcp-client" \
+ python:3.12 /mcp-client \
+ -url "http://sam-node-1:8080/mcp/events" \
+ -tool "connect_peer" \
+ -args "{\"peer_addr\":\"${node2_addr}\"}"
+ [[ "$status" -eq 0 ]]
+ mesh_wait_for_peer_connection 1 "${node2_peer_id}" 20
+
+ # Wait for the per-type rendezvous CID to propagate through the DHT.
+ sleep 2
+
+ echo "[$(date +%T)] Discovering MCP services from Node 1 (type-only)"
+ run docker run --rm --network "${MESH_NETWORK}" \
+ -v "$(pwd)/bin/mcp-client:/mcp-client" \
+ python:3.12 /mcp-client \
+ -url "http://sam-node-1:8080/mcp/events" \
+ -tool "discover_remote_services" \
+ -args '{"type":"mcp"}'
+ echo "Discovery output: $output"
+ [[ "$status" -eq 0 ]]
+
+ # mcp-client prints each text-content line; the catalog JSON is the last non-empty line.
+ local catalog
+ catalog=$(echo "$output" | tail -n 1)
+
+ local match_count
+ match_count=$(echo "$catalog" | jq --arg pid "${node2_peer_id}" '
+ [.[] | select(.srv_name == "calculator"
+ and .peer_id == $pid
+ and .srv_description == "Simple math operations")] | length
+ ')
+ echo "Matching entries: ${match_count}"
+ [[ "${match_count}" -eq 1 ]]
+}