Skip to content

Agent Mesh

feat(discovery): implement pagination using limit/offset on HTTP discover endpoint and discover_remote_services MCP tool

Antonio Ojead99f7742ab46
diff --git a/internal/node/mcp_handlers.go b/internal/node/mcp_handlers.go
index 4c11e128..838a223b 100644
--- a/internal/node/mcp_handlers.go
+++ b/internal/node/mcp_handlers.go
@@ -61,8 +61,10 @@ func (n *SamNode) handleListLocalServices(ctx context.Context, req *mcp.CallTool
// DiscoverRemoteServicesParams defines the parameters for the discover_remote_services tool.
type DiscoverRemoteServicesParams struct {
- Type string `json:"type" jsonschema:"Service type (mcp, inference, a2a)"`
- Name string `json:"name,omitempty" jsonschema:"Optional service name. Omit to list all services of the given type."`
+ Type string `json:"type" jsonschema:"Service type (mcp, inference, a2a)"`
+ Name string `json:"name,omitempty" jsonschema:"Optional service name. Omit to list all services of the given type."`
+ Limit int `json:"limit,omitempty" jsonschema:"Optional limit for pagination. Defaults to 20."`
+ Offset int `json:"offset,omitempty" jsonschema:"Optional offset for pagination. Defaults to 0."`
}
// handleDiscoverRemoteServices implements the discover_remote_services tool.
@@ -75,6 +77,26 @@ func (n *SamNode) handleDiscoverRemoteServices(ctx context.Context, req *mcp.Cal
if err != nil {
return nil, nil, err
}
+
+ limit := params.Limit
+ if limit <= 0 {
+ limit = 20
+ }
+ offset := params.Offset
+ if offset < 0 {
+ offset = 0
+ }
+
+ if offset >= len(providers) {
+ providers = []*api.DiscoveredProvider{}
+ } else {
+ end := offset + limit
+ if end > len(providers) {
+ end = len(providers)
+ }
+ providers = providers[offset:end]
+ }
+
respData, err := json.Marshal(providers)
if err != nil {
return nil, nil, err
diff --git a/internal/node/node.go b/internal/node/node.go
index d1773d8f..f115d01c 100644
--- a/internal/node/node.go
+++ b/internal/node/node.go
@@ -1459,7 +1459,11 @@ func (n *SamNode) findProvidersByCID(ctx context.Context, c cid.Cid) ([]peer.Add
// 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, n.config.DHTLookupLimit) {
+ limit := n.config.DHTLookupLimit
+ if limit <= 0 {
+ limit = 20
+ }
+ for p := range n.DHT.FindProvidersAsync(lookupCtx, c, limit) {
providersMap[p.ID] = p
}
providers := make([]peer.AddrInfo, 0, len(providersMap))
@@ -1565,7 +1569,11 @@ func (n *SamNode) DiscoverRemoteServicesStream(ctx context.Context, serviceType
fanoutCtx, cancel := context.WithTimeout(ctx, discoveryFanoutTimeout)
defer cancel()
- sem := make(chan struct{}, n.config.DiscoveryConcurrency)
+ concurrency := n.config.DiscoveryConcurrency
+ if concurrency <= 0 {
+ concurrency = 10
+ }
+ sem := make(chan struct{}, concurrency)
var wg sync.WaitGroup
for _, p := range peers {
if p.ID == n.Host.ID() {
@@ -1643,7 +1651,11 @@ func (n *SamNode) discoverServicesByType(ctx context.Context, serviceType api.Se
services []*api.ServiceInfo
}
results := make(chan peerCatalog, len(peers))
- sem := make(chan struct{}, n.config.DiscoveryConcurrency)
+ concurrency := n.config.DiscoveryConcurrency
+ if concurrency <= 0 {
+ concurrency = 10
+ }
+ sem := make(chan struct{}, concurrency)
var wg sync.WaitGroup
for _, p := range peers {
if p.ID == n.Host.ID() {
diff --git a/internal/node/sidecar.go b/internal/node/sidecar.go
index 12ee3897..7441be4c 100644
--- a/internal/node/sidecar.go
+++ b/internal/node/sidecar.go
@@ -26,6 +26,7 @@ import (
"net/http"
"net/http/httputil"
"os"
+ "strconv"
"strings"
"time"
@@ -385,12 +386,37 @@ func handleDiscoverService(node *SamNode, w http.ResponseWriter, r *http.Request
}
}
+ limitStr := r.URL.Query().Get("limit")
+ offsetStr := r.URL.Query().Get("offset")
+ limit := 20
+ offset := 0
+ if limitStr != "" {
+ if l, err := strconv.Atoi(limitStr); err == nil && l > 0 {
+ limit = l
+ }
+ }
+ if offsetStr != "" {
+ if o, err := strconv.Atoi(offsetStr); err == nil && o >= 0 {
+ offset = o
+ }
+ }
+
providers, err := node.DiscoverRemoteServices(ctx, serviceType, serviceName)
if err != nil {
http.Error(w, fmt.Sprintf("Failed to discover services: %v", err), http.StatusInternalServerError)
return
}
+ if offset >= len(providers) {
+ providers = []*api.DiscoveredProvider{}
+ } else {
+ end := offset + limit
+ if end > len(providers) {
+ end = len(providers)
+ }
+ providers = providers[offset:end]
+ }
+
w.Header().Set("Content-Type", "application/json")
if err := json.NewEncoder(w).Encode(providers); err != nil {
logger.Errorf("Failed to encode providers: %v", err)
diff --git a/internal/node/sidecar_test.go b/internal/node/sidecar_test.go
index aba2c3e2..ea075673 100644
--- a/internal/node/sidecar_test.go
+++ b/internal/node/sidecar_test.go
@@ -28,6 +28,7 @@ import (
"github.com/libp2p/go-libp2p"
dht "github.com/libp2p/go-libp2p-kad-dht"
+ "github.com/libp2p/go-libp2p/core/host"
"github.com/libp2p/go-libp2p/core/peer"
"github.com/modelcontextprotocol/go-sdk/mcp"
"google.golang.org/protobuf/encoding/protojson"
@@ -543,3 +544,109 @@ func TestStartSidecarServer_TokenMandatory(t *testing.T) {
}
}
}
+
+func TestDiscoverService_Pagination(t *testing.T) {
+ h, err := libp2p.New(libp2p.ListenAddrStrings("/ip4/127.0.0.1/tcp/0"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer func() { _ = h.Close() }()
+ d, err := dht.New(context.Background(), h, dht.Mode(dht.ModeServer), dht.ProtocolPrefix("/sam"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer func() { _ = d.Close() }()
+
+ node := &SamNode{
+ BiscuitTimeout: 500 * time.Millisecond,
+ services: NewServiceRegistry(d),
+ DHT: d,
+ Host: h,
+ BoundHTTPAddr: "127.0.0.1:8080",
+ }
+
+ var hosts []host.Host
+ var dhts []*dht.IpfsDHT
+ defer func() {
+ for _, hs := range hosts {
+ _ = hs.Close()
+ }
+ for _, dt := range dhts {
+ _ = dt.Close()
+ }
+ }()
+
+ serviceInfo := &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: "paginated-service"}
+ c, err := serviceNameToCID(serviceInfo.Type, serviceInfo.Name)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ for i := 0; i < 3; i++ {
+ h2, err := libp2p.New(libp2p.ListenAddrStrings("/ip4/127.0.0.1/tcp/0"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ hosts = append(hosts, h2)
+
+ d2, err := dht.New(context.Background(), h2, dht.Mode(dht.ModeServer), dht.ProtocolPrefix("/sam"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ dhts = append(dhts, d2)
+
+ err = h.Connect(context.Background(), peer.AddrInfo{ID: h2.ID(), Addrs: h2.Addrs()})
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ _ = d2.Provide(context.Background(), c, true)
+ }
+
+ time.Sleep(200 * time.Millisecond) // Wait for DHT propagation
+
+ // 1. Query page 1 (limit=2, offset=0)
+ req := httptest.NewRequest("GET", "/sam/service/discover?type=mcp&name=paginated-service&limit=2&offset=0", nil)
+ rr := httptest.NewRecorder()
+ handleDiscoverService(node, rr, req)
+ if rr.Code != http.StatusOK {
+ t.Errorf("expected status OK, got %d, body: %s", rr.Code, rr.Body.String())
+ }
+ var page1 []*api.DiscoveredProvider
+ if err := json.NewDecoder(rr.Body).Decode(&page1); err != nil {
+ t.Fatal(err)
+ }
+ if len(page1) != 2 {
+ t.Errorf("expected 2 providers on page 1, got %d", len(page1))
+ }
+
+ // 2. Query page 2 (limit=2, offset=2)
+ req2 := httptest.NewRequest("GET", "/sam/service/discover?type=mcp&name=paginated-service&limit=2&offset=2", nil)
+ rr2 := httptest.NewRecorder()
+ handleDiscoverService(node, rr2, req2)
+ if rr2.Code != http.StatusOK {
+ t.Errorf("expected status OK, got %d, body: %s", rr2.Code, rr2.Body.String())
+ }
+ var page2 []*api.DiscoveredProvider
+ if err := json.NewDecoder(rr2.Body).Decode(&page2); err != nil {
+ t.Fatal(err)
+ }
+ if len(page2) != 1 {
+ t.Errorf("expected 1 provider on page 2, got %d", len(page2))
+ }
+
+ // 3. Query page 3 (limit=2, offset=4)
+ req3 := httptest.NewRequest("GET", "/sam/service/discover?type=mcp&name=paginated-service&limit=2&offset=4", nil)
+ rr3 := httptest.NewRecorder()
+ handleDiscoverService(node, rr3, req3)
+ if rr3.Code != http.StatusOK {
+ t.Errorf("expected status OK, got %d, body: %s", rr3.Code, rr3.Body.String())
+ }
+ var page3 []*api.DiscoveredProvider
+ if err := json.NewDecoder(rr3.Body).Decode(&page3); err != nil {
+ t.Fatal(err)
+ }
+ if len(page3) != 0 {
+ t.Errorf("expected 0 providers on page 3, got %d", len(page3))
+ }
+}