Skip to content

Agent Mesh

38.8 KB
Raw Blame
// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package node

import (
	"context"
	"crypto/ed25519"
	"crypto/rand"
	"encoding/json"
	"errors"
	"io"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"
	"time"

	"github.com/eclipse-biscuit/biscuit-go/v2"
	"github.com/eclipse-biscuit/biscuit-go/v2/datalog"
	"github.com/google/agentmesh/api"
	"github.com/google/agentmesh/internal/identity"
	"github.com/libp2p/go-libp2p/core/crypto"
	"github.com/libp2p/go-libp2p/core/peer"
	"github.com/modelcontextprotocol/go-sdk/mcp"
)

// publishEverything is the node role as a test mesh's policy grants it:
// serving every service, so a node's record and its calls pass the gates.
var publishEverything = []*api.PolicyRole{{Name: api.RoleNode, AllowedPublish: []string{"*"}}}

// buildAndSaveBiscuit builds a biscuit signed with rootPriv that identifies
// node as caller, grants every service to call and to serve, carries the
// node role as a real enrollment does, and saves it to node's store.
func buildAndSaveBiscuit(node *AgentMeshNode, rootPriv ed25519.PrivateKey) error {
	callerID := node.Host.ID().String()
	builder := biscuit.NewBuilder(rootPriv)
	_ = builder.AddAuthorityFact(api.MarkerFact(api.FactTargetUnrestricted))
	if err := builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{
		Name: "node",
		IDs:  []biscuit.Term{biscuit.String(callerID)},
	}}); err != nil {
		return err
	}
	if err := builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{
		Name: api.FactRole,
		IDs:  []biscuit.Term{biscuit.String(api.RoleNode)},
	}}); err != nil {
		return err
	}
	if err := builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{
		Name: "client_peer_id",
		IDs:  []biscuit.Term{biscuit.String(callerID)},
	}}); err != nil {
		return err
	}
	if err := builder.AddAuthorityFact(api.MarkerFact(api.FactGrantedServiceAllTypes)); err != nil {
		return err
	}
	if err := builder.AddAuthorityFact(api.MarkerFact(api.FactGrantedPublishAllTypes)); err != nil {
		return err
	}
	if err := builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{
		Name: api.FactExpiration,
		IDs:  []biscuit.Term{biscuit.Date(time.Now().Add(time.Hour))},
	}}); err != nil {
		return err
	}
	bisc, err := builder.Build()
	if err != nil {
		return err
	}
	biscBytes, err := bisc.Serialize()
	if err != nil {
		return err
	}
	return node.Store.SaveIdentity(biscBytes)
}

// enrollUnderRoot makes every node a member of the same mesh: each gets an
// identity biscuit signed by a fresh root and trusts that root, so both ends
// of any pair verify each other (the caller through WithBiscuitAuth, the
// provider through the label gate). Returns the root key pair for tests that
// need to mint extra tokens.
func enrollUnderRoot(t *testing.T, nodes ...*AgentMeshNode) (ed25519.PublicKey, ed25519.PrivateKey) {
	t.Helper()
	rootPub, rootPriv, err := ed25519.GenerateKey(rand.Reader)
	if err != nil {
		t.Fatalf("gen root key: %v", err)
	}
	for _, n := range nodes {
		if err := buildAndSaveBiscuit(n, rootPriv); err != nil {
			t.Fatalf("buildAndSaveBiscuit for %s: %v", n.Host.ID(), err)
		}
		n.keysMu.Lock()
		n.trustedKeys = append(n.trustedKeys, TrustedKey{Key: rootPub, ReceivedAt: time.Now()})
		n.keysMu.Unlock()
	}
	return rootPub, rootPriv
}

func TestHandleFindRemoteTools_EmptyMesh_ReturnsEmptyArray(t *testing.T) {
	ctx, cancel := contextWithShortTimeout()
	defer cancel()

	node, cleanup := startBareNode(t, ctx)
	defer cleanup()

	res, _, err := node.handleFindRemoteTools(ctx, &mcp.CallToolRequest{}, FindRemoteToolsParams{})
	if err != nil {
		t.Fatalf("handleFindRemoteTools: %v", err)
	}
	if len(res.Content) == 0 {
		t.Fatal("expected non-empty result content")
	}
	tc, ok := res.Content[0].(*mcp.TextContent)
	if !ok {
		t.Fatalf("expected TextContent, got %T", res.Content[0])
	}
	var rows []map[string]any
	if err := json.Unmarshal([]byte(tc.Text), &rows); err != nil {
		t.Fatalf("response not JSON array: %v (text: %q)", err, tc.Text)
	}
	if len(rows) != 0 {
		t.Errorf("expected empty results for empty mesh, got %d rows", len(rows))
	}
}

func TestHandleFindRemoteTools_SelfPeerRejected(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	node, cleanup := startBareNode(t, ctx)
	defer cleanup()

	cidv1Self := peer.ToCid(node.Host.ID()).String()
	if cidv1Self == node.Host.ID().String() {
		t.Fatalf("expected CIDv1 encoding %q to differ from canonical PeerID %q", cidv1Self, node.Host.ID().String())
	}

	for _, tc := range []struct {
		name   string
		peerID string
	}{
		{name: "canonical base58 self peer_id", peerID: node.Host.ID().String()},
		{name: "CIDv1 multibase self peer_id", peerID: cidv1Self},
	} {
		t.Run(tc.name, func(t *testing.T) {
			_, _, err := node.handleFindRemoteTools(ctx, &mcp.CallToolRequest{}, FindRemoteToolsParams{
				PeerID: tc.peerID,
			})
			if err == nil {
				t.Fatalf("expected error when peer_id=%q equals self peer ID, got nil", tc.peerID)
			}
			if !strings.Contains(err.Error(), "is this node; cross-mesh discovery cannot target self") {
				t.Errorf("error = %v, want self-peer rejection message", err)
			}
		})
	}
}

