Skip to content

Agent Mesh

simplify

Antonio Ojeaac6f0ae811eb
diff --git a/cmd/sam-agent/inspect.go b/cmd/sam-agent/inspect.go
index 66f94e75..60707cce 100644
--- a/cmd/sam-agent/inspect.go
+++ b/cmd/sam-agent/inspect.go
@@ -137,16 +137,13 @@ func runInspectCard(cfg *runConfig, input string) error {
fmt.Println(string(data))
} else {
fmt.Printf("Peer ID: %s\n", card.PeerID)
- fmt.Printf("Name: %s\n", card.Name)
- fmt.Printf("Description: %s\n", card.Description)
- fmt.Printf("Version: %s\n", card.Version)
fmt.Printf("Algorithm: %s\n", card.Algorithm)
fmt.Printf("Issued At: %s\n", card.IssuedAt.Format("2006-01-02T15:04:05Z07:00"))
if len(card.Capabilities) > 0 {
fmt.Println("\nCapabilities:")
for _, capability := range card.Capabilities {
- fmt.Printf(" - %s: %s\n", capability.ID, capability.Description)
+ fmt.Printf(" - %s\n", capability)
}
}
diff --git a/cmd/sam-agent/proxy_reserved_test.go b/cmd/sam-agent/proxy_reserved_test.go
index faf0b775..266bcadc 100644
--- a/cmd/sam-agent/proxy_reserved_test.go
+++ b/cmd/sam-agent/proxy_reserved_test.go
@@ -123,7 +123,7 @@ func TestSAMReservedSearchReturnsPublishedWriterCard(t *testing.T) {
if priv == nil {
t.Fatalf("publisher private key missing")
}
- card, err := protocol.NewAgentCard(nodeA.PeerID(), []string{"writer"}, priv, mcpprotocol.WithResources([]mcpprotocol.Resource{{Name: "writer", Kind: "tool", Endpoint: "mcp://writer"}}))
+ card, err := protocol.NewAgentCard(nodeA.PeerID(), []string{"writer"}, []mcpprotocol.Resource{{Name: "writer", Kind: "tool", Endpoint: "mcp://writer"}}, priv)
if err != nil {
t.Fatalf("creating writer card: %v", err)
}
diff --git a/cmd/sam-agent/publish.go b/cmd/sam-agent/publish.go
index ce94cfb8..655821ec 100644
--- a/cmd/sam-agent/publish.go
+++ b/cmd/sam-agent/publish.go
@@ -121,7 +121,7 @@ func runPublish(parent context.Context, cfg *runConfig) error {
Description: strings.TrimSpace(cfg.resourceDesc),
}
- card, err := protocol.NewAgentCard(node.PeerID(), cfg.capabilities, priv, mcpprotocol.WithResources([]mcpprotocol.Resource{resource}))
+ card, err := protocol.NewAgentCard(node.PeerID(), cfg.capabilities, []mcpprotocol.Resource{resource}, priv)
if err != nil {
return fmt.Errorf("building agent card: %w", err)
}
@@ -253,7 +253,7 @@ func runPublishDryRunClient(cfg *runConfig) error {
Description: strings.TrimSpace(cfg.resourceDesc),
}
- card, err := protocol.NewAgentCard(peerID, cfg.capabilities, privKey, mcpprotocol.WithResources([]mcpprotocol.Resource{resource}))
+ card, err := protocol.NewAgentCard(peerID, cfg.capabilities, []mcpprotocol.Resource{resource}, privKey)
if err != nil {
return fmt.Errorf("building agent card: %w", err)
}
diff --git a/cmd/sam-agent/publish_card.go b/cmd/sam-agent/publish_card.go
index f99559b4..ada4e753 100644
--- a/cmd/sam-agent/publish_card.go
+++ b/cmd/sam-agent/publish_card.go
@@ -66,7 +66,7 @@ func runPublishCard(parent context.Context, cfg *runConfig) error {
Endpoint: strings.TrimSpace(cfg.resourceEP),
Description: strings.TrimSpace(cfg.resourceDesc),
}
- card, err := protocol.NewAgentCard(node.PeerID(), cfg.capabilities, priv, mcpprotocol.WithResources([]mcpprotocol.Resource{resource}))
+ card, err := protocol.NewAgentCard(node.PeerID(), cfg.capabilities, []mcpprotocol.Resource{resource}, priv)
if err != nil {
return fmt.Errorf("building agent card: %w", err)
}
diff --git a/cmd/sam-agent/publish_mcp.go b/cmd/sam-agent/publish_mcp.go
index 0c1a95ab..d3361490 100644
--- a/cmd/sam-agent/publish_mcp.go
+++ b/cmd/sam-agent/publish_mcp.go
@@ -74,7 +74,7 @@ func runPublishMCP(parent context.Context, cfg *runConfig) error {
Kind: strings.TrimSpace(cfg.resourceKind),
Endpoint: fmt.Sprintf("http://127.0.0.1:%d", cfg.mcpPort),
}
- card, err := protocol.NewAgentCard(node.PeerID(), cfg.capabilities, priv, mcpprotocol.WithResources([]mcpprotocol.Resource{resource}))
+ card, err := protocol.NewAgentCard(node.PeerID(), cfg.capabilities, []mcpprotocol.Resource{resource}, priv)
if err != nil {
return fmt.Errorf("building agent card: %w", err)
}
diff --git a/pkg/protocol/a2a/agent_card_adapter.go b/pkg/protocol/a2a/agent_card_adapter.go
index 317a7118..a89f3610 100644
--- a/pkg/protocol/a2a/agent_card_adapter.go
+++ b/pkg/protocol/a2a/agent_card_adapter.go
@@ -27,19 +27,11 @@ import (
"sam/pkg/protocol/discovery"
)
-const protocolPayloadName = "a2a"
-
// ToA2ACard converts a generic discovery AgentCard into the official A2A SDK representation.
func ToA2ACard(card *discovery.AgentCard, interfaceURL string) (*a2asdk.AgentCard, error) {
if card == nil {
return nil, fmt.Errorf("agent card is nil")
}
- if strings.TrimSpace(card.Version) == "" {
- return nil, fmt.Errorf("card version is required")
- }
- if strings.TrimSpace(card.Name) == "" {
- return nil, fmt.Errorf("card name is required")
- }
if strings.TrimSpace(card.PeerID) == "" {
return nil, fmt.Errorf("card peer ID is required")
}
@@ -47,10 +39,7 @@ func ToA2ACard(card *discovery.AgentCard, interfaceURL string) (*a2asdk.AgentCar
return nil, fmt.Errorf("at least one capability is required")
}
- out, _ := synthesizeA2ACard(card)
- if err := card.DecodeProtocolPayload(protocolPayloadName, &out); err == nil {
- out = normalizeA2ASDKCard(out)
- }
+ out := synthesizeA2ACard(card)
if strings.TrimSpace(interfaceURL) != "" {
out.SupportedInterfaces = []*a2asdk.AgentInterface{
a2asdk.NewAgentInterface(strings.TrimSpace(interfaceURL), a2asdk.TransportProtocolJSONRPC),
@@ -84,107 +73,74 @@ func AgentCardFromA2A(peerID string, card *a2asdk.AgentCard, resources []mcpprot
}
out := &discovery.AgentCard{
- Version: discovery.AgentCardVersion,
- Name: strings.TrimSpace(card.Name),
- Description: strings.TrimSpace(card.Description),
Capabilities: capabilitiesFromSkills(card.Skills),
- Interfaces: interfacesFromA2A(card.SupportedInterfaces),
+ Tools: append([]discovery.Tool(nil), resources...),
PeerID: peerID,
IssuedAt: time.Now().UTC(),
Algorithm: discovery.AgentCardSignAlgo,
}
- if err := mcpprotocol.SetResources(out, resources); err != nil {
- return nil, err
- }
- if err := out.SetProtocolPayload(protocolPayloadName, normalizeA2ASDKCard(*card)); err != nil {
- return nil, err
- }
+ mcpprotocol.SetResources(out, resources)
return out, nil
}
-func synthesizeA2ACard(card *discovery.AgentCard) (a2asdk.AgentCard, error) {
- if card == nil {
- return a2asdk.AgentCard{}, fmt.Errorf("agent card is nil")
- }
+func synthesizeA2ACard(card *discovery.AgentCard) a2asdk.AgentCard {
out := a2asdk.AgentCard{
Capabilities: a2asdk.AgentCapabilities{Streaming: true},
- Description: strings.TrimSpace(card.Description),
- Name: strings.TrimSpace(card.Name),
+ Description: "SAM agent " + strings.TrimSpace(card.PeerID),
+ Name: "sam-agent-" + strings.TrimSpace(card.PeerID),
Skills: skillsFromCapabilities(card.Capabilities),
Version: discovery.AgentCardVersion,
}
- for _, item := range card.Interfaces {
- if item.Protocol != protocolPayloadName {
- continue
- }
- binding := a2asdk.TransportProtocolJSONRPC
- if strings.TrimSpace(item.Binding) != "" {
- binding = a2asdk.TransportProtocol(strings.TrimSpace(item.Binding))
- }
- iface := a2asdk.NewAgentInterface(strings.TrimSpace(item.URL), binding)
- iface.Tenant = strings.TrimSpace(item.Tenant)
- out.SupportedInterfaces = append(out.SupportedInterfaces, iface)
- }
- return normalizeA2ASDKCard(out), nil
+ return normalizeA2ASDKCard(out)
}
-func skillsFromCapabilities(in []discovery.Capability) []a2asdk.AgentSkill {
+func skillsFromCapabilities(in []string) []a2asdk.AgentSkill {
out := make([]a2asdk.AgentSkill, 0, len(in))
for _, capability := range in {
- identifier := strings.TrimSpace(capability.ID)
- if identifier == "" {
- identifier = strings.TrimSpace(capability.Name)
- }
+ identifier := strings.TrimSpace(capability)
if identifier == "" {
continue
}
out = append(out, a2asdk.AgentSkill{
ID: identifier,
- Name: strings.TrimSpace(capability.Name),
- Description: strings.TrimSpace(capability.Description),
- Tags: append([]string(nil), capability.Tags...),
+ Name: identifier,
+ Description: "SAM capability " + identifier,
+ Tags: []string{"sam"},
})
}
return normalizeSkills(out)
}
-func capabilitiesFromSkills(in []a2asdk.AgentSkill) []discovery.Capability {
- out := make([]discovery.Capability, 0, len(in))
+func capabilitiesFromSkills(in []a2asdk.AgentSkill) []string {
+ out := make([]string, 0, len(in))
for _, skill := range in {
identifier := strings.TrimSpace(skill.ID)
- name := strings.TrimSpace(skill.Name)
if identifier == "" {
- identifier = name
- }
- if name == "" {
- name = identifier
+ identifier = strings.TrimSpace(skill.Name)
}
if identifier == "" {
continue
}
- out = append(out, discovery.Capability{
- ID: identifier,
- Name: name,
- Description: strings.TrimSpace(skill.Description),
- Tags: append([]string(nil), skill.Tags...),
- })
+ out = append(out, identifier)
}
- return out
+ return discoveryNormalizeCapabilities(out)
}
-func interfacesFromA2A(in []*a2asdk.AgentInterface) []discovery.Interface {
- out := make([]discovery.Interface, 0, len(in))
- for _, item := range in {
- if item == nil {
+func discoveryNormalizeCapabilities(capabilities []string) []string {
+ seen := make(map[string]struct{}, len(capabilities))
+ out := make([]string, 0, len(capabilities))
+ for _, capability := range capabilities {
+ capability = strings.ToLower(strings.TrimSpace(capability))
+ if capability == "" {
continue
}
- out = append(out, discovery.Interface{
- Protocol: protocolPayloadName,
- URL: strings.TrimSpace(item.URL),
- Binding: string(item.ProtocolBinding),
- Tenant: strings.TrimSpace(item.Tenant),
- })
+ if _, ok := seen[capability]; ok {
+ continue
+ }
+ seen[capability] = struct{}{}
+ out = append(out, capability)
}
+ sort.Strings(out)
return out
}
diff --git a/pkg/protocol/a2a/agent_card_adapter_test.go b/pkg/protocol/a2a/agent_card_adapter_test.go
index dc9176e9..5dc1d93d 100644
--- a/pkg/protocol/a2a/agent_card_adapter_test.go
+++ b/pkg/protocol/a2a/agent_card_adapter_test.go
@@ -38,8 +38,8 @@ func TestToA2ACard(t *testing.T) {
card, err := discovery.NewAgentCard(
pid,
[]string{"inference", "search"},
+ []mcpprotocol.Resource{{Name: "mcp", Kind: "tool"}},
priv,
- mcpprotocol.WithResources([]mcpprotocol.Resource{{Name: "mcp", Kind: "tool"}}),
)
if err != nil {
t.Fatalf("NewAgentCard() error = %v", err)
@@ -78,13 +78,6 @@ func TestAgentCardFromA2A(t *testing.T) {
if err != nil {
t.Fatalf("AgentCardFromA2A() error = %v", err)
}
- var stored a2asdk.AgentCard
- if err := card.DecodeProtocolPayload(protocolPayloadName, &stored); err != nil {
- t.Fatalf("DecodeProtocolPayload() error = %v", err)
- }
- if stored.Name != a2aCard.Name {
- t.Fatalf("stored protocol payload name = %q, want %q", stored.Name, a2aCard.Name)
- }
resources := mcpprotocol.ResourcesFromCard(card)
if len(resources) != 0 {
t.Fatalf("len(resources) = %d, want 0", len(resources))
diff --git a/pkg/protocol/discovery/agent_card.go b/pkg/protocol/discovery/agent_card.go
index b6119441..734fde01 100644
--- a/pkg/protocol/discovery/agent_card.go
+++ b/pkg/protocol/discovery/agent_card.go
@@ -15,7 +15,6 @@
package discovery
import (
- "bytes"
"encoding/base64"
"encoding/json"
"fmt"
@@ -33,58 +32,36 @@ const (
AgentDHTNamespaceBase = "/sam/v1/agents/"
)
-// CardOption lets protocol packages enrich generic discovery cards without
-// leaking protocol-specific fields into discovery itself.
-type CardOption func(*AgentCard) error
-
-// Capability describes a normalized capability advertised by an agent.
-type Capability struct {
- ID string `json:"id"`
- Name string `json:"name,omitempty"`
- Description string `json:"description,omitempty"`
- Tags []string `json:"tags,omitempty"`
-}
-
-// Interface describes a protocol endpoint injected by a protocol-specific adapter.
-type Interface struct {
- Protocol string `json:"protocol"`
- URL string `json:"url"`
- Binding string `json:"binding,omitempty"`
- Tenant string `json:"tenant,omitempty"`
- Description string `json:"description,omitempty"`
- Metadata map[string]string `json:"metadata,omitempty"`
+// Tool describes an advertised local tool endpoint.
+type Tool struct {
+ Name string `json:"name"`
+ Kind string `json:"kind"`
+ Endpoint string `json:"endpoint,omitempty"`
+ Description string `json:"description,omitempty"`
}
// AgentCard is the signed capability document advertised in the SAM mesh.
//
// The signature covers all fields except Signature.
type AgentCard struct {
- Version string `json:"version"`
- Name string `json:"name"`
- Description string `json:"description,omitempty"`
- Capabilities []Capability `json:"capabilities"`
- Interfaces []Interface `json:"interfaces,omitempty"`
- Protocols map[string]json.RawMessage `json:"protocols,omitempty"`
- PeerID string `json:"peer_id"`
- IssuedAt time.Time `json:"issued_at"`
- Algorithm string `json:"alg"`
- Signature string `json:"signature"`
+ PeerID string `json:"peer_id"`
+ Capabilities []string `json:"capabilities"`
+ Tools []Tool `json:"tools,omitempty"`
+ IssuedAt time.Time `json:"issued_at"`
+ Algorithm string `json:"alg"`
+ Signature string `json:"signature"`
}
type agentCardPayload struct {
- Version string `json:"version"`
- Name string `json:"name"`
- Description string `json:"description,omitempty"`
- Capabilities []Capability `json:"capabilities"`
- Interfaces []Interface `json:"interfaces,omitempty"`
- Protocols map[string]json.RawMessage `json:"protocols,omitempty"`
- PeerID string `json:"peer_id"`
- IssuedAt time.Time `json:"issued_at"`
- Algorithm string `json:"alg"`
+ PeerID string `json:"peer_id"`
+ Capabilities []string `json:"capabilities"`
+ Tools []Tool `json:"tools,omitempty"`
+ IssuedAt time.Time `json:"issued_at"`
+ Algorithm string `json:"alg"`
}
// NewAgentCard builds and signs an AgentCard for DHT advertisement.
-func NewAgentCard(peerID peer.ID, capabilities []string, privateKey crypto.PrivKey, opts ...CardOption) (*AgentCard, error) {
+func NewAgentCard(peerID peer.ID, capabilities []string, tools []Tool, privateKey crypto.PrivKey) (*AgentCard, error) {
if privateKey == nil {
return nil, fmt.Errorf("private key is required")
}
@@ -95,28 +72,14 @@ func NewAgentCard(peerID peer.ID, capabilities []string, privateKey crypto.PrivK
if len(normalizedCaps) == 0 {
return nil, fmt.Errorf("at least one capability is required")
}
- descriptors := make([]Capability, 0, len(normalizedCaps))
- for _, capability := range normalizedCaps {
- descriptors = append(descriptors, Capability{
- ID: capability,
- Name: capability,
- Description: "SAM capability " + capability,
- Tags: []string{"sam"},
- })
- }
card := &AgentCard{
- Version: AgentCardVersion,
- Name: "sam-agent-" + peerID.String(),
- Description: "SAM agent " + peerID.String(),
- Capabilities: descriptors,
+ Capabilities: normalizedCaps,
+ Tools: normalizeTools(tools),
PeerID: peerID.String(),
IssuedAt: time.Now().UTC(),
Algorithm: AgentCardSignAlgo,
}
- if err := ApplyCardOptions(card, opts...); err != nil {
- return nil, err
- }
if err := SignAgentCard(card, privateKey); err != nil {
return nil, err
@@ -202,19 +165,13 @@ func (c *AgentCard) Verify() error {
}
func (c *AgentCard) validateBase() error {
- if strings.TrimSpace(c.Version) == "" {
- return fmt.Errorf("card version is required")
- }
- if strings.TrimSpace(c.Name) == "" {
- return fmt.Errorf("card name is required")
- }
if strings.TrimSpace(c.PeerID) == "" {
return fmt.Errorf("card peer ID is required")
}
if _, err := peer.Decode(c.PeerID); err != nil {
return fmt.Errorf("invalid peer ID %q: %w", c.PeerID, err)
}
- if len(c.Capabilities) == 0 {
+ if len(normalizeCapabilities(c.Capabilities)) == 0 {
return fmt.Errorf("at least one capability is required")
}
if c.IssuedAt.IsZero() {
@@ -223,142 +180,26 @@ func (c *AgentCard) validateBase() error {
if strings.TrimSpace(c.Algorithm) == "" {
return fmt.Errorf("signature algorithm is required")
}
- if _, err := normalizeProtocolPayloads(c.Protocols); err != nil {
- return err
- }
return nil
}
func (c *AgentCard) signingPayload() ([]byte, error) {
- protocols, err := normalizeProtocolPayloads(c.Protocols)
- if err != nil {
- return nil, err
- }
p := agentCardPayload{
- Version: strings.TrimSpace(c.Version),
- Name: strings.TrimSpace(c.Name),
- Description: strings.TrimSpace(c.Description),
- Capabilities: normalizeCapabilityDescriptors(c.Capabilities),
- Interfaces: normalizeInterfaces(c.Interfaces),
- Protocols: protocols,
PeerID: c.PeerID,
+ Capabilities: normalizeCapabilities(c.Capabilities),
+ Tools: normalizeTools(c.Tools),
IssuedAt: c.IssuedAt.UTC(),
Algorithm: c.Algorithm,
}
return json.Marshal(p)
}
-// CapabilityNames returns normalized capability identifiers derived from A2A skills.
+// CapabilityNames returns normalized capability identifiers.
func (c *AgentCard) CapabilityNames() []string {
if c == nil {
return nil
}
- names := make([]string, 0, len(c.Capabilities))
- for _, capability := range c.Capabilities {
- name := strings.TrimSpace(capability.ID)
- if name == "" {
- name = strings.TrimSpace(capability.Name)
- }
- if name != "" {
- names = append(names, name)
- }
- }
- return normalizeCapabilities(names)
-}
-
-// SetProtocolPayload stores a protocol-specific payload in canonical JSON form.
-func (c *AgentCard) SetProtocolPayload(name string, payload any) error {
- if c == nil {
- return fmt.Errorf("agent card is nil")
- }
- raw, err := json.Marshal(payload)
- if err != nil {
- return fmt.Errorf("encoding protocol payload %q: %w", name, err)
- }
- return c.SetProtocolRawPayload(name, raw)
-}
-
-// SetProtocolRawPayload stores a raw protocol payload after compacting it.
-func (c *AgentCard) SetProtocolRawPayload(name string, payload []byte) error {
- if c == nil {
- return fmt.Errorf("agent card is nil")
- }
- name = strings.ToLower(strings.TrimSpace(name))
- if name == "" {
- return fmt.Errorf("protocol name is required")
- }
- var compact bytes.Buffer
- if err := json.Compact(&compact, payload); err != nil {
- return fmt.Errorf("protocol payload %q must be valid JSON: %w", name, err)
- }
- if c.Protocols == nil {
- c.Protocols = make(map[string]json.RawMessage, 1)
- }
- c.Protocols[name] = append(json.RawMessage(nil), compact.Bytes()...)
- return nil
-}
-
-// DecodeProtocolPayload decodes a protocol-specific payload into out.
-func (c *AgentCard) DecodeProtocolPayload(name string, out any) error {
- if c == nil {
- return fmt.Errorf("agent card is nil")
- }
- name = strings.ToLower(strings.TrimSpace(name))
- raw := c.Protocols[name]
- if len(raw) == 0 {
- return fmt.Errorf("protocol payload %q not found", name)
- }
- if err := json.Unmarshal(raw, out); err != nil {
- return fmt.Errorf("decoding protocol payload %q: %w", name, err)
- }
- return nil
-}
-
-// ApplyCardOptions applies protocol-owned hooks to the card.
-func ApplyCardOptions(card *AgentCard, opts ...CardOption) error {
- if card == nil {
- return fmt.Errorf("agent card is nil")
- }
- for _, opt := range opts {
- if opt == nil {
- continue
- }
- if err := opt(card); err != nil {
- return err
- }
- }
- return nil
-}
-
-// WithName overrides the generic display name in the discovery card.
-func WithName(name string) CardOption {
- return func(card *AgentCard) error {
- card.Name = strings.TrimSpace(name)
- return nil
- }
-}
-
-// WithDescription overrides the generic description in the discovery card.
-func WithDescription(description string) CardOption {
- return func(card *AgentCard) error {
- card.Description = strings.TrimSpace(description)
- return nil
- }
-}
-
-// WithInterface appends a generic protocol interface advertisement.
-func WithInterface(iface Interface) CardOption {
- return func(card *AgentCard) error {
- card.Interfaces = append(card.Interfaces, iface)
- return nil
- }
-}
-
-// WithProtocolPayload stores protocol-specific metadata in the card.
-func WithProtocolPayload(name string, payload any) CardOption {
- return func(card *AgentCard) error {
- return card.SetProtocolPayload(name, payload)
- }
+ return normalizeCapabilities(c.Capabilities)
}
func normalizeCapabilities(capabilities []string) []string {
@@ -379,82 +220,23 @@ func normalizeCapabilities(capabilities []string) []string {
return out
}
-func normalizeCapabilityDescriptors(in []Capability) []Capability {
- cloned := make([]Capability, 0, len(in))
- for _, capability := range in {
- capability.ID = strings.ToLower(strings.TrimSpace(capability.ID))
- capability.Name = strings.TrimSpace(capability.Name)
- capability.Description = strings.TrimSpace(capability.Description)
- if capability.ID == "" {
- capability.ID = strings.ToLower(strings.TrimSpace(capability.Name))
- }
- if capability.Name == "" {
- capability.Name = capability.ID
- }
- if capability.ID == "" {
+func normalizeTools(tools []Tool) []Tool {
+ out := make([]Tool, 0, len(tools))
+ for _, tool := range tools {
+ tool.Name = strings.TrimSpace(tool.Name)
+ tool.Kind = strings.TrimSpace(tool.Kind)
+ tool.Endpoint = strings.TrimSpace(tool.Endpoint)
+ tool.Description = strings.TrimSpace(tool.Description)
+ if tool.Name == "" {
continue
}
- for index := range capability.Tags {
- capability.Tags[index] = strings.TrimSpace(capability.Tags[index])
- }
- capability.Tags = normalizeCapabilities(capability.Tags)
- cloned = append(cloned, capability)
+ out = append(out, tool)
}
- sort.Slice(cloned, func(i, j int) bool {
- if cloned[i].ID == cloned[j].ID {
- return cloned[i].Name < cloned[j].Name
+ sort.Slice(out, func(i, j int) bool {
+ if out[i].Name == out[j].Name {
+ return out[i].Kind < out[j].Kind
}
- return cloned[i].ID < cloned[j].ID
+ return out[i].Name < out[j].Name
})
- return cloned
-}
-
-func normalizeInterfaces(in []Interface) []Interface {
- cloned := make([]Interface, 0, len(in))
- for _, item := range in {
- item.Protocol = strings.ToLower(strings.TrimSpace(item.Protocol))
- item.URL = strings.TrimSpace(item.URL)
- item.Binding = strings.TrimSpace(item.Binding)
- item.Tenant = strings.TrimSpace(item.Tenant)
- item.Description = strings.TrimSpace(item.Description)
- if item.Protocol == "" || item.URL == "" {
- continue
- }
- if len(item.Metadata) == 0 {
- item.Metadata = nil
- }
- cloned = append(cloned, item)
- }
- sort.Slice(cloned, func(i, j int) bool {
- if cloned[i].Protocol == cloned[j].Protocol {
- if cloned[i].URL == cloned[j].URL {
- return cloned[i].Binding < cloned[j].Binding
- }
- return cloned[i].URL < cloned[j].URL
- }
- return cloned[i].Protocol < cloned[j].Protocol
- })
- return cloned
-}
-
-func normalizeProtocolPayloads(in map[string]json.RawMessage) (map[string]json.RawMessage, error) {
- if len(in) == 0 {
- return nil, nil
- }
- out := make(map[string]json.RawMessage, len(in))
- for name, payload := range in {
- name = strings.ToLower(strings.TrimSpace(name))
- if name == "" || len(payload) == 0 {
- continue
- }
- var compact bytes.Buffer
- if err := json.Compact(&compact, payload); err != nil {
- return nil, fmt.Errorf("protocol payload %q must be valid JSON: %w", name, err)
- }
- out[name] = append(json.RawMessage(nil), compact.Bytes()...)
- }
- if len(out) == 0 {
- return nil, nil
- }
- return out, nil
+ return out
}
diff --git a/pkg/protocol/discovery/agent_card_test.go b/pkg/protocol/discovery/agent_card_test.go
index 05dfd7a9..5b10d44e 100644
--- a/pkg/protocol/discovery/agent_card_test.go
+++ b/pkg/protocol/discovery/agent_card_test.go
@@ -38,8 +38,8 @@ func TestAgentCardSignVerify(t *testing.T) {
card, err := protocol.NewAgentCard(
pid,
[]string{"Inference", "search", "search"},
+ []mcpprotocol.Resource{{Name: "local-mcp", Kind: "tool", Endpoint: "unix:///tmp/mcp.sock"}},
priv,
- mcpprotocol.WithResources([]mcpprotocol.Resource{{Name: "local-mcp", Kind: "tool", Endpoint: "unix:///tmp/mcp.sock"}}),
)
if err != nil {
t.Fatalf("NewAgentCard() error = %v", err)
@@ -68,6 +68,7 @@ func TestAgentCardVerifyRejectsTamper(t *testing.T) {
card, err := protocol.NewAgentCard(
pid,
[]string{"inference"},
+ nil,
priv,
)
if err != nil {
@@ -75,8 +76,7 @@ func TestAgentCardVerifyRejectsTamper(t *testing.T) {
}
card.Capabilities = append(card.Capabilities, card.Capabilities[0])
- card.Capabilities[1].ID = "search"
- card.Capabilities[1].Name = "search"
+ card.Capabilities[1] = "search"
if err := protocol.VerifyAgentCard(card); err == nil {
t.Fatal("VerifyAgentCard() should fail for tampered card")
}
@@ -93,12 +93,7 @@ func TestAgentCardVerifyRejectsMissingSignature(t *testing.T) {
}
card := &protocol.AgentCard{
- Version: protocol.AgentCardVersion,
- Name: "sam-agent-" + pid.String(),
- Capabilities: []protocol.Capability{{
- ID: "inference",
- Name: "inference",
- }},
+ Capabilities: []string{"inference"},
PeerID: pid.String(),
IssuedAt: time.Now().UTC(),
Algorithm: protocol.AgentCardSignAlgo,
diff --git a/pkg/protocol/discovery/discovery_test.go b/pkg/protocol/discovery/discovery_test.go
index 1d9566aa..1f6eed54 100644
--- a/pkg/protocol/discovery/discovery_test.go
+++ b/pkg/protocol/discovery/discovery_test.go
@@ -88,7 +88,7 @@ func TestDiscoverReturnsVerifiedCards(t *testing.T) {
defer func() { _ = consumerHost.Close() }()
providerPriv := providerHost.Peerstore().PrivKey(providerHost.ID())
- card, err := protocol.NewAgentCard(providerHost.ID(), []string{"inference"}, providerPriv)
+ card, err := protocol.NewAgentCard(providerHost.ID(), []string{"inference"}, nil, providerPriv)
if err != nil {
t.Fatalf("NewAgentCard() error = %v", err)
}
@@ -238,7 +238,7 @@ func TestDiscoverPrefersDHTCard(t *testing.T) {
t.Fatalf("IDFromPrivateKey() error = %v", err)
}
- card, err := protocol.NewAgentCard(providerID, []string{"inference"}, priv)
+ card, err := protocol.NewAgentCard(providerID, []string{"inference"}, nil, priv)
if err != nil {
t.Fatalf("NewAgentCard() error = %v", err)
}
@@ -293,7 +293,7 @@ func TestDiscoverFallsBackToStreamWhenDHTCardInvalid(t *testing.T) {
defer func() { _ = consumerHost.Close() }()
providerPriv := providerHost.Peerstore().PrivKey(providerHost.ID())
- card, err := protocol.NewAgentCard(providerHost.ID(), []string{"inference"}, providerPriv)
+ card, err := protocol.NewAgentCard(providerHost.ID(), []string{"inference"}, nil, providerPriv)
if err != nil {
t.Fatalf("NewAgentCard() error = %v", err)
}
@@ -351,7 +351,7 @@ func TestDiscoverAllowsStaleDHTCardWhenMaxAgeDisabled(t *testing.T) {
t.Fatalf("IDFromPrivateKey() error = %v", err)
}
- card, err := protocol.NewAgentCard(providerID, []string{"inference"}, priv)
+ card, err := protocol.NewAgentCard(providerID, []string{"inference"}, nil, priv)
if err != nil {
t.Fatalf("NewAgentCard() error = %v", err)
}
diff --git a/pkg/protocol/discovery/publish_test.go b/pkg/protocol/discovery/publish_test.go
index 61af9dcc..604dc9aa 100644
--- a/pkg/protocol/discovery/publish_test.go
+++ b/pkg/protocol/discovery/publish_test.go
@@ -62,7 +62,7 @@ func TestPublisherPublishesPeerAndCapabilityNamespaces(t *testing.T) {
t.Fatalf("IDFromPrivateKey() error = %v", err)
}
- card, err := protocol.NewAgentCard(pid, []string{"inference", "search"}, priv)
+ card, err := protocol.NewAgentCard(pid, []string{"inference", "search"}, nil, priv)
if err != nil {
t.Fatalf("NewAgentCard() error = %v", err)
}
@@ -109,7 +109,7 @@ func TestPublisherRejectsPeerMismatch(t *testing.T) {
t.Fatalf("IDFromPrivateKey() error = %v", err)
}
- card, err := protocol.NewAgentCard(pidA, []string{"inference"}, privA)
+ card, err := protocol.NewAgentCard(pidA, []string{"inference"}, nil, privA)
if err != nil {
t.Fatalf("NewAgentCard() error = %v", err)
}
diff --git a/pkg/protocol/mcp/agent_card_adapter.go b/pkg/protocol/mcp/agent_card_adapter.go
index 87137ac1..17f36e77 100644
--- a/pkg/protocol/mcp/agent_card_adapter.go
+++ b/pkg/protocol/mcp/agent_card_adapter.go
@@ -15,74 +15,24 @@
package mcp
import (
- "sort"
- "strings"
-
"sam/pkg/protocol/discovery"
)
-const cardProtocolName = "mcp"
-
// Resource describes an MCP-compatible tool or data source advertised by an agent.
-type Resource struct {
- Name string `json:"name"`
- Kind string `json:"kind"`
- Endpoint string `json:"endpoint,omitempty"`
- Description string `json:"description,omitempty"`
-}
-
-type cardMetadata struct {
- Resources []Resource `json:"resources,omitempty"`
-}
-
-// WithResources attaches MCP-specific resource metadata to a generic discovery card.
-func WithResources(resources []Resource) discovery.CardOption {
- return func(card *discovery.AgentCard) error {
- return SetResources(card, resources)
- }
-}
+type Resource = discovery.Tool
-// SetResources stores MCP resources in the card's protocol-specific payload.
-func SetResources(card *discovery.AgentCard, resources []Resource) error {
+// SetResources stores MCP resources directly in the discovery card tool list.
+func SetResources(card *discovery.AgentCard, resources []Resource) {
if card == nil {
- return nil
- }
- normalized := normalizeResources(resources)
- if len(normalized) == 0 {
- return nil
+ return
}
- return card.SetProtocolPayload(cardProtocolName, cardMetadata{Resources: normalized})
+ card.Tools = append([]discovery.Tool(nil), resources...)
}
-// ResourcesFromCard extracts MCP resources from a generic discovery card.
+// ResourcesFromCard returns the discovery card tool list as MCP resources.
func ResourcesFromCard(card *discovery.AgentCard) []Resource {
if card == nil {
return nil
}
- var metadata cardMetadata
- if err := card.DecodeProtocolPayload(cardProtocolName, &metadata); err != nil {
- return nil
- }
- return normalizeResources(metadata.Resources)
-}
-
-func normalizeResources(resources []Resource) []Resource {
- out := make([]Resource, 0, len(resources))
- for _, resource := range resources {
- resource.Name = strings.TrimSpace(resource.Name)
- resource.Kind = strings.TrimSpace(resource.Kind)
- resource.Endpoint = strings.TrimSpace(resource.Endpoint)
- resource.Description = strings.TrimSpace(resource.Description)
- if resource.Name == "" {
- continue
- }
- out = append(out, resource)
- }
- sort.Slice(out, func(i, j int) bool {
- if out[i].Name == out[j].Name {
- return out[i].Kind < out[j].Kind
- }
- return out[i].Name < out[j].Name
- })
- return out
+ return append([]Resource(nil), card.Tools...)
}
diff --git a/pkg/protocol/mcp/agent_card_adapter_test.go b/pkg/protocol/mcp/agent_card_adapter_test.go
index 4aa4b28a..677bc016 100644
--- a/pkg/protocol/mcp/agent_card_adapter_test.go
+++ b/pkg/protocol/mcp/agent_card_adapter_test.go
@@ -35,8 +35,8 @@ func TestWithResources(t *testing.T) {
card, err := discovery.NewAgentCard(
pid,
[]string{"search"},
+ []Resource{{Name: "search", Kind: "tool", Endpoint: "mcp://search"}},
priv,
- WithResources([]Resource{{Name: "search", Kind: "tool", Endpoint: "mcp://search"}}),
)
if err != nil {
t.Fatalf("NewAgentCard() error = %v", err)
diff --git a/tests/integration/call_test.go b/tests/integration/call_test.go
index a62d6367..c3ff13d7 100644
--- a/tests/integration/call_test.go
+++ b/tests/integration/call_test.go
@@ -240,8 +240,8 @@ func runCallProviderRole() error {
card, err := protocol.NewAgentCard(
node.PeerID(),
[]string{callCapability},
+ []mcpprotocol.Resource{{Name: "weather", Kind: "tool", Endpoint: "mcp://weather"}},
priv,
- mcpprotocol.WithResources([]mcpprotocol.Resource{{Name: "weather", Kind: "tool", Endpoint: "mcp://weather"}}),
)
if err != nil {
return fmt.Errorf("provider card creation: %w", err)
diff --git a/tests/integration/mesh_test.go b/tests/integration/mesh_test.go
index 42873781..8aa01d70 100644
--- a/tests/integration/mesh_test.go
+++ b/tests/integration/mesh_test.go
@@ -202,8 +202,8 @@ func runMeshPublisher() error {
card, err := protocol.NewAgentCard(
node.PeerID(),
[]string{meshCapability},
+ []mcpprotocol.Resource{{Name: "summarizer", Kind: "tool", Endpoint: "mcp://summarizer"}},
priv,
- mcpprotocol.WithResources([]mcpprotocol.Resource{{Name: "summarizer", Kind: "tool", Endpoint: "mcp://summarizer"}}),
)
if err != nil {
return fmt.Errorf("publisher card creation: %w", err)
diff --git a/tests/integration/p2p_test.go b/tests/integration/p2p_test.go
index 0236235e..47184373 100644
--- a/tests/integration/p2p_test.go
+++ b/tests/integration/p2p_test.go
@@ -158,33 +158,17 @@ func runProviderRole() error {
return fmt.Errorf("provider passport setup: %w", err)
}
- providerAddr := fmt.Sprintf("/ip4/%s/udp/%d/quic-v1/p2p/%s", os.Getenv(helperIPEnv), port, node.PeerID())
- info := providerInfo{PeerID: node.PeerID().String(), Bootstrap: providerAddr}
- if err := writeProviderInfo(os.Getenv(helperInfoEnv), info); err != nil {
- return err
- }
-
priv := node.Host().Peerstore().PrivKey(node.PeerID())
card, err := protocol.NewAgentCard(
node.PeerID(),
[]string{capabilityName},
+ []mcpprotocol.Resource{{Name: "echo", Kind: "tool", Endpoint: "mcp://echo"}},
priv,
- mcpprotocol.WithResources([]mcpprotocol.Resource{{Name: "echo", Kind: "tool", Endpoint: "mcp://echo"}}),
)
if err != nil {
return fmt.Errorf("provider card creation: %w", err)
}
- publisher, err := protocol.NewPublisher(node)
- if err != nil {
- return fmt.Errorf("provider publisher: %w", err)
- }
- if err := publisher.Publish(ctx, card); err != nil {
- if err := publishWithRetry(ctx, publisher, card); err != nil {
- return fmt.Errorf("provider publish: %w", err)
- }
- }
-
discovery, err := protocol.NewDiscoveryService(node)
if err != nil {
return fmt.Errorf("provider discovery service: %w", err)
@@ -197,6 +181,22 @@ func runProviderRole() error {
return fmt.Errorf("provider bridge setup: %w", err)
}
+ providerAddr := fmt.Sprintf("/ip4/%s/udp/%d/quic-v1/p2p/%s", os.Getenv(helperIPEnv), port, node.PeerID())
+ info := providerInfo{PeerID: node.PeerID().String(), Bootstrap: providerAddr}
+ if err := writeProviderInfo(os.Getenv(helperInfoEnv), info); err != nil {
+ return err
+ }
+
+ publisher, err := protocol.NewPublisher(node)
+ if err != nil {
+ return fmt.Errorf("provider publisher: %w", err)
+ }
+ if err := publisher.Publish(ctx, card); err != nil {
+ if err := publishWithRetry(ctx, publisher, card); err != nil {
+ return fmt.Errorf("provider publish: %w", err)
+ }
+ }
+
// Keep the provider online while the consumer performs discovery and bridge calls.
<-ctx.Done()
return nil