Agent Mesh
Go a2aa2a-protocolagent-meshagentic-aiinferencemcpmeshmesh-networknetwork-securitynetworking-aip2p-network
add streamable discover api
Antonio Ojead366486b3c3f
diff --git a/cmd/sam-node/node.go b/cmd/sam-node/node.goindex a40e2d3d..03c49d69 100644--- a/cmd/sam-node/node.go+++ b/cmd/sam-node/node.go@@ -749,7 +749,13 @@ func (n *SamNode) findProvidersByCID(ctx context.Context, c cid.Cid) ([]peer.Addif n.DHT == nil {return nil, fmt.Errorf("DHT not initialized")}- lookupCtx, cancel := context.WithTimeout(ctx, dhtLookupTimeout)+ timeout := dhtLookupTimeout+ if deadline, ok := ctx.Deadline(); ok {+ if remaining := time.Until(deadline); remaining > 0 {+ timeout = remaining+ }+ }+ lookupCtx, cancel := context.WithTimeout(ctx, timeout)defer cancel()// FindProvidersAsync can emit the same peer multiple times when the// DHT walk converges from different paths; dedupe so downstream@@ -802,6 +808,92 @@ func (n *SamNode) DiscoverRemoteServices(ctx context.Context, serviceType api.Sereturn n.discoverServicesByName(ctx, serviceType, typeStr, serviceName)}+// DiscoverRemoteServicesStream performs service discovery and streams results down the returned channel.+// The channel is closed automatically when discovery completes or the context is cancelled.+func (n *SamNode) DiscoverRemoteServicesStream(ctx context.Context, serviceType api.ServiceType, serviceName string) (<-chan *api.DiscoveredProvider, error) {+ typeStr, err := serviceTypeToString(serviceType)+ if err != nil {+ return nil, err+ }++ out := make(chan *api.DiscoveredProvider, 16)++ go func() {+ defer close(out)++ if serviceName != "" {+ peers, err := n.FindProvidersByName(ctx, serviceType, serviceName)+ if err != nil {+ logger.Errorf("[Discovery] FindProvidersByName failed: %v", err)+ return+ }+ for _, p := range peers {+ if p.ID == n.Host.ID() {+ continue+ }+ select {+ case <-ctx.Done():+ return+ case out <- &api.DiscoveredProvider{+ PeerId: p.ID.String(),+ LocalProxyUrl: n.localProxyURL(p.ID, typeStr, serviceName),+ SrvName: serviceName,+ }:+ }+ }+ return+ }++ peers, err := n.FindProvidersByType(ctx, serviceType)+ if err != nil {+ logger.Errorf("[Discovery] FindProvidersByType failed: %v", err)+ return+ }++ timeout := discoveryFanoutTimeout+ if deadline, ok := ctx.Deadline(); ok {+ if remaining := time.Until(deadline); remaining > 0 {+ timeout = remaining+ }+ }+ fanoutCtx, cancel := context.WithTimeout(ctx, timeout)+ defer cancel()++ 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+ }+ for _, info := range services {+ dp := &api.DiscoveredProvider{+ PeerId: peerID.String(),+ LocalProxyUrl: n.localProxyURL(peerID, typeStr, info.Name),+ SrvName: info.Name,+ SrvDescription: info.Description,+ }+ select {+ case <-fanoutCtx.Done():+ return+ case out <- dp:+ }+ }+ }(p.ID)+ }+ wg.Wait()+ }()++ return out, nil+}++// 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)@@ -830,7 +922,13 @@ func (n *SamNode) discoverServicesByType(ctx context.Context, serviceType api.Sereturn nil, err}- fanoutCtx, cancel := context.WithTimeout(ctx, discoveryFanoutTimeout)+ timeout := discoveryFanoutTimeout+ if deadline, ok := ctx.Deadline(); ok {+ if remaining := time.Until(deadline); remaining > 0 {+ timeout = remaining+ }+ }+ fanoutCtx, cancel := context.WithTimeout(ctx, timeout)defer cancel()type peerCatalog struct {diff --git a/cmd/sam-node/sidecar.go b/cmd/sam-node/sidecar.goindex 74d35b10..81de19ce 100644--- a/cmd/sam-node/sidecar.go+++ b/cmd/sam-node/sidecar.go@@ -15,19 +15,21 @@package mainimport (+ "context""crypto/tls""crypto/x509""encoding/json""fmt""io""net"- "google.golang.org/protobuf/encoding/protojson""net/http""net/http/httputil""os""strings"+ "time""github.com/google/sam/api"+ "google.golang.org/protobuf/encoding/protojson"libp2phttp "github.com/libp2p/go-libp2p-http")@@ -242,8 +244,8 @@ func handleDiscoverService(node *SamNode, w http.ResponseWriter, r *http.RequestserviceName := r.URL.Query().Get("name")serviceTypeStr := r.URL.Query().Get("type")- if serviceName == "" || serviceTypeStr == "" {- http.Error(w, "name and type query parameters are required", http.StatusBadRequest)+ if serviceTypeStr == "" {+ http.Error(w, "type query parameter is required", http.StatusBadRequest)return}@@ -253,7 +255,74 @@ func handleDiscoverService(node *SamNode, w http.ResponseWriter, r *http.Requestreturn}- providers, err := node.DiscoverRemoteServices(r.Context(), serviceType, serviceName)+ timeoutStr := r.URL.Query().Get("timeout")+ var customTimeout time.Duration+ if timeoutStr != "" {+ customTimeout, err = time.ParseDuration(timeoutStr)+ if err != nil {+ http.Error(w, fmt.Sprintf("Invalid timeout parameter: %v", err), http.StatusBadRequest)+ return+ }+ }++ ctx := r.Context()+ if customTimeout > 0 {+ var cancel context.CancelFunc+ ctx, cancel = context.WithTimeout(ctx, customTimeout)+ defer cancel()+ }++ streamParam := r.URL.Query().Get("stream")+ acceptHeader := r.Header.Get("Accept")+ isStreaming := streamParam == "true" || acceptHeader == "text/event-stream"++ if isStreaming {+ w.Header().Set("Content-Type", "text/event-stream")+ w.Header().Set("Cache-Control", "no-cache")+ w.Header().Set("Connection", "keep-alive")++ flusher, ok := w.(http.Flusher)+ if !ok {+ http.Error(w, "Streaming unsupported", http.StatusInternalServerError)+ return+ }++ out, err := node.DiscoverRemoteServicesStream(ctx, serviceType, serviceName)+ if err != nil {+ logger.Errorf("Failed to start streaming service discovery: %v", err)+ if _, err := fmt.Fprintf(w, "event: error\ndata: %s\n\n", err.Error()); err != nil {+ logger.Errorf("Failed to write SSE error: %v", err)+ }+ flusher.Flush()+ return+ }++ for {+ select {+ case <-ctx.Done():+ return+ case dp, ok := <-out:+ if !ok {+ if _, err := fmt.Fprintf(w, "event: done\ndata: {}\n\n"); err != nil {+ logger.Errorf("Failed to write SSE done: %v", err)+ }+ flusher.Flush()+ return+ }+ data, err := json.Marshal(dp)+ if err != nil {+ logger.Errorf("Failed to marshal discovered provider: %v", err)+ continue+ }+ if _, err := fmt.Fprintf(w, "data: %s\n\n", data); err != nil {+ logger.Errorf("Failed to write SSE data: %v", err)+ }+ flusher.Flush()+ }+ }+ }++ providers, err := node.DiscoverRemoteServices(ctx, serviceType, serviceName)if err != nil {http.Error(w, fmt.Sprintf("Failed to discover services: %v", err), http.StatusInternalServerError)returndiff --git a/tests/integration/service_discovery_test.go b/tests/integration/service_discovery_test.goindex 4a0f24f3..4911349f 100644--- a/tests/integration/service_discovery_test.go+++ b/tests/integration/service_discovery_test.go@@ -15,6 +15,7 @@package integration_testimport (+ "bufio""bytes""encoding/json""google.golang.org/protobuf/encoding/protojson"@@ -128,6 +129,149 @@ func TestServiceDiscovery(t *testing.T) {t.Log("Service discovery test passed.")}+func TestServiceDiscoveryStreaming(t *testing.T) {+ nodeBin := buildBinary(t, "./cmd/sam-node")+ _, hubAddr := startMockLibp2pHub(t)++ homeA := t.TempDir()+ homeB := t.TempDir()++ apiToken := "secret-token"++ // Start Node A+ t.Log("Starting Node A...")+ _ = startBackgroundNode(t, nodeBin, hubAddr, homeA,+ "--listen", "/ip4/127.0.0.1/udp/0/quic-v1",+ "--listen", "/ip4/127.0.0.1/tcp/0",+ "--discovery-interval", "100ms",+ "--bind-addr", "127.0.0.1:0",+ "--api-token", apiToken,+ )++ // Start Node B+ t.Log("Starting Node B...")+ _ = startBackgroundNode(t, nodeBin, hubAddr, homeB,+ "--listen", "/ip4/127.0.0.1/udp/0/quic-v1",+ "--listen", "/ip4/127.0.0.1/tcp/0",+ "--discovery-interval", "100ms",+ "--bind-addr", "127.0.0.1:0",+ "--api-token", apiToken,+ )++ // Resolve actual addresses from logs+ actualApiAddrA := waitForMCPAddr(t, filepath.Join(homeA, "node.log"))+ actualApiAddrB := waitForMCPAddr(t, filepath.Join(homeB, "node.log"))++ // Wait for nodes to start sidecar API+ waitForAPI(t, actualApiAddrA)+ waitForAPI(t, actualApiAddrB)++ addrA := waitForPeerInfoInLog(t, filepath.Join(homeA, "node.log"))++ // Connect Node B to Node A+ callMCP(t, actualApiAddrB, "connect_peer", map[string]any{"peer_addr": addrA})++ // Wait for DHT to have peers on Node A+ t.Log("Waiting for DHT to have peers on Node A...")+ deadline := time.Now().Add(10 * time.Second)+ var dhtReady bool+ for time.Now().Before(deadline) {+ respData := callMCP(t, actualApiAddrA, "get_mesh_info", map[string]any{})+ var data map[string]any+ if err := json.Unmarshal([]byte(respData), &data); err == nil {+ dhtSize, _ := data["dht_size"].(float64)+ if dhtSize > 0 {+ dhtReady = true+ break+ }+ }+ time.Sleep(500 * time.Millisecond)+ }+ if !dhtReady {+ t.Fatalf("DHT not ready on Node A")+ }++ // Agent A registers a service+ serviceName := "mcp:github-tools"+ registerService(t, actualApiAddrA, apiToken, serviceName)++ // Wait for DHT propagation+ t.Log("Waiting for DHT propagation...")+ time.Sleep(2 * time.Second)++ // Call streaming endpoint with invalid timeout first to verify validation+ t.Log("Testing invalid timeout query parameter...")+ badReq, _ := http.NewRequest("GET", "http://"+actualApiAddrB+"/sam/service/discover?type=mcp&name="+serviceName+"&stream=true&timeout=invalid", nil)+ badReq.Header.Set("Authorization", "Bearer "+apiToken)+ badResp, err := http.DefaultClient.Do(badReq)+ if err != nil {+ t.Fatal(err)+ }+ _ = badResp.Body.Close()+ if badResp.StatusCode != http.StatusBadRequest {+ t.Fatalf("Expected StatusBadRequest for invalid timeout, got %d", badResp.StatusCode)+ }++ // Agent B queries the streaming endpoint via HTTP Sidecar+ t.Log("Agent B discovering service via SSE stream...")+ req, _ := http.NewRequest("GET", "http://"+actualApiAddrB+"/sam/service/discover?type=mcp&name="+serviceName+"&stream=true&timeout=5s", nil)+ req.Header.Set("Authorization", "Bearer "+apiToken)++ resp, err := http.DefaultClient.Do(req)+ if err != nil {+ t.Fatalf("Failed to request streaming discovery: %v", err)+ }+ defer func() { _ = resp.Body.Close() }()++ if resp.StatusCode != http.StatusOK {+ t.Fatalf("Streaming discovery failed with status: %d", resp.StatusCode)+ }++ contentType := resp.Header.Get("Content-Type")+ if !strings.HasPrefix(contentType, "text/event-stream") {+ t.Fatalf("Expected Content-Type text/event-stream, got %q", contentType)+ }++ // Parse stream chunk-by-chunk+ reader := bufio.NewReader(resp.Body)+ peerIDA := getPeerIDFromAddr(addrA)+ var foundStreamed bool++ for {+ line, err := reader.ReadString('\n')+ if err == io.EOF {+ break+ }+ if err != nil {+ t.Fatalf("Failed to read SSE line: %v", err)+ }++ line = strings.TrimSpace(line)+ if strings.HasPrefix(line, "data:") {+ dataContent := strings.TrimSpace(strings.TrimPrefix(line, "data:"))+ if dataContent == "{}" {+ continue // Done event or keep-alive empty JSON+ }+ var provider api.DiscoveredProvider+ if err := json.Unmarshal([]byte(dataContent), &provider); err == nil {+ if provider.PeerId == peerIDA.String() {+ foundStreamed = true+ }+ }+ }+ if strings.HasPrefix(line, "event: done") {+ break+ }+ }++ if !foundStreamed {+ t.Fatalf("Failed to stream and find provider Node A in SSE results")+ }++ // Agent A unregisters the service+ unregisterService(t, actualApiAddrA, apiToken, serviceName)+}+func waitForAPI(t *testing.T, addr string) {t.Helper()deadline := time.Now().Add(5 * time.Second)