// contextWithShortTimeout returns a context with a small deadline so
// that tests fail fast if a libp2p dial hangs.
func contextWithShortTimeout() (context.Context, context.CancelFunc) {
	return context.WithTimeout(context.Background(), 3*time.Second)
}

func TestHandleFindRemoteTools_SinglePeer(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
	defer cancel()

	tools := []*mcp.Tool{
		{Name: "review_pr", Description: "Run a code review", InputSchema: map[string]any{"type": "object"}},
		{Name: "add_comment", Description: "Add a comment", InputSchema: map[string]any{"type": "object"}},
	}
	hostedSrv := httptest.NewServer(newFakeMCPHandler(t, tools))
	defer hostedSrv.Close()

	nodeA, cleanupA := startBareNode(t, ctx)
	defer cleanupA()
	nodeB, cleanupB := startBareNode(t, ctx)
	defer cleanupB()

	if err := nodeA.Host.Connect(ctx, peer.AddrInfo{ID: nodeB.Host.ID(), Addrs: nodeB.Host.Addrs()}); err != nil {
		t.Fatalf("connect: %v", err)
	}

	enrollUnderRoot(t, nodeA, nodeB)

	// Register an MCP service on B with two tools.
	regReq := &api.RegisterServiceRequest{
		Service: &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: "code-reviewer"},
		Backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: hostedSrv.URL},
	}
	if err := nodeB.RegisterService(ctx, regReq); err != nil {
		t.Fatalf("RegisterService: %v", err)
	}

	res, _, err := nodeA.handleFindRemoteTools(ctx, &mcp.CallToolRequest{}, FindRemoteToolsParams{
		PeerID: nodeB.Host.ID().String(),
	})
	if err != nil {
		t.Fatalf("handleFindRemoteTools: %v", err)
	}
	tc, ok := res.Content[0].(*mcp.TextContent)
	if !ok {
		t.Fatalf("expected TextContent, got %T", res.Content[0])
	}
	var rows []remoteToolRow
	if err := json.Unmarshal([]byte(tc.Text), &rows); err != nil {
		t.Fatalf("unmarshal: %v (text: %q)", err, tc.Text)
	}

	wantNames := map[string]bool{
		"mcp://code-reviewer/review_pr":   false,
		"mcp://code-reviewer/add_comment": false,
	}
	for _, row := range rows {
		if row.PeerID != nodeB.Host.ID().String() {
			t.Errorf("row has peer_id %q, want %q", row.PeerID, nodeB.Host.ID().String())
		}
		if _, ok := wantNames[row.ToolName]; ok {
			wantNames[row.ToolName] = true
		}
	}
	for name, found := range wantNames {
		if !found {
			t.Errorf("expected tool %q in response, not found; rows=%+v", name, rows)
		}
	}
}

// TestHandleFindRemoteTools_BackendPredatesDiscover is a regression test for
// a go-sdk v1.7.0 (SEP-2575) incompatibility: mcp.Client.Connect() sends a
// "server/discover" preflight before "initialize", falling back to the
// legacy handshake if it's rejected. HandleStreamPassThrough's dumb-pipe
// proxy used to forward that preflight straight to the backend, and a
// backend that doesn't understand it (like calc-mcp's Python server) would
// reject it, killing the whole libp2p stream before the "initialize"
// fallback could run. This exercises that path with a Go backend that
// mimics the same "discover unsupported" rejection, so it runs in
// milliseconds instead of the full docker-based e2e suite.
func TestHandleFindRemoteTools_BackendPredatesDiscover(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
	defer cancel()

	tools := []*mcp.Tool{
		{Name: "add", Description: "Add two numbers", InputSchema: map[string]any{"type": "object"}},
	}
	hostedSrv := httptest.NewServer(newPreDiscoverMCPHandler(t, tools))
	defer hostedSrv.Close()

	nodeA, cleanupA := startBareNode(t, ctx)
	defer cleanupA()
	nodeB, cleanupB := startBareNode(t, ctx)
	defer cleanupB()

	if err := nodeA.Host.Connect(ctx, peer.AddrInfo{ID: nodeB.Host.ID(), Addrs: nodeB.Host.Addrs()}); err != nil {
		t.Fatalf("connect: %v", err)
	}

	enrollUnderRoot(t, nodeA, nodeB)

	regReq := &api.RegisterServiceRequest{
		Service: &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: "calculator"},
		Backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: hostedSrv.URL},
	}
	if err := nodeB.RegisterService(ctx, regReq); err != nil {
		t.Fatalf("RegisterService: %v", err)
	}

	res, _, err := nodeA.handleFindRemoteTools(ctx, &mcp.CallToolRequest{}, FindRemoteToolsParams{
		PeerID: nodeB.Host.ID().String(),
	})
	if err != nil {
		t.Fatalf("handleFindRemoteTools: %v", err)
	}
	tc, ok := res.Content[0].(*mcp.TextContent)
	if !ok {
		t.Fatalf("expected TextContent, got %T", res.Content[0])
	}
	var rows []remoteToolRow
	if err := json.Unmarshal([]byte(tc.Text), &rows); err != nil {
		t.Fatalf("unmarshal: %v (text: %q)", err, tc.Text)
	}

	var found bool
	for _, row := range rows {
		if row.Error != "" {
			t.Errorf("row for %q has unexpected error: %s", row.ToolName, row.Error)
		}
		if row.ToolName == "mcp://calculator/add" {
			found = true
		}
	}
	if !found {
		t.Errorf("expected mcp://calculator/add in response, not found; rows=%+v", rows)
	}
}

