Agent Mesh
Go a2aa2a-protocolagent-meshagentic-aiinferencemcpmeshmesh-networknetwork-securitynetworking-aip2p-network
internal/identity, internal/node: add unit regression tests for bugfixes and library hooks
Antonio Ojeaa29a404dc43a
diff --git a/internal/identity/biscuit_test.go b/internal/identity/biscuit_test.goindex f4e7d4b3..da7a3ce1 100644--- a/internal/identity/biscuit_test.go+++ b/internal/identity/biscuit_test.go@@ -29,6 +29,7 @@ import ("github.com/google/agentmesh/api""github.com/libp2p/go-libp2p/core/crypto""github.com/libp2p/go-libp2p/core/peer"+ "google.golang.org/protobuf/types/known/timestamppb")// testTimeout bounds datalog evaluation in these tests. It is deliberately@@ -856,3 +857,103 @@ func TestMintBiscuitToken_PublishFacts(t *testing.T) {t.Error("a delegated credential grants publishing nothing")}}++func TestInspectVerifiedBiscuit_ExtractsAuthorityLabels(t *testing.T) {+ pub, priv, err := ed25519.GenerateKey(rand.Reader)+ if err != nil {+ t.Fatal(err)+ }+ privNode, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1)+ if err != nil {+ t.Fatal(err)+ }+ peerID, err := peer.IDFromPrivateKey(privNode)+ if err != nil {+ t.Fatal(err)+ }++ roles := []*api.PolicyRole{{Name: api.RoleNode, AllowedPublish: []string{"*"}}}+ wantLabels := map[string]string{"env": "prod", "jurisdiction": "eu"}++ t.Run("authority labels extracted on base and TAR-attenuated tokens", func(t *testing.T) {+ raw, err := MintBootstrapBiscuitToken(priv, peerID, api.RoleNode, time.Now().Add(time.Hour), roles, wantLabels)+ if err != nil {+ t.Fatalf("MintBootstrapBiscuitToken: %v", err)+ }+ claims, err := InspectVerifiedBiscuit(raw, []ed25519.PublicKey{pub}, testTimeout)+ if err != nil {+ t.Fatalf("InspectVerifiedBiscuit(base): %v", err)+ }+ if len(claims.Labels) != len(wantLabels) {+ t.Fatalf("Labels len = %d (%v), want %v", len(claims.Labels), claims.Labels, wantLabels)+ }+ for k, want := range wantLabels {+ if got := claims.Labels[k]; got != want {+ t.Errorf("Labels[%q] = %q, want %q", k, got, want)+ }+ }++ attenuated, err := AttenuateBiscuit(raw, &api.TaskAuthorizationRule{+ Name: "triage-1",+ ExpireTime: timestamppb.New(time.Now().Add(10 * time.Minute)),+ Rules: []*api.TaskRule{+ {AllowedServices: []string{"a2a://assistant"}},+ },+ })+ if err != nil {+ t.Fatalf("AttenuateBiscuit: %v", err)+ }+ attClaims, err := InspectVerifiedBiscuit(attenuated, []ed25519.PublicKey{pub}, testTimeout)+ if err != nil {+ t.Fatalf("InspectVerifiedBiscuit(attenuated): %v", err)+ }+ for k, want := range wantLabels {+ if got := attClaims.Labels[k]; got != want {+ t.Errorf("attenuated Labels[%q] = %q, want %q", k, got, want)+ }+ }+ })++ t.Run("unlabeled token leaves Labels empty", func(t *testing.T) {+ raw, err := MintBootstrapBiscuitToken(priv, peerID, api.RoleNode, time.Now().Add(time.Hour), roles, nil)+ if err != nil {+ t.Fatalf("MintBootstrapBiscuitToken: %v", err)+ }+ claims, err := InspectVerifiedBiscuit(raw, []ed25519.PublicKey{pub}, testTimeout)+ if err != nil {+ t.Fatalf("InspectVerifiedBiscuit: %v", err)+ }+ if len(claims.Labels) != 0 {+ t.Errorf("Labels = %v, want empty", claims.Labels)+ }+ })++ t.Run("forged label fact in appended block rejected", func(t *testing.T) {+ raw, err := MintBootstrapBiscuitToken(priv, peerID, api.RoleNode, time.Now().Add(time.Hour), roles, nil)+ if err != nil {+ t.Fatalf("MintBootstrapBiscuitToken: %v", err)+ }+ parsed, err := biscuit.Unmarshal(raw)+ if err != nil {+ t.Fatalf("Unmarshal: %v", err)+ }+ blk := parsed.CreateBlock()+ if err := blk.AddFact(biscuit.Fact{Predicate: biscuit.Predicate{+ Name: api.FactLabel,+ IDs: []biscuit.Term{biscuit.String("env"), biscuit.String("forged")},+ }}); err != nil {+ t.Fatalf("AddFact: %v", err)+ }+ forged, err := parsed.Append(rand.Reader, blk.Build())+ if err != nil {+ t.Fatalf("Append: %v", err)+ }+ forgedBytes, err := forged.Serialize()+ if err != nil {+ t.Fatalf("Serialize: %v", err)+ }+ if _, err := InspectVerifiedBiscuit(forgedBytes, []ed25519.PublicKey{pub}, testTimeout); !errors.Is(err, ErrAppendedBlocks) {+ t.Fatalf("InspectVerifiedBiscuit(forged label block) err = %v, want wrapping %v", err, ErrAppendedBlocks)+ }+ })+}diff --git a/internal/node/ingress_test.go b/internal/node/ingress_test.goindex 3de2c6ff..437de1c1 100644--- a/internal/node/ingress_test.go+++ b/internal/node/ingress_test.go@@ -34,8 +34,10 @@ import ("github.com/golang-jwt/jwt/v5""github.com/google/agentmesh/api""github.com/google/agentmesh/internal/identity"+ libp2phttp "github.com/libp2p/go-libp2p-http"libp2pcrypto "github.com/libp2p/go-libp2p/core/crypto""github.com/libp2p/go-libp2p/core/peer"+ "google.golang.org/protobuf/types/known/timestamppb")func mustTestPeerID(t *testing.T) (peer.ID, libp2pcrypto.PrivKey) {@@ -705,3 +707,237 @@ func TestExternalIngressHandler(t *testing.T) {}})}++func TestStartIngressServer_PropagatesMeshTaskHeader(t *testing.T) {+ ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)+ defer cancel()++ provider, cleanupProvider := startBareNode(t, ctx)+ defer cleanupProvider()+ caller, cleanupCaller := startBareNode(t, ctx)+ defer cleanupCaller()++ enrollUnderRoot(t, provider, caller)++ if err := caller.Host.Connect(ctx, peer.AddrInfo{ID: provider.Host.ID(), Addrs: provider.Host.Addrs()}); err != nil {+ t.Fatalf("Connect: %v", err)+ }+ if err := caller.VerifyProvider(ctx, provider.Host.ID(), nil, ""); err != nil {+ t.Fatalf("VerifyProvider handshake: %v", err)+ }++ var captured http.Header+ provider.services.insertService(&fakeService{+ info: &api.ServiceInfo{+ Type: api.ServiceType_SERVICE_TYPE_A2A,+ Name: "assistant",+ },+ handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ captured = r.Header.Clone()+ w.WriteHeader(http.StatusOK)+ }),+ })++ baseBiscuit, err := caller.Store.LoadIdentity()+ if err != nil {+ t.Fatalf("LoadIdentity: %v", err)+ }++ client := &http.Client{Transport: libp2phttp.NewTransport(caller.Host)}+ targetURL := "libp2p://" + provider.Host.ID().String() + "/a2a/assistant/tasks"++ t.Run("untasked Biscuit strips spoofed X-Mesh-Task", func(t *testing.T) {+ captured = nil+ req, err := http.NewRequestWithContext(ctx, http.MethodPost, targetURL, strings.NewReader(`{}`))+ if err != nil {+ t.Fatalf("NewRequest: %v", err)+ }+ req.Header.Set(api.HeaderMeshBiscuit, base64.StdEncoding.EncodeToString(baseBiscuit))+ req.Header.Set(api.HeaderMeshTask, "spoofed-task")++ resp, err := client.Do(req)+ if err != nil {+ t.Fatalf("client.Do: %v", err)+ }+ _ = resp.Body.Close()+ if resp.StatusCode != http.StatusOK {+ t.Fatalf("status = %d, want 200", resp.StatusCode)+ }+ if got := captured.Get(api.HeaderMeshTask); got != "" {+ t.Errorf("X-Mesh-Task = %q, want empty when Biscuit has no task block", got)+ }+ })++ t.Run("nested TAR Biscuit propagates innermost X-Mesh-Task", func(t *testing.T) {+ captured = nil+ exp := timestamppb.New(time.Now().Add(10 * time.Minute))+ outerTok, err := identity.AttenuateBiscuit(baseBiscuit, &api.TaskAuthorizationRule{+ Name: "triage-42",+ ExpireTime: exp,+ Rules: []*api.TaskRule{+ {AllowedServices: []string{"a2a://assistant"}},+ },+ })+ if err != nil {+ t.Fatalf("AttenuateBiscuit(outer): %v", err)+ }+ innerTok, err := identity.AttenuateBiscuit(outerTok, &api.TaskAuthorizationRule{+ Name: "step-2",+ ExpireTime: exp,+ Rules: []*api.TaskRule{+ {AllowedServices: []string{"a2a://assistant"}},+ },+ })+ if err != nil {+ t.Fatalf("AttenuateBiscuit(inner): %v", err)+ }+ sealedTok, err := identity.SealBiscuit(innerTok)+ if err != nil {+ t.Fatalf("SealBiscuit: %v", err)+ }++ req, err := http.NewRequestWithContext(ctx, http.MethodPost, targetURL, strings.NewReader(`{}`))+ if err != nil {+ t.Fatalf("NewRequest: %v", err)+ }+ req.Header.Set(api.HeaderMeshBiscuit, base64.StdEncoding.EncodeToString(sealedTok))+ req.Header.Set(api.HeaderMeshTask, "spoofed-task")++ resp, err := client.Do(req)+ if err != nil {+ t.Fatalf("client.Do: %v", err)+ }+ _ = resp.Body.Close()+ if resp.StatusCode != http.StatusOK {+ t.Fatalf("status = %d, want 200", resp.StatusCode)+ }+ if got := captured.Get(api.HeaderMeshTask); got != "step-2" {+ t.Errorf("X-Mesh-Task = %q, want %q", got, "step-2")+ }+ })+}++func TestPreferredRouterIngressURL_PrefersAttachedRouter(t *testing.T) {+ routerA, _ := mustTestPeerID(t)+ routerB, _ := mustTestPeerID(t)++ n := &AgentMeshNode{+ attached: make(map[peer.ID]bool),+ routerCatalog: []routerCandidate{+ {AddrInfo: peer.AddrInfo{ID: routerA}, IngressURL: "https://a.ingress.example/"},+ {AddrInfo: peer.AddrInfo{ID: routerB}, IngressURL: "https://b.ingress.example/"},+ },+ }++ urls := n.RouterIngressURLs()+ if len(urls) != 2 || urls[0] != "https://a.ingress.example" || urls[1] != "https://b.ingress.example" {+ t.Fatalf("RouterIngressURLs() = %v, want [https://a.ingress.example https://b.ingress.example]", urls)+ }+ if got := n.PreferredRouterIngressURL(); got != "https://a.ingress.example" {+ t.Errorf("PreferredRouterIngressURL() with none attached = %q, want https://a.ingress.example", got)+ }++ n.attached[routerB] = true+ if got := n.PreferredRouterIngressURL(); got != "https://b.ingress.example" {+ t.Errorf("PreferredRouterIngressURL() with routerB attached = %q, want https://b.ingress.example", got)+ }+}++type fakeObservableIngressService struct {+ fakeService+ announce bool+ ingressActive bool+}++func (f *fakeObservableIngressService) NoAnnounce() bool { return !f.announce }+func (f *fakeObservableIngressService) SetIngressActive(active bool) { f.ingressActive = active }+func (f *fakeObservableIngressService) ExternalIngressAllowed() bool { return f.ingressActive }++func TestServiceRegistry_UnannouncedAndExternalIngressGate(t *testing.T) {+ t.Run("unannounced service skips Provide and Withdraw", func(t *testing.T) {+ dht := &fakeIngressDHT{}+ reg := newServiceRegistryForTest(dht)++ svc := &fakeObservableIngressService{+ fakeService: fakeService{+ info: &api.ServiceInfo{+ Name: "hidden-agent",+ Type: api.ServiceType_SERVICE_TYPE_A2A,+ Ingress: &api.ServiceIngress{AuthMode: api.IngressAuthMode_INGRESS_AUTH_MODE_PASSTHROUGH},+ },+ handler: http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {}),+ },+ announce: false,+ }+ if err := reg.Register(context.Background(), svc); err != nil {+ t.Fatalf("Register: %v", err)+ }+ if len(dht.calls) != 0 || len(dht.ingressCalls) != 0 {+ t.Errorf("unannounced Register called DHT (plain=%d, ingress=%d), want 0", len(dht.calls), len(dht.ingressCalls))+ }+ if svc.ingressActive {+ t.Error("expected ingressActive=false when service is not announced")+ }+ if err := reg.Unregister(context.Background(), "hidden-agent"); err != nil {+ t.Fatalf("Unregister: %v", err)+ }+ if len(dht.withdrawn) != 0 {+ t.Errorf("unannounced Unregister called Withdraw %d times, want 0", len(dht.withdrawn))+ }+ })++ t.Run("refused ingress sets observer inactive and gates externalIngressHandler 404", func(t *testing.T) {+ cpPub, cpPriv, err := ed25519.GenerateKey(rand.Reader)+ if err != nil {+ t.Fatalf("GenerateKey: %v", err)+ }+ routerPID, _ := mustTestPeerID(t)+ _, servingPriv := mustTestPeerID(t)+ routerTok, err := identity.MintBootstrapBiscuitToken(+ cpPriv, routerPID, api.RoleRouter, time.Now().Add(time.Hour),+ []*api.PolicyRole{{Name: api.RoleRouter}}, nil,+ )+ if err != nil {+ t.Fatalf("MintBootstrapBiscuitToken: %v", err)+ }++ dht := &fakeIngressDHT{failIngressErr: errors.New("router refused ingress role ceiling")}+ reg := newServiceRegistryForTest(dht)+ svc := &fakeObservableIngressService{+ fakeService: fakeService{+ info: &api.ServiceInfo{+ Name: "gated-agent",+ Type: api.ServiceType_SERVICE_TYPE_A2A,+ Ingress: &api.ServiceIngress{AuthMode: api.IngressAuthMode_INGRESS_AUTH_MODE_PASSTHROUGH},+ },+ handler: http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {+ w.WriteHeader(http.StatusOK)+ }),+ },+ announce: true,+ ingressActive: true,+ }+ if err := reg.Register(context.Background(), svc); err != nil {+ t.Fatalf("Register: %v", err)+ }+ if svc.ingressActive {+ t.Fatal("expected SetIngressActive(false) when router refused ProvideWithIngress")+ }++ n := &AgentMeshNode{+ config: Options{PrivKey: servingPriv},+ services: reg,+ trustedKeys: []TrustedKey{{Key: cpPub, ReceivedAt: time.Now()}},+ BiscuitTimeout: time.Second,+ }+ req := httptest.NewRequest(http.MethodPost, "http://mesh/a2a/gated-agent/events", strings.NewReader(`{}`))+ req.RemoteAddr = routerPID.String()+ req.Header.Set(api.HeaderMeshBiscuit, base64.StdEncoding.EncodeToString(routerTok))+ req.Header.Set(api.HeaderMeshIngress, api.IngressAuthModeStringPassthrough)+ rec := httptest.NewRecorder()+ n.externalIngressHandler().ServeHTTP(rec, req)+ if rec.Code != http.StatusNotFound {+ t.Fatalf("externalIngressHandler status = %d, want 404 when ExternalIngressAllowed() is false: %s", rec.Code, rec.Body.String())+ }+ })+}diff --git a/internal/node/mcp_handlers_test.go b/internal/node/mcp_handlers_test.goindex 0ca44e39..e5234ab7 100644--- a/internal/node/mcp_handlers_test.go+++ b/internal/node/mcp_handlers_test.go@@ -144,11 +144,29 @@ func TestHandleFindRemoteTools_SelfPeerRejected(t *testing.T) {node, cleanup := startBareNode(t, ctx)defer cleanup()- _, _, err := node.handleFindRemoteTools(ctx, &mcp.CallToolRequest{}, FindRemoteToolsParams{- PeerID: node.Host.ID().String(),- })- if err == nil {- t.Fatal("expected error when peer_id equals self peer ID")+ 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)+ }+ })}}diff --git a/internal/node/node.go b/internal/node/node.goindex 42bccbe6..c37d2b8e 100644--- a/internal/node/node.go+++ b/internal/node/node.go@@ -2663,7 +2663,7 @@ func (n *AgentMeshNode) StartIngressServer(ctx context.Context) error {if len(claims.Roles) > 0 {r.Header.Set(api.HeaderMeshRoles, strings.Join(claims.Roles, ","))}- if t := outermostTaskName(claims.TaskRules); t != "" {+ if t := claims.InnermostTaskName(); t != "" {r.Header.Set(api.HeaderMeshTask, t)}}@@ -2938,15 +2938,6 @@ func (n *AgentMeshNode) startCatalogReportLoop(ctx context.Context, initialDelay}()}-func outermostTaskName(rules []*api.TaskAuthorizationRule) string {- for i := len(rules) - 1; i >= 0; i-- {- if rules[i] != nil && rules[i].GetName() != "" {- return rules[i].GetName()- }- }- return ""-}-// Services returns the node's local service registry (available after Start).func (n *AgentMeshNode) Services() *ServiceRegistry {return n.servicesdiff --git a/internal/node/oidc_test.go b/internal/node/oidc_test.goindex 2c81debd..290caf5a 100644--- a/internal/node/oidc_test.go+++ b/internal/node/oidc_test.go@@ -902,3 +902,73 @@ func TestRenewWithRefreshToken(t *testing.T) {t.Errorf("Expected updated refresh token 'new_refresh_token_456', got '%s'", newRefresh)}}++func TestOIDCMethodsRejectPlaintextNonLoopbackTransport(t *testing.T) {+ prevGlobal := allowInsecureControlPlane.Load()+ SetAllowInsecureControlPlane(false)+ t.Cleanup(func() { SetAllowInsecureControlPlane(prevGlobal) })++ // 192.0.2.10 is RFC 5737 TEST-NET-1: if RoundTrip attempted a TCP dial+ // instead of failing at api.ValidateControlPlaneTransport, the short context+ // would time out with context.DeadlineExceeded rather than a transport policy error.+ ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)+ defer cancel()++ strictNode := &AgentMeshNode{BiscuitTimeout: 500 * time.Millisecond}+ // An in-process node opting into AllowInsecureControlPlane must stay scoped+ // to that instance and leave strictNode rejecting plaintext non-loopback URLs.+ _ = &AgentMeshNode{+ BiscuitTimeout: 500 * time.Millisecond,+ config: Options{AllowInsecureControlPlane: true},+ }++ const nonLoopbackIssuer = "http://192.0.2.10:8080"+ cases := []struct {+ name string+ call func() error+ }{+ {+ name: "DiscoverTokenURL",+ call: func() error {+ _, err := strictNode.DiscoverTokenURL(ctx, nonLoopbackIssuer)+ return err+ },+ },+ {+ name: "DiscoverEndpointsWithDevice",+ call: func() error {+ _, err := strictNode.DiscoverEndpointsWithDevice(ctx, nonLoopbackIssuer)+ return err+ },+ },+ {+ name: "DeviceLogin",+ call: func() error {+ _, err := strictNode.DeviceLogin(ctx, nonLoopbackIssuer+"/device", nonLoopbackIssuer+"/token", "client-id", "aud", false)+ return err+ },+ },+ {+ name: "RefreshJWT",+ call: func() error {+ _, _, err := strictNode.RefreshJWT(ctx, nonLoopbackIssuer+"/token", "client-id", "", "rt-123")+ return err+ },+ },+ }++ for _, tc := range cases {+ t.Run(tc.name, func(t *testing.T) {+ err := tc.call()+ if err == nil {+ t.Fatalf("%s accepted plaintext non-loopback URL %s, want error", tc.name, nonLoopbackIssuer)+ }+ if ctx.Err() != nil {+ t.Fatalf("%s dialed the network and hit context deadline (%v) instead of failing closed at transport check: %v", tc.name, ctx.Err(), err)+ }+ if !strings.Contains(strings.ToLower(err.Error()), "https") && !strings.Contains(strings.ToLower(err.Error()), "plaintext") && !strings.Contains(strings.ToLower(err.Error()), "insecure") {+ t.Errorf("%s error = %v, want transport policy rejection mentioning https/plaintext/insecure", tc.name, err)+ }+ })+ }+}diff --git a/internal/node/store_test.go b/internal/node/store_test.goindex 10f76fb7..bd4627e2 100644--- a/internal/node/store_test.go+++ b/internal/node/store_test.go@@ -578,3 +578,42 @@ func TestGetDefaultDataDir(t *testing.T) {t.Fatalf("GetDefaultDataDir = %q, want %q", got, custom)}}++func TestStore_SetOnChange(t *testing.T) {+ store, err := NewStore(t.TempDir())+ if err != nil {+ t.Fatalf("NewStore: %v", err)+ }+ defer func() { _ = store.Close() }()++ calls := 0+ var hookErr error+ store.SetOnChange(func() error {+ calls+++ return hookErr+ })++ if err := store.SaveKey([]byte("priv-key")); err != nil {+ t.Fatalf("SaveKey: %v", err)+ }+ if err := store.SaveIdentity([]byte("biscuit")); err != nil {+ t.Fatalf("SaveIdentity: %v", err)+ }+ if err := store.SaveRefreshToken("rt-rotated"); err != nil {+ t.Fatalf("SaveRefreshToken: %v", err)+ }+ if err := store.SetCredential(&api.MemberCredential{OidcSession: &api.OIDCSession{RefreshToken: "rt-2"}}); err != nil {+ t.Fatalf("SetCredential: %v", err)+ }+ if err := store.ResetMeshIdentity(); err != nil {+ t.Fatalf("ResetMeshIdentity: %v", err)+ }+ if calls != 5 {+ t.Fatalf("onChange calls = %d, want 5", calls)+ }++ hookErr = errors.New("sync disk full")+ if err := store.SaveRefreshToken("rt-3"); !errors.Is(err, hookErr) {+ t.Fatalf("SaveRefreshToken with failing onChange = %v, want %v", err, hookErr)+ }+}diff --git a/sdk/meshnet/a2a.go b/sdk/meshnet/a2a.goindex 0ba4d182..5fbac58a 100644--- a/sdk/meshnet/a2a.go+++ b/sdk/meshnet/a2a.go@@ -506,7 +506,7 @@ func (s *Server) callerInfoFromRequest(r *http.Request) (*CallerInfo, bool) {caller.Principal = claims.Principal()caller.Roles = slices.Clone(claims.Roles)caller.Labels = maps.Clone(claims.Labels)- caller.Task = outermostTaskName(claims.TaskRules)+ caller.Task = claims.InnermostTaskName()if externalIngress {if actor := cmp.Or(claims.ActorNodePeerID, claims.NodePeerID); actor != "" {if id, pErr := peer.Decode(actor); pErr == nil {@@ -527,15 +527,6 @@ func (s *Server) callerInfoFromRequest(r *http.Request) (*CallerInfo, bool) {return caller, externalIngress}-func outermostTaskName(rules []*api.TaskAuthorizationRule) string {- for i := len(rules) - 1; i >= 0; i-- {- if rules[i] != nil && rules[i].GetName() != "" {- return rules[i].GetName()- }- }- return ""-}-const (a2aAgentCardEscapedPath = "/.well-known/agent-card.json"maxAgentCardBytes = 1 << 20