Skip to content

Agent Mesh

add streamable discover api

Antonio Ojead366486b3c3f
diff --git a/cmd/sam-node/node.go b/cmd/sam-node/node.go
index 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.Add
if 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.Se
return 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.Se
return 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.go
index 74d35b10..81de19ce 100644
--- a/cmd/sam-node/sidecar.go
+++ b/cmd/sam-node/sidecar.go
@@ -15,19 +15,21 @@
package main
import (
+ "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.Request
serviceName := 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.Request
return
}
- 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)
return
diff --git a/tests/integration/service_discovery_test.go b/tests/integration/service_discovery_test.go
index 4a0f24f3..4911349f 100644
--- a/tests/integration/service_discovery_test.go
+++ b/tests/integration/service_discovery_test.go
@@ -15,6 +15,7 @@
package integration_test
import (
+ "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)