func TestHandleFindRemoteTools_MeshWide(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
	defer cancel()

	// B hosts "code-reviewer", C hosts "mcp:summarizer", D hosts "plugin:linter".
	bTools := []*mcp.Tool{
		{Name: "review_pr", Description: "review", InputSchema: map[string]any{"type": "object"}},
	}
	cTools := []*mcp.Tool{
		{Name: "summarize", Description: "summarize", InputSchema: map[string]any{"type": "object"}},
	}
	dTools := []*mcp.Tool{
		{Name: "lint", Description: "lint", InputSchema: map[string]any{"type": "object"}},
	}
	bSrv := httptest.NewServer(newFakeMCPHandler(t, bTools))
	defer bSrv.Close()
	cSrv := httptest.NewServer(newFakeMCPHandler(t, cTools))
	defer cSrv.Close()
	dSrv := httptest.NewServer(newFakeMCPHandler(t, dTools))
	defer dSrv.Close()

	nodeA, cleanupA := startBareNode(t, ctx)
	defer cleanupA()
	nodeB, cleanupB := startBareNode(t, ctx)
	defer cleanupB()
	nodeC, cleanupC := startBareNode(t, ctx)
	defer cleanupC()
	nodeD, cleanupD := startBareNode(t, ctx)
	defer cleanupD()

	// Connect A to B, C, and D; every node is enrolled under one root so A's
	// stream passes WithBiscuitAuth and each target passes A's provider gate.
	enrollUnderRoot(t, nodeA, nodeB, nodeC, nodeD)
	for _, target := range []*AgentMeshNode{nodeB, nodeC, nodeD} {
		if err := nodeA.Host.Connect(ctx, peer.AddrInfo{ID: target.Host.ID(), Addrs: target.Host.Addrs()}); err != nil {
			t.Fatalf("connect to %s: %v", target.Host.ID(), err)
		}
	}

	if err := nodeB.RegisterService(ctx, &api.RegisterServiceRequest{
		Service: &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: "code-reviewer"},
		Backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: bSrv.URL},
	}); err != nil {
		t.Fatalf("RegisterService B: %v", err)
	}
	if err := nodeC.RegisterService(ctx, &api.RegisterServiceRequest{
		Service: &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: "summarizer"},
		Backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: cSrv.URL},
	}); err != nil {
		t.Fatalf("RegisterService C: %v", err)
	}
	if err := nodeD.RegisterService(ctx, &api.RegisterServiceRequest{
		Service: &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: "linter"},
		Backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: dSrv.URL},
	}); err != nil {
		t.Fatalf("RegisterService D: %v", err)
	}
	// A name that carries its own scheme used to be accepted and reached via
	// a name-only fallback that ignored the type the policy was evaluated on.
	for _, legacy := range []string{"mcp://summarizer", "plugin://linter"} {
		if err := nodeD.RegisterService(ctx, &api.RegisterServiceRequest{
			Service: &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: legacy},
			Backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: dSrv.URL},
		}); err == nil {
			t.Errorf("service name %q was accepted", legacy)
		}
	}

	// Direct fan-out test: invoke fetchRemoteToolCatalogue for peers,
	// confirm they return their tools.
	rowsB, errB := nodeA.fetchRemoteToolCatalogue(ctx, nodeB.Host.ID(), "")
	if errB != nil {
		t.Fatalf("fetch from B: %v", errB)
	}
	rowsC, errC := nodeA.fetchRemoteToolCatalogue(ctx, nodeC.Host.ID(), "")
	if errC != nil {
		t.Fatalf("fetch from C: %v", errC)
	}
	rowsD, errD := nodeA.fetchRemoteToolCatalogue(ctx, nodeD.Host.ID(), "")
	if errD != nil {
		t.Fatalf("fetch from D: %v", errD)
	}

	gotNames := map[string]bool{}
	for _, tool := range append(append(rowsB, rowsC...), rowsD...) {
		gotNames[tool.ToolName] = true
	}

	for _, want := range []string{"mcp://code-reviewer/review_pr", "mcp://summarizer/summarize", "mcp://linter/lint"} {
		if !gotNames[want] {
			t.Errorf("missing %s; got %v", want, gotNames)
		}
	}
}

func TestHandleFindRemoteTools_PartialFailure(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	cSrv := httptest.NewServer(newFakeMCPHandler(t, []*mcp.Tool{
		{Name: "summarize", Description: "x", InputSchema: map[string]any{"type": "object"}},
	}))
	defer cSrv.Close()

	nodeA, cleanupA := startBareNode(t, ctx)
	defer cleanupA()
	nodeC, cleanupC := startBareNode(t, ctx)
	defer cleanupC()

	enrollUnderRoot(t, nodeA, nodeC)

	// A connects to C only; B is a fictional peer ID that won't resolve.
	if err := nodeA.Host.Connect(ctx, peer.AddrInfo{ID: nodeC.Host.ID(), Addrs: nodeC.Host.Addrs()}); err != nil {
		t.Fatal(err)
	}

	if err := nodeC.RegisterService(ctx, &api.RegisterServiceRequest{
		Service: &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: "summarizer"},
		Backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: cSrv.URL},
	}); err != nil {
		t.Fatalf("RegisterService: %v", err)
	}

	// Generate a fictitious peer ID from a fresh keypair we never connect to.
	_, fakePub, err := crypto.GenerateKeyPair(crypto.Ed25519, -1)
	if err != nil {
		t.Fatal(err)
	}
	fictitiousPID, err := peer.IDFromPublicKey(fakePub)
	if err != nil {
		t.Fatal(err)
	}

	rows := nodeA.fanOutFetch(ctx, []peer.ID{nodeC.Host.ID(), fictitiousPID}, "")

	gotSummarizer := false
	for _, r := range rows {
		if r.ToolName == "mcp://summarizer/summarize" {
			gotSummarizer = true
		}
	}
	if !gotSummarizer {
		t.Errorf("expected mcp://summarizer/summarize from C even with B unreachable; got %+v", rows)
	}
}

