Agent Mesh
Go a2aa2a-protocolagent-meshagentic-aiinferencemcpmeshmesh-networknetwork-securitynetworking-aip2p-network
// 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 integration_test
import (
"context"
"iter"
"net/http"
"net/http/httptest"
"strings"
"sync/atomic"
"testing"
"time"
"github.com/a2aproject/a2a-go/v2/a2a"
"github.com/a2aproject/a2a-go/v2/a2aclient"
"github.com/a2aproject/a2a-go/v2/a2aclient/agentcard"
"github.com/a2aproject/a2a-go/v2/a2asrv"
"github.com/google/agentmesh/api"
)
// headerRoundTripper stamps fixed headers (mesh auth, labels) on every
// request so the stock A2A SDK client needs no Agent Mesh-specific code.
type headerRoundTripper struct {
headers map[string]string
}
func (h headerRoundTripper) RoundTrip(r *http.Request) (*http.Response, error) {
r = r.Clone(r.Context())
for k, v := range h.headers {
r.Header.Set(k, v)
}
return http.DefaultTransport.RoundTrip(r)
}
func meshHTTPClient(token string, extra map[string]string) *http.Client {
headers := map[string]string{api.HeaderMeshAuthentication: "Bearer " + token}
for k, v := range extra {
headers[k] = v
}
return &http.Client{Transport: headerRoundTripper{headers: headers}}
}
// TestA2ACUJ covers the "A2A agent behind the mesh" CUJ with the official
// SDK on both ends: node A (attested region=eu) hosts a stock a2asrv agent;
// a stock a2aclient bootstraps from the regenerated card served by node B,
// holds a message exchange, and a region-mismatched request is refused
// fail-closed before any payload leaves node B.
func TestA2ACUJ(t *testing.T) {
nodeBin := buildBinary(t, "./cmd/agentmesh-node")
_, hubAddr := startMockRouter(t)
homeA := t.TempDir()
homeB := t.TempDir()
apiToken := "test-token"
// Stock-SDK A2A agent on node A's side: a2asrv serving its card and
// echoing message/send. The card deliberately advertises a gRPC
// interface and a stale signature, which the mesh must drop on
// regeneration, and streaming, which it must keep and carry. Its
// JSON-RPC endpoint is "/invoke", as in the a2a-go samples, not the
// root: the mesh URL must keep that path. The backend exists before
// the node: services are declared in the node's configuration, never
// registered at runtime.
var sendCount atomic.Int32
var sawLabelsHeader atomic.Bool
firstStreamEventSeen := make(chan struct{})
echo := a2asrv.AgentExecutorFunc(func(ctx context.Context, ec *a2asrv.ExecutorContext) iter.Seq2[a2a.Event, error] {
return func(yield func(a2a.Event, error) bool) {
sendCount.Add(1)
if len(ec.Message.Parts) > 0 && ec.Message.Parts[0].Text() == "stream" {
if !yield(a2a.NewSubmittedTask(ec, ec.Message), nil) {
return
}
select {
case <-firstStreamEventSeen:
case <-ctx.Done():
return
}
yield(a2a.NewStatusUpdateEvent(ec, a2a.TaskStateCompleted, a2a.NewMessageForTask(a2a.MessageRoleAgent, ec, a2a.NewTextPart("echo from eu"))), nil)
return
}
yield(a2a.NewMessageForTask(a2a.MessageRoleAgent, ec, a2a.NewTextPart("echo from eu")), nil)
}
})
agentCard := &a2a.AgentCard{
Name: "echo-agent",
Description: "test a2a agent",
Version: "1.0.0",
Capabilities: a2a.AgentCapabilities{Streaming: true},
SupportedInterfaces: []*a2a.AgentInterface{
{URL: "http://localhost:9999/invoke", ProtocolBinding: a2a.TransportProtocolJSONRPC, ProtocolVersion: "1.0"},
{URL: "localhost:50051", ProtocolBinding: a2a.TransportProtocolGRPC, ProtocolVersion: "1.0"},
},
Signatures: []a2a.AgentCardSignature{{Protected: "eyJhbGciOiJFUzI1NiJ9", Signature: "c3RhbGU"}},
}
mux := http.NewServeMux()
mux.Handle(a2asrv.WellKnownAgentCardPath, a2asrv.NewStaticAgentCardHandler(agentCard))
mux.Handle("/invoke", a2asrv.NewJSONRPCHandler(a2asrv.NewHandler(echo)))
agent := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Header.Get(api.HeaderMeshRequiredLabels) != "" {
sawLabelsHeader.Store(true)
}
mux.ServeHTTP(w, r)
}))
defer agent.Close()
t.Log("Starting Node A (provider, region=eu)...")
nodeA := 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",
"--config", writeNodeConfig(t, homeA, map[string]string{"region": "eu"}, svcDecl{Type: "a2a", Name: "echo-agent", TargetURL: agent.URL}),
)
t.Log("Starting Node B (consumer)...")
nodeB := 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",
)
apiAddrA := nodeA.waitForAPI(t)
apiAddrB := nodeB.waitForAPI(t)
addrA := nodeA.p2pAddr
connectPeer(t, apiAddrB, addrA)
waitForDHTPeers(t, apiAddrA)
idx := strings.LastIndex(addrA, "/p2p/")
if idx < 0 {
t.Fatalf("no /p2p/ component in peer addr %q", addrA)
}
peerA := addrA[idx+len("/p2p/"):]
meshBase := "http://" + apiAddrB + "/mesh/" + peerA + "/a2a/echo-agent"
ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
defer cancel()
// CUJ step 1: a stock SDK resolver bootstraps from the regenerated card.
// Poll: the first fetch can race connectivity establishment.
resolver := agentcard.NewResolver(meshHTTPClient(apiToken, nil))
var card *a2a.AgentCard
deadline := time.Now().Add(30 * time.Second)
for {
var err error
card, err = resolver.Resolve(ctx, meshBase)
if err == nil {
break
}
if time.Now().After(deadline) {
t.Fatalf("timeout resolving agent card through the mesh: %v", err)
}
time.Sleep(200 * time.Millisecond)
}
if len(card.SupportedInterfaces) != 1 || card.SupportedInterfaces[0].URL != meshBase+"/invoke" {
t.Errorf("interfaces not regenerated / gRPC not dropped: got %+v, want exactly one interface with URL %q", card.SupportedInterfaces, meshBase+"/invoke")
}
if card.SupportedInterfaces[0].ProtocolBinding != a2a.TransportProtocolJSONRPC {
t.Errorf("binding = %q, want JSONRPC", card.SupportedInterfaces[0].ProtocolBinding)
}
if !card.Capabilities.Streaming {
t.Errorf("streaming = %v, want true as the agent declares it", card.Capabilities.Streaming)
}
if len(card.Signatures) != 0 {
t.Error("stale signatures must be dropped from the regenerated card")
}
// CUJ step 2: a stock SDK client built from that card, constrained to
// region=eu, is admitted and gets the echo back.
euClient, err := a2aclient.NewFromCard(ctx, card,
a2aclient.WithJSONRPCTransport(meshHTTPClient(apiToken, map[string]string{api.HeaderMeshRequiredLabels: "region=eu"})))
if err != nil {
t.Fatalf("stock client rejected the regenerated card: %v", err)
}
req := &a2a.SendMessageRequest{Message: a2a.NewMessage(a2a.MessageRoleUser, a2a.NewTextPart("hi"))}
deadline = time.Now().Add(30 * time.Second)
var result a2a.SendMessageResult
for {
result, err = euClient.SendMessage(ctx, req)
if err == nil {
break
}
if time.Now().After(deadline) {
t.Fatalf("labelled message/send failed: %v", err)
}
time.Sleep(200 * time.Millisecond)
}
reply, ok := result.(*a2a.Message)
if !ok {
t.Fatalf("send result = %T, want *a2a.Message", result)
}
if len(reply.Parts) == 0 || reply.Parts[0].Text() != "echo from eu" {
t.Fatalf("unexpected reply: %+v", reply)
}
// CUJ step 2b: the card keeps streaming, so the same client may stream
// the exchange; the SSE response must flush across the mesh as each
// event is emitted (not buffered until EOF): the server holds the final
// event until the client confirms it received the first one.
streamReq := &a2a.SendMessageRequest{Message: a2a.NewMessage(a2a.MessageRoleUser, a2a.NewTextPart("stream"))}
var streamed []a2a.Event
for event, err := range euClient.SendStreamingMessage(ctx, streamReq) {
if err != nil {
t.Fatalf("streamed message/send failed: %v", err)
}
streamed = append(streamed, event)
if len(streamed) == 1 {
close(firstStreamEventSeen)
}
}
if len(streamed) != 2 {
t.Fatalf("streamed %d events, want 2 (submitted task + completed status): %+v", len(streamed), streamed)
}
if task, ok := streamed[0].(*a2a.Task); !ok || task.Status.State != a2a.TaskStateSubmitted {
t.Fatalf("first streamed event = %+v, want *a2a.Task in state %q", streamed[0], a2a.TaskStateSubmitted)
}
if ev, ok := streamed[1].(*a2a.TaskStatusUpdateEvent); !ok || ev.Status.State != a2a.TaskStateCompleted ||
ev.Status.Message == nil || len(ev.Status.Message.Parts) == 0 || ev.Status.Message.Parts[0].Text() != "echo from eu" {
t.Fatalf("second streamed event = %+v, want completed TaskStatusUpdateEvent with text %q", streamed[1], "echo from eu")
}
// CUJ step 3: a mismatched label refuses fail-closed BEFORE egress —
// the agent backend must never see the request.
before := sendCount.Load()
usClient, err := a2aclient.NewFromCard(ctx, card,
a2aclient.WithJSONRPCTransport(meshHTTPClient(apiToken, map[string]string{api.HeaderMeshRequiredLabels: "region=us-east-1"})))
if err != nil {
t.Fatalf("client construction failed: %v", err)
}
if _, err := usClient.SendMessage(ctx, req); err == nil {
t.Fatal("mismatched label must fail closed")
}
if sendCount.Load() != before {
t.Fatal("payload reached the agent despite label refusal")
}
// Zero-trust invariant: the labels header never crosses the mesh.
if sawLabelsHeader.Load() {
t.Errorf("%s header leaked to the agent backend", api.HeaderMeshRequiredLabels)
}
t.Log("A2A CUJ test passed.")
}