Agent Mesh
Go a2aa2a-protocolagent-meshagentic-aiinferencemcpmeshmesh-networknetwork-securitynetworking-aip2p-network
hub node mesh
Antonio Ojea3c82304fcb4d
diff --git a/cmd/sam-hub/main.go b/cmd/sam-hub/main.goindex 86206b95..453140d5 100644--- a/cmd/sam-hub/main.go+++ b/cmd/sam-hub/main.go@@ -51,6 +51,7 @@ import ("github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/relay"libp2ptls "github.com/libp2p/go-libp2p/p2p/security/tls""github.com/multiformats/go-multiaddr"+ madns "github.com/multiformats/go-multiaddr-dns""golang.org/x/time/rate"@@ -58,6 +59,20 @@ import ("google.golang.org/protobuf/proto")+func init() {+ if dnsServer := os.Getenv("SAM_TEST_DNS_SERVER"); dnsServer != "" {+ customResolver := &net.Resolver{+ PreferGo: true,+ Dial: func(ctx context.Context, network, address string) (net.Conn, error) {+ d := net.Dialer{Timeout: 5 * time.Second}+ return d.DialContext(ctx, "udp", dnsServer)+ },+ }+ net.DefaultResolver = customResolver+ madns.DefaultResolver, _ = madns.NewResolver(madns.WithDefaultResolver(customResolver))+ }+}+const (GracePeriod = 60 * time.Second@@ -635,6 +650,10 @@ func main() {// Start key rotation if enabledh.startRotation(ctx)+ if len(externalMultiaddrs) > 0 {+ go startBootstrapFederation(ctx, h, externalMultiaddrs)+ }+mux := http.NewServeMux()mux.Handle("/metrics", promhttp.HandlerFor(prometheus.DefaultGatherer, promhttp.HandlerOpts{}))mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {@@ -899,3 +918,46 @@ func (h *Hub) HandleAuthHandshake(s network.Stream) {logger.Errorf("[AuthN] Failed to write ACK to %s: %v", remotePeer, err)}}++func startBootstrapFederation(ctx context.Context, h *Hub, peers []string) {+ if len(peers) == 0 {+ return+ }+ ticker := time.NewTicker(30 * time.Second)+ defer ticker.Stop()++ connectBootstrap(ctx, h, peers)++ for {+ select {+ case <-ctx.Done():+ return+ case <-ticker.C:+ connectBootstrap(ctx, h, peers)+ }+ }+}++func connectBootstrap(ctx context.Context, h *Hub, peers []string) {+ for _, peerStr := range peers {+ ma, err := multiaddr.NewMultiaddr(peerStr)+ if err != nil {+ continue+ }+ resolvedAddrs, err := madns.DefaultResolver.Resolve(ctx, ma)+ if err != nil {+ resolvedAddrs = []multiaddr.Multiaddr{ma}+ }+ for _, resolved := range resolvedAddrs {+ pi, err := peer.AddrInfoFromP2pAddr(resolved)+ if err != nil || pi.ID == h.Host.ID() {+ continue+ }+ if len(h.Host.Network().ConnsToPeer(pi.ID)) == 0 {+ if err := h.Host.Connect(ctx, *pi); err == nil {+ logger.Infof("[Federation] Connected to bootstrap peer: %s via %s", pi.ID, peerStr)+ }+ }+ }+ }+}diff --git a/cmd/sam-node/main.go b/cmd/sam-node/main.goindex 8954cd14..41c56bdf 100644--- a/cmd/sam-node/main.go+++ b/cmd/sam-node/main.go@@ -249,6 +249,7 @@ func main() {newHubAddrs = append(newHubAddrs, ma)}+ logger.Debugf("listenAddrs: %v, allowLoopback: %v", listenAddrs, allowLoopbackFlag)node, err = NewSamNode(context.Background(), priv, hubPubKey, newHubAddrs, store, meshFlag, discoveryIntervalFlag, listenAddrs, enableRelayFlag, nodeConfig, keyGracePeriodFlag, allowLoopbackFlag)if err != nil {logger.Fatalf("Failed to start mesh node after enrollment: %v", err)diff --git a/go.mod b/go.modindex 1048618c..9da3ff9f 100644--- a/go.mod+++ b/go.mod@@ -17,12 +17,14 @@ require (github.com/libp2p/go-msgio v0.3.0github.com/modelcontextprotocol/go-sdk v1.6.1github.com/multiformats/go-multiaddr v0.16.1+ github.com/multiformats/go-multiaddr-dns v0.5.0github.com/multiformats/go-multihash v0.2.3github.com/openai/openai-go v1.12.0github.com/prometheus/client_golang v1.23.2github.com/prometheus/client_model v0.6.2github.com/spf13/cobra v1.10.2go.etcd.io/bbolt v1.4.3+ golang.org/x/net v0.55.0golang.org/x/oauth2 v0.36.0golang.org/x/time v0.15.0google.golang.org/protobuf v1.36.11@@ -77,7 +79,6 @@ require (github.com/mr-tron/base58 v1.3.0 // indirectgithub.com/multiformats/go-base32 v0.1.0 // indirectgithub.com/multiformats/go-base36 v0.2.0 // indirect- github.com/multiformats/go-multiaddr-dns v0.5.0 // indirectgithub.com/multiformats/go-multiaddr-fmt v0.1.0 // indirectgithub.com/multiformats/go-multibase v0.3.0 // indirectgithub.com/multiformats/go-multicodec v0.10.0 // indirect@@ -130,7 +131,6 @@ require (golang.org/x/crypto v0.52.0 // indirectgolang.org/x/exp v0.0.0-20260603202125-055de637280b // indirectgolang.org/x/mod v0.36.0 // indirect- golang.org/x/net v0.55.0 // indirectgolang.org/x/sync v0.20.0 // indirectgolang.org/x/sys v0.45.0 // indirectgolang.org/x/telemetry v0.0.0-20260603145448-488200d49c17 // indirectdiff --git a/tests/integration/fakedns_test.go b/tests/integration/fakedns_test.gonew file mode 100644index 00000000..8f56216d--- /dev/null+++ b/tests/integration/fakedns_test.go@@ -0,0 +1,140 @@+package integration_test++import (+ "context"+ "fmt"+ "net"+ "strings"+ "sync"+ "testing"++ "golang.org/x/net/dns/dnsmessage"+)++var dnsHijackLock sync.Mutex++type FakeDNSServer struct {+ hosts map[string]net.IP+ txtHosts map[string][]string+ conn *net.UDPConn+ mu sync.RWMutex+}++func NewFakeDNSServer(hosts map[string]string, txtHosts map[string][]string) (*FakeDNSServer, error) {+ parsedHosts := make(map[string]net.IP, len(hosts))+ for domain, ipStr := range hosts {+ ip := net.ParseIP(ipStr)+ if ip == nil {+ return nil, fmt.Errorf("invalid IP address for domain %s: %s", domain, ipStr)+ }+ parsedHosts[strings.TrimSuffix(domain, ".")] = ip+ }++ parsedTxtHosts := make(map[string][]string, len(txtHosts))+ for domain, txts := range txtHosts {+ parsedTxtHosts[strings.TrimSuffix(domain, ".")] = txts+ }++ addr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")+ if err != nil {+ return nil, err+ }+ conn, err := net.ListenUDP("udp", addr)+ if err != nil {+ return nil, err+ }++ server := &FakeDNSServer{+ hosts: parsedHosts,+ txtHosts: parsedTxtHosts,+ conn: conn,+ }+ go server.serve()+ return server, nil+}++func (s *FakeDNSServer) UpdateTXT(domain string, txts []string) {+ s.mu.Lock()+ defer s.mu.Unlock()+ s.txtHosts[strings.TrimSuffix(domain, ".")] = txts+}++func (s *FakeDNSServer) serve() {+ buf := make([]byte, 512)+ for {+ n, addr, err := s.conn.ReadFromUDP(buf)+ if err != nil {+ return+ }+ var msg dnsmessage.Message+ if err := msg.Unpack(buf[:n]); err != nil {+ continue+ }++ resp := dnsmessage.Message{+ Header: dnsmessage.Header{+ ID: msg.Header.ID,+ Response: true,+ Authoritative: true,+ },+ Questions: msg.Questions,+ }++ if len(msg.Questions) > 0 {+ q := msg.Questions[0]+ domain := strings.TrimSuffix(q.Name.String(), ".")++ s.mu.RLock()+ if q.Type == dnsmessage.TypeA || q.Type == dnsmessage.TypeAAAA {+ if ip, ok := s.hosts[domain]; ok {+ if ipv4 := ip.To4(); ipv4 != nil && q.Type == dnsmessage.TypeA {+ resp.Answers = append(resp.Answers, dnsmessage.Resource{+ Header: dnsmessage.ResourceHeader{Name: q.Name, Type: dnsmessage.TypeA, Class: dnsmessage.ClassINET, TTL: 300},+ Body: &dnsmessage.AResource{A: [4]byte(ipv4)},+ })+ } else if q.Type == dnsmessage.TypeAAAA && ip.To4() == nil {+ resp.Answers = append(resp.Answers, dnsmessage.Resource{+ Header: dnsmessage.ResourceHeader{Name: q.Name, Type: dnsmessage.TypeAAAA, Class: dnsmessage.ClassINET, TTL: 300},+ Body: &dnsmessage.AAAAResource{AAAA: [16]byte(ip)},+ })+ }+ }+ } else if q.Type == dnsmessage.TypeTXT {+ if txtRecords, ok := s.txtHosts[domain]; ok {+ for _, txt := range txtRecords {+ resp.Answers = append(resp.Answers, dnsmessage.Resource{+ Header: dnsmessage.ResourceHeader{Name: q.Name, Type: dnsmessage.TypeTXT, Class: dnsmessage.ClassINET, TTL: 300},+ Body: &dnsmessage.TXTResource{TXT: []string{txt}},+ })+ }+ }+ }+ s.mu.RUnlock()+ }++ packed, err := resp.Pack()+ if err == nil {+ s.conn.WriteToUDP(packed, addr)+ }+ }+}++func (s *FakeDNSServer) Hijack(t *testing.T) {+ t.Helper()+ dnsHijackLock.Lock()++ originalDial := net.DefaultResolver.Dial+ originalPreferGo := net.DefaultResolver.PreferGo++ net.DefaultResolver.PreferGo = true+ net.DefaultResolver.Dial = func(ctx context.Context, network, address string) (net.Conn, error) {+ return net.Dial("udp", s.conn.LocalAddr().String())+ }++ t.Cleanup(func() {+ net.DefaultResolver.Dial = originalDial+ net.DefaultResolver.PreferGo = originalPreferGo+ s.conn.Close()+ dnsHijackLock.Unlock()+ })+}diff --git a/tests/integration/federation_test.go b/tests/integration/federation_test.gonew file mode 100644index 00000000..913869b8--- /dev/null+++ b/tests/integration/federation_test.go@@ -0,0 +1,322 @@+package integration_test++import (+ "bytes"+ "context"+ "fmt"+ "io"+ "net/http"+ "net/http/httptest"+ "os"+ "os/exec"+ "path/filepath"+ "regexp"+ "strings"+ "testing"+ "time"++ "github.com/google/sam/api"+ "google.golang.org/protobuf/proto"+)++func TestHubFederationAndRelay(t *testing.T) {+ hubBin := buildBinary(t, "./cmd/sam-hub")+ nodeBin := buildBinary(t, "./cmd/sam-node")+ clientBin := buildBinary(t, "./cmd/mcp-client")++ tmpDir := t.TempDir()++ // Create a mock policy file+ policyFile := filepath.Join(tmpDir, "policies.yaml")+ policyContent := `version: "v1alpha1"+bindings:+ - user: mock-user+ role: admin+roles:+ admin:+ mcp:+ allowed_tools:+ - "/sam/mcp/1.0.0"+ - "list_local_services"+ - "discover_remote_services"+ - "federated-tool"+`+ if err := os.WriteFile(policyFile, []byte(policyContent), 0644); err != nil {+ t.Fatal(err)+ }++ portA := getFreePort(t)+ portB := getFreePort(t)+ p2pPortA := getFreePort(t)+ p2pPortB := getFreePort(t)++ // Start Fake DNS Server+ dnsServer, err := NewFakeDNSServer(map[string]string{+ "test-hub.local": "127.0.0.1",+ }, map[string][]string{})+ if err != nil {+ t.Fatalf("failed to start fake dns: %v", err)+ }+ t.Cleanup(func() { dnsServer.Hijack(t) })++ // Start Hub A+ // Mock OIDC+ oidcURL, jwtTokenStr := startMockOIDC(t)++ cmdA := exec.Command(hubBin,+ "--bind-address", fmt.Sprintf("127.0.0.1:%d", portA),+ "--listen", fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", p2pPortA),+ "--policy-file", policyFile,+ "--keys-db", filepath.Join(tmpDir, "keysA.db"),+ "--allow-loopback",+ "--external-multiaddr", "/dnsaddr/test-hub.local",+ "--issuer", oidcURL,+ "--insecure-skip-tls-verify",+ "--key", "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",+ )+ cmdA.Env = append(os.Environ(), "SAM_TEST_DNS_SERVER="+dnsServer.conn.LocalAddr().String())+ var stdoutA, stderrA safeBuffer+ cmdA.Stdout = &stdoutA+ cmdA.Stderr = &stderrA++ if err := cmdA.Start(); err != nil {+ t.Fatalf("failed to start Hub A: %v", err)+ }+ defer func() { _ = cmdA.Process.Kill() }()++ // Fetch Hub A's Peer ID (which actively loops and waits for readiness)+ peerIDA := fetchPeerID(t, portA)++ // Update Fake DNS with Hub A's TXT record+ dnsServer.UpdateTXT("_dnsaddr.test-hub.local", []string{+ fmt.Sprintf("dnsaddr=/ip4/127.0.0.1/tcp/%d/p2p/%s", p2pPortA, peerIDA),+ })++ // Start Hub B, explicitly federating with Hub A via DNS+ cmdB := exec.Command(hubBin,+ "--bind-address", fmt.Sprintf("127.0.0.1:%d", portB),+ "--listen", fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", p2pPortB),+ "--policy-file", policyFile,+ "--keys-db", filepath.Join(tmpDir, "keysB.db"),+ "--allow-loopback",+ "--external-multiaddr", "/dnsaddr/test-hub.local",+ "--issuer", oidcURL,+ "--insecure-skip-tls-verify",+ "--key", "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",+ )+ cmdB.Env = append(os.Environ(), "SAM_TEST_DNS_SERVER="+dnsServer.conn.LocalAddr().String())+ var stdoutB, stderrB safeBuffer+ cmdB.Stdout = io.MultiWriter(os.Stdout, &stdoutB)+ cmdB.Stderr = io.MultiWriter(os.Stderr, &stderrB)++ if err := cmdB.Start(); err != nil {+ t.Fatalf("failed to start Hub B: %v", err)+ }+ defer func() { _ = cmdB.Process.Kill() }()++ time.Sleep(2 * time.Second)++ // Node A connects to Hub A+ apiPortA := getFreePort(t)+ nodeACmd := exec.Command(nodeBin, "run",+ "--hub", fmt.Sprintf("http://127.0.0.1:%d", portA),+ "--data-dir", filepath.Join(tmpDir, "nodeA"),+ "--bind-addr", fmt.Sprintf("127.0.0.1:%d", apiPortA),+ "--api-token", "tokenA",+ "--jwt", jwtTokenStr,+ "--listen", "/ip4/127.0.0.1/tcp/0",+ "--listen", "/ip4/127.0.0.1/udp/0/quic-v1",+ "--discovery-interval", "100ms",+ "--enable-relay=true",+ "--allow-loopback=true",+ )+ var nodeStdoutA, nodeStderrA safeBuffer+ nodeACmd.Stdout = io.MultiWriter(os.Stdout, &nodeStdoutA)+ nodeACmd.Stderr = io.MultiWriter(os.Stderr, &nodeStderrA)+ if err := nodeACmd.Start(); err != nil {+ t.Fatalf("failed to start Node A: %v", err)+ }+ defer func() { _ = nodeACmd.Process.Kill() }()++ // Node B connects to Hub B+ apiPortB := getFreePort(t)+ nodeBCmd := exec.Command(nodeBin, "run",+ "--hub", fmt.Sprintf("http://127.0.0.1:%d", portB),+ "--data-dir", filepath.Join(tmpDir, "nodeB"),+ "--bind-addr", fmt.Sprintf("127.0.0.1:%d", apiPortB),+ "--api-token", "tokenB",+ "--jwt", jwtTokenStr,+ "--listen", "/ip4/127.0.0.1/tcp/0",+ "--listen", "/ip4/127.0.0.1/udp/0/quic-v1",+ "--discovery-interval", "100ms",+ "--allow-loopback=true",+ )+ var nodeStdoutB, nodeStderrB safeBuffer+ nodeBCmd.Stdout = io.MultiWriter(os.Stdout, &nodeStdoutB)+ nodeBCmd.Stderr = io.MultiWriter(os.Stderr, &nodeStderrB)+ if err := nodeBCmd.Start(); err != nil {+ t.Fatalf("failed to start Node B: %v", err)+ }+ defer func() { _ = nodeBCmd.Process.Kill() }()++ // Give nodes time to connect and sync+ waitForDHTReady(t, clientBin, apiPortA, "tokenA")+ waitForDHTReady(t, clientBin, apiPortB, "tokenB")++ // Start Mock Backend on Node A+ mcpServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ w.Header().Set("Content-Type", "application/json")+ w.WriteHeader(http.StatusOK)+ _, _ = w.Write([]byte(`{"jsonrpc": "2.0", "id": 1, "result": {"success": true}}`))+ }))+ t.Cleanup(func() { mcpServer.Close() })++ // Publish a service on Node A+ t.Log("Publishing tool on Node A...")+ registerService(t, fmt.Sprintf("127.0.0.1:%d", apiPortA), "tokenA", "federated-tool", mcpServer.URL)+ time.Sleep(2 * time.Second)++ // Search for the service from Node B+ t.Log("Searching for tool from Node B...")+ searchCmd := exec.Command(clientBin,+ "-url", fmt.Sprintf("http://127.0.0.1:%d/mcp/events", apiPortB),+ "-token", "tokenB",+ "-tool", "discover_remote_services",+ "-args", `{"type": "mcp"}`,+ )++ ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)+ defer cancel()++ var found bool+ for {+ select {+ case <-ctx.Done():+ t.Logf("Node A Stdout: %s", nodeStdoutA.String())+ t.Logf("Node A Stderr: %s", nodeStderrA.String())+ t.Logf("Node B Stdout: %s", nodeStdoutB.String())+ t.Logf("Node B Stderr: %s", nodeStderrB.String())+ t.Fatalf("timed out waiting to discover tool from Node B. Hub A logs: %s, Hub B logs: %s", stderrA.String(), stderrB.String())+ default:+ out, err := searchCmd.Output()+ if err == nil {+ // For simplicity, just check if the output contains the name+ if strings.Contains(string(out), "federated-tool") {+ found = true+ break+ }+ }+ time.Sleep(500 * time.Millisecond)+ }+ if found {+ break+ }+ }++ t.Log("Successfully discovered federated tool via relay!")++ // Assert datapath works via Node B's local Egress Proxy+ t.Log("Testing datapath from Node B to Node A...")++ // Extract Node A's Peer ID from its logs+ peerIDRe := regexp.MustCompile(`(?m)^PeerID:\s+([A-Za-z0-9]+)$`)+ matches := peerIDRe.FindStringSubmatch(nodeStdoutA.String())+ if len(matches) < 2 {+ t.Fatalf("could not extract Node A Peer ID from logs")+ }+ peerIDA_node := matches[1]++ // The proxy path on Node B is /sam/<peerID>/mcp/federated-tool+ proxyURL := fmt.Sprintf("http://127.0.0.1:%d/sam/%s/mcp/federated-tool", apiPortB, peerIDA_node)+ req, _ := http.NewRequest("POST", proxyURL, bytes.NewBuffer([]byte(`{"jsonrpc": "2.0", "id": 1, "method": "test"}`)))+ req.Header.Set("Authorization", "Bearer tokenB")++ resp, err := http.DefaultClient.Do(req)+ if err != nil {+ t.Fatalf("Datapath failed: %v", err)+ }+ defer resp.Body.Close()+ if resp.StatusCode != http.StatusOK {+ body, _ := io.ReadAll(resp.Body)+ t.Fatalf("Datapath returned status %d: %s", resp.StatusCode, string(body))+ }+ body, _ := io.ReadAll(resp.Body)+ if !strings.Contains(string(body), `"success": true`) {+ t.Fatalf("Unexpected datapath response: %s", string(body))+ }+ t.Log("Datapath works!")+}++func fetchPeerID(t *testing.T, port int) string {+ var bodyBytes []byte+ var err error++ ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)+ defer cancel()++ for {+ var resp *http.Response+ resp, err = http.Get(fmt.Sprintf("http://127.0.0.1:%d/info", port))+ if err == nil {+ bodyBytes, err = io.ReadAll(resp.Body)+ resp.Body.Close()+ if err == nil {+ break+ }+ }++ select {+ case <-ctx.Done():+ t.Fatalf("timed out waiting for /info: %v", err)+ case <-time.After(100 * time.Millisecond):+ }+ }++ var info api.HubInfoResponse+ if err := proto.Unmarshal(bodyBytes, &info); err != nil {+ t.Fatalf("failed to decode /info: %v", err)+ }++ // Hub's PeerID is derived from its first listen multiaddr's /p2p/ segment+ var peerID string+ if len(info.HubAddresses) > 0 {+ peerID = extractPeerID(info.HubAddresses[0])+ }+ if peerID == "" {+ t.Fatalf("empty peer id from /info")+ }+ return peerID+}++func extractPeerID(maddrStr string) string {+ parts := strings.Split(maddrStr, "/")+ for i, part := range parts {+ if part == "p2p" && i+1 < len(parts) {+ return parts[i+1]+ }+ }+ return ""+}++func waitForDHTReady(t *testing.T, clientBin string, apiPort int, token string) {+ t.Helper()+ deadline := time.Now().Add(10 * time.Second)+ cmdArgs := []string{+ "-url", fmt.Sprintf("http://127.0.0.1:%d/mcp/events", apiPort),+ "-token", token,+ "-tool", "get_mesh_info",+ "-args", `{}`,+ }++ for time.Now().Before(deadline) {+ cmd := exec.Command(clientBin, cmdArgs...)+ out, err := cmd.Output()+ if err == nil {+ if strings.Contains(string(out), `"dht_size":`) && !strings.Contains(string(out), `"dht_size":0`) {+ return+ }+ }+ time.Sleep(500 * time.Millisecond)+ }+ t.Fatalf("DHT not ready on port %d", apiPort)+}diff --git a/tests/integration/mock_oidc_test.go b/tests/integration/mock_oidc_test.gonew file mode 100644index 00000000..c36a13c1--- /dev/null+++ b/tests/integration/mock_oidc_test.go@@ -0,0 +1,64 @@+package integration_test++import (+ "crypto/rand"+ "crypto/rsa"+ "encoding/base64"+ "encoding/json"+ "math/big"+ "net/http"+ "net/http/httptest"+ "testing"+ "time"++ "github.com/golang-jwt/jwt/v5"+)++func startMockOIDC(t *testing.T) (string, string) {+ privKey, err := rsa.GenerateKey(rand.Reader, 2048)+ if err != nil {+ t.Fatalf("failed to generate rsa key: %v", err)+ }++ mux := http.NewServeMux()+ srv := httptest.NewServer(mux)+ issuer := srv.URL++ mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {+ w.Header().Set("Content-Type", "application/json")+ json.NewEncoder(w).Encode(map[string]interface{}{+ "issuer": issuer,+ "jwks_uri": issuer + "/keys",+ })+ })++ mux.HandleFunc("/keys", func(w http.ResponseWriter, r *http.Request) {+ w.Header().Set("Content-Type", "application/json")+ json.NewEncoder(w).Encode(map[string]interface{}{+ "keys": []map[string]interface{}{+ {+ "kty": "RSA",+ "alg": "RS256",+ "use": "sig",+ "kid": "mock-key",+ "n": base64.RawURLEncoding.EncodeToString(privKey.N.Bytes()),+ "e": base64.RawURLEncoding.EncodeToString(big.NewInt(int64(privKey.E)).Bytes()),+ },+ },+ })+ })++ token := jwt.NewWithClaims(jwt.SigningMethodRS256, jwt.MapClaims{+ "iss": issuer,+ "aud": "sam-mesh-audience",+ "sub": "mock-user",+ "exp": time.Now().Add(time.Hour).Unix(),+ })+ token.Header["kid"] = "mock-key"+ jwtStr, err := token.SignedString(privKey)+ if err != nil {+ t.Fatalf("failed to sign jwt: %v", err)+ }++ return issuer, jwtStr+}diff --git a/tests/integration/service_discovery_test.go b/tests/integration/service_discovery_test.goindex 4911349f..c5d2e021 100644--- a/tests/integration/service_discovery_test.go+++ b/tests/integration/service_discovery_test.go@@ -95,7 +95,7 @@ func TestServiceDiscovery(t *testing.T) {// Agent A registers a serviceserviceName := "mcp:github-tools"- registerService(t, actualApiAddrA, apiToken, serviceName)+ registerService(t, actualApiAddrA, apiToken, serviceName, "http://localhost:8080")// Wait for DHT propagationt.Log("Waiting for DHT propagation...")@@ -193,7 +193,7 @@ func TestServiceDiscoveryStreaming(t *testing.T) {// Agent A registers a serviceserviceName := "mcp:github-tools"- registerService(t, actualApiAddrA, apiToken, serviceName)+ registerService(t, actualApiAddrA, apiToken, serviceName, "http://localhost:8080")// Wait for DHT propagationt.Log("Waiting for DHT propagation...")@@ -286,7 +286,7 @@ func waitForAPI(t *testing.T, addr string) {t.Fatalf("timeout waiting for API at %s", addr)}-func registerService(t *testing.T, apiAddr, token, serviceName string) {+func registerService(t *testing.T, apiAddr, token, serviceName, targetURL string) {t.Helper()reqData := &api.RegisterServiceRequest{Service: &api.ServiceInfo{@@ -294,7 +294,7 @@ func registerService(t *testing.T, apiAddr, token, serviceName string) {Name: serviceName,Description: "test desc",},- Backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: "http://localhost:8080"},+ Backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: targetURL},}body, err := protojson.Marshal(reqData)if err != nil {