func buildAndSaveCustomBiscuit(node *AgentMeshNode, rootPriv ed25519.PrivateKey, allowedServices []string) error {
	callerID := node.Host.ID().String()
	builder := biscuit.NewBuilder(rootPriv)
	err := builder.AddAuthorityFact(api.MarkerFact(api.FactTargetUnrestricted))
	if err != nil {
		return err
	}
	if err := builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{
		Name: "node",
		IDs:  []biscuit.Term{biscuit.String(callerID)},
	}}); err != nil {
		return err
	}
	if err := builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{
		Name: api.FactRole,
		IDs:  []biscuit.Term{biscuit.String(api.RoleNode)},
	}}); err != nil {
		return err
	}
	if err := builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{
		Name: "client_peer_id",
		IDs:  []biscuit.Term{biscuit.String(callerID)},
	}}); err != nil {
		return err
	}
	for _, svc := range allowedServices {
		opType, opName := api.ParseServiceTarget(svc)
		if opName == "" {
			opName = "*"
		}
		if err := builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{
			Name: "granted_service_exact",
			IDs:  []biscuit.Term{biscuit.String(opType), biscuit.String(opName)},
		}}); err != nil {
			return err
		}
	}
	if err := builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{
		Name: api.FactExpiration,
		IDs:  []biscuit.Term{biscuit.Date(time.Now().Add(time.Hour))},
	}}); err != nil {
		return err
	}
	bisc, err := builder.Build()
	if err != nil {
		return err
	}
	biscBytes, err := bisc.Serialize()
	if err != nil {
		return err
	}
	return node.Store.SaveIdentity(biscBytes)
}

func TestFetchRemoteToolCatalogue_AuthRejectedHidden(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	cSrv := httptest.NewServer(newFakeMCPHandler(t, []*mcp.Tool{
		{Name: "summarize", Description: "x", InputSchema: map[string]any{"type": "object"}},
	}))
	defer cSrv.Close()

	nodeA, cleanupA := startBareNode(t, ctx)
	defer cleanupA()
	nodeC, cleanupC := startBareNode(t, ctx)
	defer cleanupC()

	// Both enrolled under one root; A's identity is then narrowed to a
	// biscuit that DOES NOT allow "summarizer", only "some_other_service"
	// and "system://mesh.catalog".
	_, rootPrivEd := enrollUnderRoot(t, nodeA, nodeC)
	if err := buildAndSaveCustomBiscuit(nodeA, rootPrivEd, []string{"mcp://some_other_service", "system://mesh.catalog"}); err != nil {
		t.Fatalf("buildAndSaveCustomBiscuit: %v", err)
	}

	if err := nodeA.Host.Connect(ctx, peer.AddrInfo{ID: nodeC.Host.ID(), Addrs: nodeC.Host.Addrs()}); err != nil {
		t.Fatal(err)
	}

	if err := nodeC.RegisterService(ctx, &api.RegisterServiceRequest{
		Service: &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: "summarizer"},
		Backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: cSrv.URL},
	}); err != nil {
		t.Fatalf("RegisterService: %v", err)
	}

	// Fetching tools from C should succeed for the catalog, but the unauthorized
	// "summarizer" service must be hidden entirely rather than leaked as an error
	// row (issue #176: discovery should only ever show what the caller can call).
	rows, err := nodeA.fetchRemoteToolCatalogue(ctx, nodeC.Host.ID(), "")
	if err != nil {
		t.Fatalf("fetchRemoteToolCatalogue returned unexpected overall error: %v", err)
	}

	if len(rows) != 0 {
		t.Fatalf("expected unauthorized service to be hidden (0 rows), got %d: %+v", len(rows), rows)
	}
}

