Agent Mesh
Go a2aa2a-protocolagent-meshagentic-aiinferencemcpmeshmesh-networknetwork-securitynetworking-aip2p-network
Allow discovering remote services by type
Tomas Tormo0f43a276f871
diff --git a/api/sam.pb.go b/api/sam.pb.goindex 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.FileDescriptorconst 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.protoindex 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.goindex 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.goindex 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 toolmcp.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 toolmcp.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, toolNreturn 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 rejectedcallParams := &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, toolNreturn 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.goindex 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 Serverif 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.RegisterServiceRif 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.RegisterServiceRreturn 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.Handlervar 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 servicesdiff --git a/cmd/sam-node/sidecar_test.go b/cmd/sam-node/sidecar_test.goindex 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/Dockerfilenew file mode 100644index 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.pynew file mode 100644index 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.txtnew file mode 100644index 00000000..c413b608--- /dev/null+++ b/tests/e2e/docker/calc-mcp/requirements.txt@@ -0,0 +1 @@+mcp>=1.0.0diff --git a/tests/e2e/docker/calc-mcp/sam-node-config.yaml b/tests/e2e/docker/calc-mcp/sam-node-config.yamlnew file mode 100644index 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.bashindex 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:-}" ]]; thenecho "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_idhub_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/nullMESH_CONTAINERS+=("${name}")}diff --git a/tests/e2e/services.bats b/tests/e2e/services.batsnew file mode 100644index 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 ]]+}