func TestCallMCPTool_LabelEnforcement(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
	defer cancel()

	nodeA, cleanupA := startBareNode(t, ctx)
	defer cleanupA()
	nodeB, cleanupB := startBareNode(t, ctx)
	defer cleanupB()

	if err := nodeA.Host.Connect(ctx, peer.AddrInfo{ID: nodeB.Host.ID(), Addrs: nodeB.Host.Addrs()}); err != nil {
		t.Fatalf("connect: %v", err)
	}

	rootPub, rootPriv, err := ed25519.GenerateKey(rand.Reader)
	if err != nil {
		t.Fatalf("gen root key: %v", err)
	}

	// nodeA authenticates to nodeB as an unrestricted caller.
	if err := buildAndSaveBiscuit(nodeA, rootPriv); err != nil {
		t.Fatalf("buildAndSaveBiscuit: %v", err)
	}
	nodeB.keysMu.Lock()
	nodeB.trustedKeys = append(nodeB.trustedKeys, TrustedKey{Key: rootPub, ReceivedAt: time.Now()})
	nodeB.keysMu.Unlock()

	// nodeB's own identity is control-plane-attested with region=eu-de; nodeA
	// must trust the same root to verify it.
	nodeBIdentity, err := identity.MintBootstrapBiscuitToken(rootPriv, nodeB.Host.ID(), api.RoleNode, time.Now().Add(time.Hour), publishEverything, map[string]string{"region": "eu-de"})
	if err != nil {
		t.Fatalf("mint nodeB identity: %v", err)
	}
	nodeB.SetIdentityCache(nodeBIdentity)
	nodeA.keysMu.Lock()
	nodeA.trustedKeys = append(nodeA.trustedKeys, TrustedKey{Key: rootPub, ReceivedAt: time.Now()})
	nodeA.keysMu.Unlock()

	hostedSrv := httptest.NewServer(newFakeMCPHandler(t, []*mcp.Tool{
		{Name: "review_pr", Description: "Run a code review", InputSchema: map[string]any{"type": "object"}},
	}))
	defer hostedSrv.Close()

	if err := nodeB.RegisterService(ctx, &api.RegisterServiceRequest{
		Service: &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: "code-reviewer"},
		Backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: hostedSrv.URL},
	}); err != nil {
		t.Fatalf("RegisterService: %v", err)
	}
	defer func() { _ = nodeB.UnregisterService(ctx, "code-reviewer") }()

	// A required label that nodeB's attestation satisfies (exact match).
	if _, err := nodeA.CallMCPTool(ctx, nodeB.Host.ID(), "mcp://code-reviewer/review_pr", map[string]any{}, map[string]string{"region": "eu-de"}); err != nil {
		t.Fatalf("CallMCPTool with satisfied label requirement should succeed: %v", err)
	}

	// A required label that nodeB's attestation does not satisfy: fail closed.
	if _, err := nodeA.CallMCPTool(ctx, nodeB.Host.ID(), "mcp://code-reviewer/review_pr", map[string]any{}, map[string]string{"region": "na-us"}); err == nil {
		t.Fatal("CallMCPTool with a non-matching label requirement must fail")
	}
}

// A provider whose credential does not grant the service is refused once: the
// refusal is an answer, so the call is not retried against the same peer.
func TestCallMCPTool_ProviderNotGrantedIsNotRetried(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
	defer cancel()

	nodeA, cleanupA := startBareNode(t, ctx)
	defer cleanupA()
	nodeB, cleanupB := startBareNode(t, ctx)
	defer cleanupB()

	if err := nodeA.Host.Connect(ctx, peer.AddrInfo{ID: nodeB.Host.ID(), Addrs: nodeB.Host.Addrs()}); err != nil {
		t.Fatalf("connect: %v", err)
	}

	rootPub, rootPriv, err := ed25519.GenerateKey(rand.Reader)
	if err != nil {
		t.Fatalf("gen root key: %v", err)
	}
	if err := buildAndSaveBiscuit(nodeA, rootPriv); err != nil {
		t.Fatalf("buildAndSaveBiscuit: %v", err)
	}
	nodeB.keysMu.Lock()
	nodeB.trustedKeys = append(nodeB.trustedKeys, TrustedKey{Key: rootPub, ReceivedAt: time.Now()})
	nodeB.keysMu.Unlock()

	// nodeB is enrolled, but no role grants it anything to publish.
	nodeBIdentity, err := identity.MintBootstrapBiscuitToken(rootPriv, nodeB.Host.ID(), api.RoleNode, time.Now().Add(time.Hour), nil, nil)
	if err != nil {
		t.Fatalf("mint nodeB identity: %v", err)
	}
	nodeB.SetIdentityCache(nodeBIdentity)
	nodeA.keysMu.Lock()
	nodeA.trustedKeys = append(nodeA.trustedKeys, TrustedKey{Key: rootPub, ReceivedAt: time.Now()})
	nodeA.keysMu.Unlock()

	hostedSrv := httptest.NewServer(newFakeMCPHandler(t, []*mcp.Tool{
		{Name: "review_pr", Description: "Run a code review", InputSchema: map[string]any{"type": "object"}},
	}))
	defer hostedSrv.Close()
	if err := nodeB.RegisterService(ctx, &api.RegisterServiceRequest{
		Service: &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: "code-reviewer"},
		Backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: hostedSrv.URL},
	}); err != nil {
		t.Fatalf("RegisterService: %v", err)
	}
	defer func() { _ = nodeB.UnregisterService(ctx, "code-reviewer") }()

	_, err = nodeA.CallMCPTool(ctx, nodeB.Host.ID(), "mcp://code-reviewer/review_pr", map[string]any{}, nil)
	if !errors.Is(err, ErrProviderNotGranted) {
		t.Fatalf("CallMCPTool to an ungranted provider = %v, want ErrProviderNotGranted", err)
	}
	if strings.Contains(err.Error(), "retries") {
		t.Fatalf("CallMCPTool to an ungranted provider = %v, want one refusal with no retry", err)
	}

	// A publish check that stops at the facts limit is no verdict on the
	// grant, and it is not retried either: the same credential and policy
	// reach the limit again.
	nodeA.MeshPolicyMu.Lock()
	nodeA.MeshPolicyRules = authorizerFactLimitRules()
	nodeA.MeshPolicyMu.Unlock()
	_, err = nodeA.CallMCPTool(ctx, nodeB.Host.ID(), "mcp://code-reviewer/review_pr", map[string]any{}, nil)
	if !errors.Is(err, datalog.ErrWorldRunLimitMaxFacts) || errors.Is(err, ErrProviderNotGranted) {
		t.Fatalf("CallMCPTool over the facts limit = %v, want an error wrapping %v and not %v", err, datalog.ErrWorldRunLimitMaxFacts, ErrProviderNotGranted)
	}
	if strings.Contains(err.Error(), "retries") {
		t.Fatalf("CallMCPTool over the facts limit = %v, want one refusal with no retry", err)
	}
}

// The operator's egress floor gates MCP egress even when the caller supplies no
// required_labels: silence must not waive the floor (see #385).
func TestCallMCPTool_EgressFloorEnforcement(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
	defer cancel()

	nodeA, cleanupA := startBareNode(t, ctx)
	defer cleanupA()
	nodeB, cleanupB := startBareNode(t, ctx)
	defer cleanupB()

	if err := nodeA.Host.Connect(ctx, peer.AddrInfo{ID: nodeB.Host.ID(), Addrs: nodeB.Host.Addrs()}); err != nil {
		t.Fatalf("connect: %v", err)
	}

	rootPub, rootPriv, err := ed25519.GenerateKey(rand.Reader)
	if err != nil {
		t.Fatalf("gen root key: %v", err)
	}

	// nodeA authenticates to nodeB as an unrestricted caller.
	if err := buildAndSaveBiscuit(nodeA, rootPriv); err != nil {
		t.Fatalf("buildAndSaveBiscuit: %v", err)
	}
	nodeB.keysMu.Lock()
	nodeB.trustedKeys = append(nodeB.trustedKeys, TrustedKey{Key: rootPub, ReceivedAt: time.Now()})
	nodeB.keysMu.Unlock()

	// nodeB attests region=eu-de and nothing else.
	nodeBIdentity, err := identity.MintBootstrapBiscuitToken(rootPriv, nodeB.Host.ID(), api.RoleNode, time.Now().Add(time.Hour), publishEverything, map[string]string{"region": "eu-de"})
	if err != nil {
		t.Fatalf("mint nodeB identity: %v", err)
	}
	nodeB.SetIdentityCache(nodeBIdentity)
	nodeA.keysMu.Lock()
	nodeA.trustedKeys = append(nodeA.trustedKeys, TrustedKey{Key: rootPub, ReceivedAt: time.Now()})
	nodeA.keysMu.Unlock()

	hostedSrv := httptest.NewServer(newFakeMCPHandler(t, []*mcp.Tool{
		{Name: "review_pr", Description: "Run a code review", InputSchema: map[string]any{"type": "object"}},
	}))
	defer hostedSrv.Close()

	if err := nodeB.RegisterService(ctx, &api.RegisterServiceRequest{
		Service: &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: "code-reviewer"},
		Backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: hostedSrv.URL},
	}); err != nil {
		t.Fatalf("RegisterService: %v", err)
	}
	defer func() { _ = nodeB.UnregisterService(ctx, "code-reviewer") }()

	// Floor satisfied by nodeB's attestation; the caller requires nothing.
	nodeA.nodeConfig = &NodeConfigComplete{EgressRequireLabels: map[string]string{"region": "eu-de"}}
	if _, err := nodeA.CallMCPTool(ctx, nodeB.Host.ID(), "mcp://code-reviewer/review_pr", map[string]any{}, nil); err != nil {
		t.Fatalf("CallMCPTool inside the floor should succeed: %v", err)
	}

	// Floor nodeB does not attest; the caller staying silent must not waive it.
	nodeA.nodeConfig = &NodeConfigComplete{EgressRequireLabels: map[string]string{"jurisdiction": "eu"}}
	if _, err := nodeA.CallMCPTool(ctx, nodeB.Host.ID(), "mcp://code-reviewer/review_pr", map[string]any{}, nil); err == nil {
		t.Fatal("CallMCPTool outside the floor with no caller requirement must fail")
	}
}

func TestNewMCPHandler_RegistersFindRemoteTools(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	node, cleanup := startBareNode(t, ctx)
	defer cleanup()

	srv := httptest.NewServer(NewMCPHandler(node))
	defer srv.Close()

	client := mcp.NewClient(&mcp.Implementation{Name: "tc", Version: "0.0.1"}, nil)
	transport := &mcp.StreamableClientTransport{Endpoint: srv.URL + "/mcp"}
	session, err := client.Connect(ctx, transport, nil)
	if err != nil {
		t.Fatalf("connect: %v", err)
	}
	defer func() { _ = session.Close() }()

	res, err := session.ListTools(ctx, nil)
	if err != nil {
		t.Fatalf("list tools: %v", err)
	}
	found := false
	for _, tl := range res.Tools {
		if tl.Name == "find_remote_tools" {
			found = true
		}
	}
	if !found {
		var names []string
		for _, tl := range res.Tools {
			names = append(names, tl.Name)
		}
		t.Errorf("find_remote_tools missing from sidecar tools/list; got %v", names)
	}
}

// A legacy-version client that also sends the 2026-07-28 per-request _meta
// tag must be served, not refused as a new-protocol request; a stateful SDK
// handler answers it with -32022.
func TestNewMCPHandler_AcceptsLegacyRequestWithProtocolVersionMeta(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	srv := httptest.NewServer(NewMCPHandler(&AgentMeshNode{BiscuitTimeout: 500 * time.Millisecond}))
	defer srv.Close()

	body := `{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-11-25","capabilities":{},"clientInfo":{"name":"tc","version":"0.0.1"},"_meta":{"io.modelcontextprotocol/protocolVersion":"2025-11-25"}}}`
	req, err := http.NewRequestWithContext(ctx, http.MethodPost, srv.URL+"/mcp", strings.NewReader(body))
	if err != nil {
		t.Fatal(err)
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Accept", "application/json, text/event-stream")
	req.Header.Set("Mcp-Protocol-Version", "2025-11-25")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		t.Fatal(err)
	}
	defer func() { _ = resp.Body.Close() }()
	out, _ := io.ReadAll(resp.Body)
	if resp.StatusCode != http.StatusOK || !strings.Contains(string(out), `"protocolVersion":"2025-11-25"`) {
		t.Fatalf("initialize with _meta protocol version tag: status %d body %s", resp.StatusCode, out)
	}
	if resp.Header.Get("Mcp-Session-Id") != "" {
		t.Errorf("stateless handler must not issue Mcp-Session-Id, got %q", resp.Header.Get("Mcp-Session-Id"))
	}
}

func TestHandleDescribeRemoteTool_EmptyPeerID(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()

	node, cleanup := startBareNode(t, ctx)
	defer cleanup()

	_, _, err := node.handleDescribeRemoteTool(ctx, &mcp.CallToolRequest{}, DescribeRemoteToolParams{
		ToolName: "code-reviewer/review_pr",
	})
	if err == nil {
		t.Fatal("expected error for empty peer_id")
	}
}

func TestHandleDescribeRemoteTool_EmptyToolName(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()

	node, cleanup := startBareNode(t, ctx)
	defer cleanup()

	_, _, err := node.handleDescribeRemoteTool(ctx, &mcp.CallToolRequest{}, DescribeRemoteToolParams{
		PeerID: "12D3KooWFakePeerID",
	})
	if err == nil {
		t.Fatal("expected error for empty tool_name")
	}
}

func TestHandleDescribeRemoteTool_NonNamespacedRejected(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()

	node, cleanup := startBareNode(t, ctx)
	defer cleanup()

	_, _, err := node.handleDescribeRemoteTool(ctx, &mcp.CallToolRequest{}, DescribeRemoteToolParams{
		PeerID:   node.Host.ID().String(),
		ToolName: "send_message", // no dot
	})
	if err == nil {
		t.Fatal("expected error for tool_name without '.'")
	}
	if !strings.Contains(err.Error(), "service/tool") {
		t.Errorf("error %q does not explain the namespacing requirement", err.Error())
	}
}

func TestHandleDescribeRemoteTool_SelfPeerRejected(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	node, cleanup := startBareNode(t, ctx)
	defer cleanup()

	_, _, err := node.handleDescribeRemoteTool(ctx, &mcp.CallToolRequest{}, DescribeRemoteToolParams{
		PeerID:   node.Host.ID().String(),
		ToolName: "mcp://code-reviewer/review_pr",
	})
	if err == nil {
		t.Fatal("expected error when peer_id equals self peer ID")
	}
}

func TestHandleDescribeRemoteTool_InvalidPeerID(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	node, cleanup := startBareNode(t, ctx)
	defer cleanup()

	_, _, err := node.handleDescribeRemoteTool(ctx, &mcp.CallToolRequest{}, DescribeRemoteToolParams{
		PeerID:   "not-a-valid-peer-id",
		ToolName: "mcp://code-reviewer/review_pr",
	})
	if err == nil {
		t.Fatal("expected error for malformed peer_id")
	}
}

func TestHandleDescribeRemoteTool_RoundTrip(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
	defer cancel()

	nodeA, cleanupA := startBareNode(t, ctx)
	defer cleanupA()
	nodeB, cleanupB := startBareNode(t, ctx)
	defer cleanupB()

	if err := nodeA.Host.Connect(ctx, peer.AddrInfo{ID: nodeB.Host.ID(), Addrs: nodeB.Host.Addrs()}); err != nil {
		t.Fatalf("connect: %v", err)
	}

	enrollUnderRoot(t, nodeA, nodeB)

	tools := []*mcp.Tool{
		{
			Name:        "review_pr",
			Description: "Run a code review",
			InputSchema: map[string]any{
				"type":     "object",
				"required": []any{"pr_url"},
				"properties": map[string]any{
					"pr_url": map[string]any{"type": "string"},
				},
			},
			OutputSchema: map[string]any{
				"type": "object",
				"properties": map[string]any{
					"summary": map[string]any{"type": "string"},
				},
			},
		},
	}
	hostedSrv := httptest.NewServer(newFakeMCPHandler(t, tools))
	defer hostedSrv.Close()

	regReq := &api.RegisterServiceRequest{
		Service: &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: "code-reviewer"},
		Backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: hostedSrv.URL},
	}
	if err := nodeB.RegisterService(ctx, regReq); err != nil {
		t.Fatalf("RegisterService: %v", err)
	}
	defer func() { _ = nodeB.UnregisterService(ctx, "code-reviewer") }()

	res, _, err := nodeA.handleDescribeRemoteTool(ctx, &mcp.CallToolRequest{}, DescribeRemoteToolParams{
		PeerID:   nodeB.Host.ID().String(),
		ToolName: "mcp://code-reviewer/review_pr",
	})
	if err != nil {
		t.Fatalf("handleDescribeRemoteTool: %v", err)
	}
	tc, ok := res.Content[0].(*mcp.TextContent)
	if !ok {
		t.Fatalf("expected TextContent, got %T", res.Content[0])
	}

	var desc remoteToolDescription
	if err := json.Unmarshal([]byte(tc.Text), &desc); err != nil {
		t.Fatalf("unmarshal: %v (text: %q)", err, tc.Text)
	}
	if desc.PeerID != nodeB.Host.ID().String() {
		t.Errorf("PeerID = %q, want %q", desc.PeerID, nodeB.Host.ID().String())
	}
	if desc.ToolName != "mcp://code-reviewer/review_pr" {
		t.Errorf("ToolName = %q, want %q", desc.ToolName, "mcp://code-reviewer/review_pr")
	}
	if desc.Description != "Run a code review" {
		t.Errorf("Description = %q, want %q", desc.Description, "Run a code review")
	}
	inSchema, ok := desc.InputSchema.(map[string]any)
	if !ok {
		t.Fatalf("InputSchema type = %T, want map[string]any", desc.InputSchema)
	}
	if inSchema["type"] != "object" {
		t.Errorf("InputSchema.type = %v, want 'object'", inSchema["type"])
	}
	outSchema, ok := desc.OutputSchema.(map[string]any)
	if !ok {
		t.Fatalf("OutputSchema type = %T, want map[string]any", desc.OutputSchema)
	}
	if outSchema["type"] != "object" {
		t.Errorf("OutputSchema.type = %v, want 'object'", outSchema["type"])
	}
}

func TestHandleDescribeRemoteTool_RoundTrip_UnknownTool(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
	defer cancel()

	nodeA, cleanupA := startBareNode(t, ctx)
	defer cleanupA()
	nodeB, cleanupB := startBareNode(t, ctx)
	defer cleanupB()

	if err := nodeA.Host.Connect(ctx, peer.AddrInfo{ID: nodeB.Host.ID(), Addrs: nodeB.Host.Addrs()}); err != nil {
		t.Fatalf("connect: %v", err)
	}

	enrollUnderRoot(t, nodeA, nodeB)

	tools := []*mcp.Tool{
		{Name: "review_pr", Description: "x", InputSchema: map[string]any{"type": "object"}},
	}
	hostedSrv := httptest.NewServer(newFakeMCPHandler(t, tools))
	defer hostedSrv.Close()
	if err := nodeB.RegisterService(ctx, &api.RegisterServiceRequest{
		Service: &api.ServiceInfo{Type: api.ServiceType_SERVICE_TYPE_MCP, Name: "code-reviewer"},
		Backend: &api.RegisterServiceRequest_TargetUrl{TargetUrl: hostedSrv.URL},
	}); err != nil {
		t.Fatalf("RegisterService: %v", err)
	}
	defer func() { _ = nodeB.UnregisterService(ctx, "code-reviewer") }()

	_, _, err := nodeA.handleDescribeRemoteTool(ctx, &mcp.CallToolRequest{}, DescribeRemoteToolParams{
		PeerID:   nodeB.Host.ID().String(),
		ToolName: "mcp://code-reviewer/does-not-exist",
	})
	if err == nil {
		t.Fatal("expected error from peer when tool is not registered")
	}
	wantError := "tool not found on peer"
	if err.Error() != wantError {
		t.Errorf("error %q != %q", err.Error(), wantError)
	}
}

func TestNewMCPHandler_RegistersDescribeRemoteTool(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	node, cleanup := startBareNode(t, ctx)
	defer cleanup()

	srv := httptest.NewServer(NewMCPHandler(node))
	defer srv.Close()

	client := mcp.NewClient(&mcp.Implementation{Name: "tc", Version: "0.0.1"}, nil)
	transport := &mcp.StreamableClientTransport{Endpoint: srv.URL + "/mcp"}
	session, err := client.Connect(ctx, transport, nil)
	if err != nil {
		t.Fatalf("connect: %v", err)
	}
	defer func() { _ = session.Close() }()

	res, err := session.ListTools(ctx, nil)
	if err != nil {
		t.Fatalf("list tools: %v", err)
	}
	found := false
	for _, tl := range res.Tools {
		if tl.Name == "describe_remote_tool" {
			found = true
		}
	}
	if !found {
		var names []string
		for _, tl := range res.Tools {
			names = append(names, tl.Name)
		}
		t.Errorf("describe_remote_tool missing from sidecar tools/list; got %v", names)
	}
}

// newFakeMCPHandler returns an http.Handler serving a tiny MCP server over
// streamable-http with the given tools registered.
func newFakeMCPHandler(t *testing.T, tools []*mcp.Tool) http.Handler {
	t.Helper()
	srv := mcp.NewServer(&mcp.Implementation{Name: "fake", Version: "0.0.1"}, nil)
	for _, tool := range tools {
		toolCopy := tool
		srv.AddTool(toolCopy, func(ctx context.Context, req *mcp.CallToolRequest) (*mcp.CallToolResult, error) {
			return &mcp.CallToolResult{
				Content: []mcp.Content{&mcp.TextContent{Text: "fake-result:" + toolCopy.Name}},
			}, nil
		})
	}
	return mcp.NewStreamableHTTPHandler(func(*http.Request) *mcp.Server { return srv }, nil)
}

// newPreDiscoverMCPHandler wraps a real streamable-http MCP server but
// rejects the SEP-2575 "server/discover" preflight with a plain HTTP 400,
// the way a server built against an older SDK/spec version does (e.g. the
// Python `mcp` package used by development/examples/calc-mcp). This lets
// tests exercise HandleStreamPassThrough against a backend that predates
// "server/discover" without needing a real non-Go MCP server.
func newPreDiscoverMCPHandler(t *testing.T, tools []*mcp.Tool) http.Handler {
	t.Helper()
	real := newFakeMCPHandler(t, tools)
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Method == http.MethodPost {
			body, err := io.ReadAll(r.Body)
			if err != nil {
				http.Error(w, "failed to read body", http.StatusBadRequest)
				return
			}
			r.Body = io.NopCloser(strings.NewReader(string(body)))
			var probe struct {
				Method string `json:"method"`
			}
			if json.Unmarshal(body, &probe) == nil && preflightMethodsUnsupportedByPassThrough[probe.Method] {
				http.Error(w, "Missing session ID", http.StatusBadRequest)
				return
			}
		}
		real.ServeHTTP(w, r)
	})
}