Agent Mesh
Go a2aa2a-protocolagent-meshagentic-aiinferencemcpmeshmesh-networknetwork-securitynetworking-aip2p-network
refactor to use mcp over tcp
Antonio Ojeab7e300a7f62f
diff --git a/cmd/sam-node/main.go b/cmd/sam-node/main.goindex 35bcab35..de14135e 100644--- a/cmd/sam-node/main.go+++ b/cmd/sam-node/main.go@@ -23,7 +23,6 @@ import ("net/http""os""os/signal"- "path/filepath""strings""syscall""time"@@ -59,7 +58,7 @@ var (clientSecretFlag stringtokenURLFlag stringhubPublicKeyFlag string- mcpSocketFlag string+ mcpAddrFlag stringmeshFlag stringdiscoveryIntervalFlag stringenableRelayFlag bool@@ -219,7 +218,7 @@ func main() {node.Host.SetStreamHandler(api.AuthProtocolID, node.HandleAuthHandshake)// Start MCP Server- startMCPServer(node, mcpSocketFlag, dataDir)+ startMCPServer(node, mcpAddrFlag)fmt.Printf("SAM Node Online.\nPeerID: %s\nListening on: %v\n", node.Host.ID(), node.Host.Addrs())@@ -306,7 +305,7 @@ func main() {runCmd.Flags().StringVar(&clientIDFlag, "client-id", os.Getenv("SAM_OIDC_ID"), "OIDC Client ID for M2M")runCmd.Flags().StringVar(&clientSecretFlag, "client-secret", os.Getenv("SAM_OIDC_SECRET"), "OIDC Client Secret for M2M")runCmd.Flags().StringVar(&hubPublicKeyFlag, "hub-public-key", "", "Hub Public Key (32-byte Hex)")- runCmd.Flags().StringVar(&mcpSocketFlag, "mcp-socket", "", "Path to Unix domain socket for local MCP server (default: <datadir>/mcp.sock)")+ runCmd.Flags().StringVar(&mcpAddrFlag, "mcp-addr", "127.0.0.1:8080", "Local TCP address for the MCP HTTP/SSE server")runCmd.Flags().StringVar(&meshFlag, "mesh", DefaultMeshName, "Mesh federation name")runCmd.Flags().StringVar(&discoveryIntervalFlag, "discovery-interval", DefaultDiscoveryInterval, "Polling interval for DHT discovery")runCmd.Flags().BoolVar(&enableRelayFlag, "enable-relay", false, "Allow this node to serve as a relay for others")@@ -357,20 +356,16 @@ func getOrGenerateKey(s *Store) crypto.PrivKey {return priv}-func startMCPServer(node *SamNode, socketPath string, dataDir string) {+func startMCPServer(node *SamNode, mcpAddr string) {mcpHandler := NewMCPHandler(node)go func() {- if socketPath == "" {- socketPath = filepath.Join(dataDir, "mcp.sock")+ if mcpAddr == "" {+ mcpAddr = "127.0.0.1:8080"}- if err := os.Remove(socketPath); err != nil && !os.IsNotExist(err) {- logger.Errorf("Failed to remove old socket %s: %v", socketPath, err)- }-- listener, err := net.Listen("unix", socketPath)+ listener, err := net.Listen("tcp", mcpAddr)if err != nil {- logger.Errorf("Failed to listen on Unix socket %s: %v", socketPath, err)+ logger.Errorf("Failed to listen on TCP address %s: %v", mcpAddr, err)return}defer func() {@@ -379,7 +374,7 @@ func startMCPServer(node *SamNode, socketPath string, dataDir string) {}}()- fmt.Printf("Starting MCP server on Unix socket %s\n", socketPath)+ fmt.Printf("Starting MCP server on TCP address %s\n", listener.Addr().String())if err := http.Serve(listener, mcpHandler); err != nil {logger.Errorf("MCP server error: %v", err)}diff --git a/cmd/sam-node/mcp_test.go b/cmd/sam-node/mcp_test.goindex 68ecaeb0..b6d15389 100644--- a/cmd/sam-node/mcp_test.go+++ b/cmd/sam-node/mcp_test.go@@ -15,120 +15,52 @@package mainimport (- "io"+ "net/http"+ "net/http/httptest""testing"- "time"-- lru "github.com/hashicorp/golang-lru/v2"- "github.com/libp2p/go-libp2p/core/network"- "github.com/libp2p/go-libp2p/core/peer"- "github.com/google/sam/api"- "github.com/libp2p/go-libp2p/core/protocol")+func TestMCPHandler_HTTP(t *testing.T) {+ // Setup a dummy node+ node := &SamNode{}+ handler := NewMCPHandler(node)-type mockStream struct {- r io.Reader- w io.Writer- protocol protocol.ID-}--func (s *mockStream) Read(p []byte) (n int, err error) {- return s.r.Read(p)-}-func (s *mockStream) Write(p []byte) (n int, err error) {- return s.w.Write(p)-}-func (s *mockStream) Close() error {- if c, ok := s.w.(io.Closer); ok {- return c.Close()- }- return nil-}-func (s *mockStream) Protocol() protocol.ID {- return s.protocol-}--type mockConn struct {- network.Conn // Embed interface- remotePeer peer.ID-}--func (c *mockConn) RemotePeer() peer.ID {- return c.remotePeer-}--func (s *mockStream) Conn() network.Conn {- return &mockConn{remotePeer: peer.ID("dummy-peer-id")}-}-func (s *mockStream) Reset() error {- return nil-}-func (s *mockStream) CloseRead() error {- return nil-}-func (s *mockStream) CloseWrite() error {- return nil-}-func (s *mockStream) ID() string {- return "dummy-stream-id"-}-func (s *mockStream) ResetWithError(code network.StreamErrorCode) error {- return nil-}-func (s *mockStream) Scope() network.StreamScope {- return nil-}-func (s *mockStream) SetDeadline(t time.Time) error {- return nil-}-func (s *mockStream) SetReadDeadline(t time.Time) error {- return nil-}-func (s *mockStream) SetWriteDeadline(t time.Time) error {- return nil-}-func (s *mockStream) SetProtocol(id protocol.ID) error {- s.protocol = id- return nil-}-func (s *mockStream) Stat() network.Stats {- return network.Stats{}-}+ ts := httptest.NewServer(handler)+ defer ts.Close()-func TestZeroTrustMCPServer(t *testing.T) {- pr1, pw1 := io.Pipe()- pr2, pw2 := io.Pipe()+ client := &http.Client{}- serverStream := &mockStream{r: pr1, w: pw2, protocol: api.MCPProtocolID}- clientStream := &mockStream{r: pr2, w: pw1, protocol: api.MCPProtocolID}+ // Test GET on root+ req, err := http.NewRequest("GET", ts.URL, nil)+ if err != nil {+ t.Fatal(err)+ }- rl, _ := NewPeerRateLimiter(100)- rp, _ := lru.New[string, int64](100)- vc, _ := lru.New[string, string](100)- node := &SamNode{- rateLimiter: rl,- revokedPeers: rp,- verificationCache: vc,+ resp, err := client.Do(req)+ if err != nil {+ t.Fatal(err)}+ defer resp.Body.Close()- go func() {- handler := node.WithBiscuitAuth(node.HandleMCPStream)- handler(serverStream)- }()+ // We expect OK or MethodNotAllowed depending on exact handler implementation,+ // but it should not be 404 or 500.+ if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusMethodNotAllowed && resp.StatusCode != http.StatusBadRequest {+ t.Errorf("Expected status OK, MethodNotAllowed, or BadRequest on root, got %d", resp.StatusCode)+ }- // Test: Skip sending AuthFrame and write MCP message directly!- if _, err := pw1.Write([]byte(`{"jsonrpc":"2.0","method":"initialize"}`)); err != nil {- t.Fatalf("failed to write to pipe: %v", err)+ // Test GET on /mcp+ req2, err := http.NewRequest("GET", ts.URL+"/mcp", nil)+ if err != nil {+ t.Fatal(err)}- if err := pw1.Close(); err != nil {- t.Fatalf("failed to close pipe: %v", err)++ resp2, err := client.Do(req2)+ if err != nil {+ t.Fatal(err)}+ defer resp2.Body.Close()- // Server should read invalid auth frame and close stream!- msg := make([]byte, 100)- _, err := clientStream.Read(msg)- if err == nil {- t.Errorf("Expected error reading from stream (stream should be closed by server), got nil")+ if resp2.StatusCode != http.StatusOK && resp2.StatusCode != http.StatusMethodNotAllowed && resp2.StatusCode != http.StatusBadRequest {+ t.Errorf("Expected status OK, MethodNotAllowed, or BadRequest on /mcp, got %d", resp2.StatusCode)}}diff --git a/cmd/sam-node/middleware_test.go b/cmd/sam-node/middleware_test.goindex 09a427f6..2877b837 100644--- a/cmd/sam-node/middleware_test.go+++ b/cmd/sam-node/middleware_test.go@@ -15,6 +15,7 @@package mainimport (+ "context""crypto/ed25519""crypto/sha256""encoding/hex"@@ -29,12 +30,58 @@ import ("github.com/google/sam/api"lru "github.com/hashicorp/golang-lru/v2""github.com/libp2p/go-libp2p/core/network"+ "github.com/libp2p/go-libp2p/core/crypto""github.com/libp2p/go-libp2p/core/peer""github.com/libp2p/go-libp2p/core/protocol""github.com/libp2p/go-msgio"+ "github.com/multiformats/go-multiaddr""google.golang.org/protobuf/proto")+type mockConn struct {+ remotePeer peer.ID+}++func (c *mockConn) RemotePeer() peer.ID { return c.remotePeer }+func (c *mockConn) LocalPeer() peer.ID { return "" }+func (c *mockConn) LocalMultiaddr() multiaddr.Multiaddr { return nil }+func (c *mockConn) RemoteMultiaddr() multiaddr.Multiaddr { return nil }+func (c *mockConn) Stat() network.ConnStats { return network.ConnStats{} }+func (c *mockConn) Scope() network.ConnScope { return nil }+func (c *mockConn) Close() error { return nil }+func (c *mockConn) CloseWithError(network.ConnErrorCode) error { return nil }+func (c *mockConn) ConnState() network.ConnectionState { return network.ConnectionState{} }+func (c *mockConn) GetStreams() []network.Stream { return nil }+func (c *mockConn) ID() string { return "" }+func (c *mockConn) IsClosed() bool { return false }+func (c *mockConn) NewStream(context.Context) (network.Stream, error) { return nil, nil }+func (c *mockConn) RemotePublicKey() crypto.PubKey { return nil }+func (c *mockConn) As(interface{}) bool { return false }++type mockStream struct {+ r io.Reader+ w io.Writer+ protocol protocol.ID+ conn network.Conn+}++func (s *mockStream) Read(p []byte) (n int, err error) { return s.r.Read(p) }+func (s *mockStream) Write(p []byte) (n int, err error) { return s.w.Write(p) }+func (s *mockStream) Close() error { return nil }+func (s *mockStream) Protocol() protocol.ID { return s.protocol }+func (s *mockStream) ID() string { return "" }+func (s *mockStream) SetProtocol(protocol.ID) error { return nil }+func (s *mockStream) CloseRead() error { return nil }+func (s *mockStream) CloseWrite() error { return nil }+func (s *mockStream) Reset() error { return nil }+func (s *mockStream) ResetWithError(network.StreamErrorCode) error { return nil }+func (s *mockStream) SetDeadline(time.Time) error { return nil }+func (s *mockStream) SetReadDeadline(time.Time) error { return nil }+func (s *mockStream) SetWriteDeadline(time.Time) error { return nil }+func (s *mockStream) Stat() network.Stats { return network.Stats{} }+func (s *mockStream) Conn() network.Conn { return s.conn }+func (s *mockStream) Scope() network.StreamScope { return nil }+func TestAuthorize(t *testing.T) {dir, err := os.MkdirTemp("", "middleware-test")if err != nil {@@ -318,7 +365,7 @@ func TestRevocation(t *testing.T) {pr1, pw1 := io.Pipe()pr2, pw2 := io.Pipe()- serverStream := &mockStream{r: pr1, w: pw2, protocol: protocol.ID("/test/proto")}+ serverStream := &mockStream{r: pr1, w: pw2, protocol: protocol.ID("/test/proto"), conn: &mockConn{remotePeer: dummyPeer}}// Run handler in goroutinego func() {@@ -442,7 +489,7 @@ func TestHandleAuthHandshakeCache(t *testing.T) {pr1, pw1 := io.Pipe()- serverStream := &mockStream{r: pr1, w: io.Discard, protocol: api.AuthProtocolID}+ serverStream := &mockStream{r: pr1, w: io.Discard, protocol: api.AuthProtocolID, conn: &mockConn{remotePeer: dummyPeer}}go func() {node.HandleAuthHandshake(serverStream)@@ -483,7 +530,7 @@ func TestHandleAuthHandshakeCache(t *testing.T) {node.Store = store2pr5, pw5 := io.Pipe()- serverStream3 := &mockStream{r: pr5, w: io.Discard, protocol: api.AuthProtocolID}+ serverStream3 := &mockStream{r: pr5, w: io.Discard, protocol: api.AuthProtocolID, conn: &mockConn{remotePeer: dummyPeer}}go func() {node.HandleAuthHandshake(serverStream3)diff --git a/sam-mcp-python/pyproject.toml b/sam-mcp-python/pyproject.tomlindex 1c4c4d5b..d63165e3 100644--- a/sam-mcp-python/pyproject.toml+++ b/sam-mcp-python/pyproject.toml@@ -8,7 +8,9 @@ version = "0.1.0"description = "Python SDK for Sovereign Agent Mesh (SAM) using MCP"readme = "README.md"requires-python = ">=3.10"-dependencies = []+dependencies = [+ "mcp>=1.0.0",+][project.optional-dependencies]langchain = [@@ -24,3 +26,7 @@ include = ["src"][tool.hatch.build.targets.wheel]packages = ["src/sam_mcp"]++[tool.pytest.ini_options]+pythonpath = ["src"]+asyncio_mode = "strict"diff --git a/sam-mcp-python/src/sam_mcp/client.py b/sam-mcp-python/src/sam_mcp/client.pyindex cc3ad15e..75b8941d 100644--- a/sam-mcp-python/src/sam_mcp/client.py+++ b/sam-mcp-python/src/sam_mcp/client.py@@ -1,74 +1,49 @@-import json+import asyncioimport osfrom typing import Any, Dict, List, Optional-from .transport import SamTransport-from .protocol import Protocol, JsonRpcError+from mcp import ClientSession+from mcp.client.sse import sse_clientclass SamClient:- """High-level developer interface for SAM MCP."""+ """High-level developer interface for SAM MCP using official SDK."""- def __init__(self, socket_path: Optional[str] = None):- if socket_path is None:- socket_path = os.environ.get("SAM_MCP_SOCKET", "/tmp/sam/mcp.sock")- self.transport = SamTransport(socket_path)- self._request_id = 0+ def __init__(self, server_url: Optional[str] = None):+ if server_url is None:+ server_url = os.environ.get("SAM_MCP_URL", "http://localhost:8080/sse")+ self.server_url = server_url+ self.session: Optional[ClientSession] = None+ self._sse_cm = Noneasync def connect(self):- """Connects to the SAM node and performs MCP initialization."""- await self.transport.connect()- await self._initialize()+ """Connects to the SAM node via SSE."""+ self._sse_cm = sse_client(self.server_url)+ read_stream, write_stream = await self._sse_cm.__aenter__()+ self.session = ClientSession(read_stream, write_stream)+ await self.session.__aenter__()+ await self.session.initialize()async def close(self):"""Closes the connection."""- await self.transport.close()-- def _next_id(self) -> int:- self._request_id += 1- return self._request_id-- async def _initialize(self):- """Performs MCP handshake."""- params = {- "protocolVersion": "2024-11-05",- "capabilities": {},- "clientInfo": {"name": "sam-mcp-python", "version": "0.1.0"}- }- req = Protocol.create_request("initialize", params, self._next_id())- resp_str = await self.transport.send_message(json.dumps(req))- resp = Protocol.parse_message(resp_str)-- if "error" in resp:- raise JsonRpcError(resp["error"]["code"], resp["error"]["message"], resp["error"].get("data"))-- # Standard MCP also expects an 'initialized' notification- notif = Protocol.create_request("notifications/initialized")- await self.transport.send_message(json.dumps(notif))+ if self.session:+ await self.session.__aexit__(None, None, None)+ if self._sse_cm:+ await self._sse_cm.__aexit__(None, None, None)+ self.session = None+ self._sse_cm = Noneasync def get_tools(self) -> List[Dict[str, Any]]:"""Returns available mesh tools."""- req = Protocol.create_request("tools/list", {}, self._next_id())- resp_str = await self.transport.send_message(json.dumps(req))- resp = Protocol.parse_message(resp_str)-- if "error" in resp:- raise JsonRpcError(resp["error"]["code"], resp["error"]["message"], resp["error"].get("data"))-- return resp.get("result", {}).get("tools", [])+ if not self.session:+ raise RuntimeError("Not connected")+ resp = await self.session.list_tools()+ return [t.model_dump() if hasattr(t, "model_dump") else t for t in resp.tools]async def call_tool(self, name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:"""Executes a tool over the mesh."""- params = {- "name": name,- "arguments": arguments- }- req = Protocol.create_request("tools/call", params, self._next_id())- resp_str = await self.transport.send_message(json.dumps(req))- resp = Protocol.parse_message(resp_str)-- if "error" in resp:- raise JsonRpcError(resp["error"]["code"], resp["error"]["message"], resp["error"].get("data"))-- return resp.get("result", {})+ if not self.session:+ raise RuntimeError("Not connected")+ resp = await self.session.call_tool(name, arguments)+ return resp.model_dump() if hasattr(resp, "model_dump") else respasync def __aenter__(self):await self.connect()diff --git a/sam-mcp-python/src/sam_mcp/protocol.py b/sam-mcp-python/src/sam_mcp/protocol.pyindex 66a21908..1c8dce54 100644--- a/sam-mcp-python/src/sam_mcp/protocol.py+++ b/sam-mcp-python/src/sam_mcp/protocol.py@@ -1,62 +1 @@-import json-from typing import Any, Dict, Optional, Union--class JsonRpcError(Exception):- def __init__(self, code: int, message: str, data: Optional[Any] = None):- self.code = code- self.message = message- self.data = data- super().__init__(f"JSON-RPC Error {code}: {message}")-- def to_dict(self) -> Dict[str, Any]:- res = {"code": self.code, "message": self.message}- if self.data is not None:- res["data"] = self.data- return res--class Protocol:- @staticmethod- def create_request(method: str, params: Optional[Dict[str, Any]] = None, request_id: Optional[Union[int, str]] = None) -> Dict[str, Any]:- req = {- "jsonrpc": "2.0",- "method": method,- }- if params is not None:- req["params"] = params- if request_id is not None:- req["id"] = request_id- return req-- @staticmethod- def create_response(request_id: Union[int, str], result: Any) -> Dict[str, Any]:- return {- "jsonrpc": "2.0",- "id": request_id,- "result": result- }-- @staticmethod- def create_error_response(request_id: Optional[Union[int, str]], code: int, message: str, data: Optional[Any] = None) -> Dict[str, Any]:- error = {"code": code, "message": message}- if data is not None:- error["data"] = data- return {- "jsonrpc": "2.0",- "id": request_id,- "error": error- }-- @staticmethod- def parse_message(message_str: str) -> Dict[str, Any]:- try:- data = json.loads(message_str)- except json.JSONDecodeError as e:- raise JsonRpcError(-32700, f"Parse error: {e}. Message: {message_str}")-- if not isinstance(data, dict):- raise JsonRpcError(-32600, "Invalid Request", "Message must be a JSON object")-- if data.get("jsonrpc") != "2.0":- raise JsonRpcError(-32600, "Invalid Request", "Missing or invalid jsonrpc version")-- return data+# Deprecated: This file is no longer used. The SDK now uses the official 'mcp' package.diff --git a/sam-mcp-python/src/sam_mcp/transport.py b/sam-mcp-python/src/sam_mcp/transport.pyindex 6e645855..1c8dce54 100644--- a/sam-mcp-python/src/sam_mcp/transport.py+++ b/sam-mcp-python/src/sam_mcp/transport.py@@ -1,88 +1 @@-import asyncio-import os-from typing import Optional--class SamTransport:- """Handles Unix domain socket connections and HTTP-like messaging for MCP."""-- def __init__(self, socket_path: str):- self.socket_path = socket_path- self.reader: Optional[asyncio.StreamReader] = None- self.writer: Optional[asyncio.StreamWriter] = None-- async def connect(self):- """Establishes connection to the Unix socket."""- self.reader, self.writer = await asyncio.open_unix_connection(self.socket_path)-- async def close(self):- """Closes the connection."""- if self.writer:- self.writer.close()- await self.writer.wait_closed()- self.reader = None- self.writer = None-- async def send_message(self, data: str) -> str:- """Sends a JSON-RPC message wrapped in HTTP POST and returns the response body."""- if not self.writer or not self.reader:- raise RuntimeError("Not connected to SAM node")-- data_bytes = data.encode('utf-8')- request = (- f"POST /mcp HTTP/1.1\r\n"- f"Host: localhost\r\n"- f"Content-Type: application/json\r\n"- f"Accept: application/json, text/event-stream\r\n"- f"Content-Length: {len(data_bytes)}\r\n"- f"\r\n"- ).encode('utf-8') + data_bytes-- self.writer.write(request)- await self.writer.drain()-- # Read HTTP response headers- headers_data = bytearray()- while True:- line = await self.reader.readline()- if not line:- raise RuntimeError("Connection closed while reading headers")- headers_data.extend(line)- if headers_data.endswith(b"\r\n\r\n"):- break-- headers_str = headers_data.decode('utf-8')- lines = headers_str.split("\r\n")-- # Parse status line- status_line = lines[0]- parts = status_line.split(" ", 2)- if len(parts) < 2:- raise RuntimeError(f"Invalid HTTP status line: {status_line}")- status_code = int(parts[1])-- # Find Content-Length- content_length = 0- for line in lines[1:]:- if line.lower().startswith("content-length:"):- content_length = int(line.split(":", 1)[1].strip())- break-- if not (200 <= status_code < 300):- body = ""- if content_length > 0:- body_bytes = await self.reader.readexactly(content_length)- body = body_bytes.decode('utf-8')- raise RuntimeError(f"HTTP Error {status_code}: {body}")-- if content_length == 0:- return ""-- body = await self.reader.readexactly(content_length)- return body.decode('utf-8')-- async def __aenter__(self):- await self.connect()- return self-- async def __aexit__(self, exc_type, exc_val, exc_tb):- await self.close()+# Deprecated: This file is no longer used. The SDK now uses the official 'mcp' package.diff --git a/sam-mcp-python/tests/unit/test_unit.py b/sam-mcp-python/tests/unit/test_unit.pyindex 8c5e595b..965c7c8e 100644--- a/sam-mcp-python/tests/unit/test_unit.py+++ b/sam-mcp-python/tests/unit/test_unit.py@@ -67,21 +67,28 @@ async def test_transport_send_message():# Client Tests@pytest.mark.asyncioasync def test_client_get_tools():- with patch("sam_mcp.client.SamTransport") as MockTransport:- mock_transport = MockTransport.return_value- mock_transport.connect = AsyncMock()- mock_transport.close = AsyncMock()+ with patch("sam_mcp.client.sse_client") as mock_sse_client, \+ patch("sam_mcp.client.ClientSession") as MockClientSession:++ mock_cm = AsyncMock()+ mock_sse_client.return_value = mock_cm+ mock_cm.__aenter__.return_value = (MagicMock(), MagicMock())+ mock_cm.__aexit__ = AsyncMock()- # Mock initialize response and tools/list response- mock_transport.send_message.side_effect = [- '{"jsonrpc":"2.0","id":1,"result":{"protocolVersion":"2024-11-05"}}', # init- '{"jsonrpc":"2.0","id":2,"result":{"tools":[{"name":"test_tool"}]}}' # list- ]- mock_transport.writer = MagicMock()- mock_transport.writer.write = AsyncMock()- mock_transport.writer.drain = AsyncMock()+ mock_session = MockClientSession.return_value+ mock_session.__aenter__ = AsyncMock(return_value=mock_session)+ mock_session.__aexit__ = AsyncMock()+ mock_session.initialize = AsyncMock()- async with SamClient(socket_path="/tmp/test.sock") as client:+ mock_tool = MagicMock()+ mock_tool.name = "test_tool"+ mock_tool.model_dump.return_value = {"name": "test_tool"}++ mock_resp = MagicMock()+ mock_resp.tools = [mock_tool]+ mock_session.list_tools = AsyncMock(return_value=mock_resp)++ async with SamClient(server_url="http://localhost:8080/sse") as client:tools = await client.get_tools()assert len(tools) == 1assert tools[0]["name"] == "test_tool"@@ -94,8 +101,8 @@ def test_langchain_adapter():client = MockClient()tools = [{"name": "test_tool", "description": "A test tool"}]- # We need to mock langchain-core import if it's not installed in the environment- with patch.dict("sys.modules", {"langchain_core.tools": MagicMock()}):+ # We need to mock langchain-core and pydantic imports if they are not installed+ with patch.dict("sys.modules", {"langchain_core.tools": MagicMock(), "pydantic": MagicMock()}):from langchain_core.tools import StructuredToolmock_structured_tool = MagicMock()diff --git a/tests/integration/catalog_test.go b/tests/integration/catalog_test.goindex 24a4dece..94dd82ff 100644--- a/tests/integration/catalog_test.go+++ b/tests/integration/catalog_test.go@@ -3,8 +3,6 @@ package integration_testimport ("context""encoding/json"- "net"- "net/http""os""os/exec""path/filepath"@@ -21,7 +19,7 @@ func startBackgroundNode(t *testing.T, nodeBin string, hubAddr string, homeDir s"HOME="+homeDir,"XDG_CONFIG_HOME="+filepath.Join(homeDir, ".config"),)- allArgs := append([]string{"run", "--hub", hubAddr, "--jwt", "test-jwt"}, args...)+ allArgs := append([]string{"run", "--hub", hubAddr, "--jwt", "test-jwt", "--mcp-addr", "127.0.0.1:0"}, args...)cmd := exec.Command(nodeBin, allArgs...)cmd.Env = env@@ -48,25 +46,36 @@ func startBackgroundNode(t *testing.T, nodeBin string, hubAddr string, homeDir sreturn cmd}-func callMCP(t *testing.T, socketPath string, toolName string, params map[string]any) string {+func waitForMCPAddr(t *testing.T, logPath string) string {t.Helper()- ctx := context.Background()-- oldTransport := http.DefaultClient.Transport- defer func() { http.DefaultClient.Transport = oldTransport }()-- http.DefaultClient.Transport = &http.Transport{- DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) {- return net.Dial("unix", socketPath)- },+ deadline := time.Now().Add(5 * time.Second)+ for time.Now().Before(deadline) {+ data, _ := os.ReadFile(logPath)+ lines := strings.Split(string(data), "\n")+ for _, line := range lines {+ if strings.Contains(line, "Starting MCP server on TCP address ") {+ parts := strings.Split(line, "Starting MCP server on TCP address ")+ if len(parts) > 1 {+ return strings.TrimSpace(parts[1])+ }+ }+ }+ time.Sleep(100 * time.Millisecond)}-+ t.Fatalf("timeout waiting for MCP addr in log: %s", logPath)+ return ""+}++func callMCP(t *testing.T, mcpAddr string, toolName string, params map[string]any) string {+ t.Helper()+ ctx := context.Background()+client := mcp.NewClient(&mcp.Implementation{Name: "test-client",Version: "0.1.0",}, nil)-- session, err := client.Connect(ctx, &mcp.StreamableClientTransport{Endpoint: "http://localhost/"}, nil)++ session, err := client.Connect(ctx, &mcp.StreamableClientTransport{Endpoint: "http://" + mcpAddr + "/"}, nil)if err != nil {t.Fatalf("Failed to connect: %v", err)}@@ -75,7 +84,7 @@ func callMCP(t *testing.T, socketPath string, toolName string, params map[stringt.Logf("failed to close session: %v", err)}}()-+result, err := session.CallTool(ctx, &mcp.CallToolParams{Name: toolName,Arguments: params,@@ -83,7 +92,7 @@ func callMCP(t *testing.T, socketPath string, toolName string, params map[stringif err != nil {t.Fatalf("CallTool failed: %v", err)}-+for _, content := range result.Content {if textContent, ok := content.(*mcp.TextContent); ok {return textContent.Text@@ -126,30 +135,18 @@ func TestCatalogRoutingAndFailover(t *testing.T) {nodeBin := buildBinary(t, "./cmd/sam-node")_, hubAddr := startMockLibp2pHub(t)- scratchDir := filepath.Join(repoRoot(t), "tests", "integration", "scratch")- _ = os.RemoveAll(scratchDir) // Clear old logs-- homeA := filepath.Join(scratchDir, "homeA")- homeB := filepath.Join(scratchDir, "homeB")- homeC := filepath.Join(scratchDir, "homeC")-- if err := os.MkdirAll(homeA, 0755); err != nil {- t.Fatalf("failed to create homeA: %v", err)- }- if err := os.MkdirAll(homeB, 0755); err != nil {- t.Fatalf("failed to create homeB: %v", err)- }- if err := os.MkdirAll(homeC, 0755); err != nil {- t.Fatalf("failed to create homeC: %v", err)- }-- socketPathA := filepath.Join(homeA, ".config", "sam-mesh", "mcp.sock")+ homeA := t.TempDir()+ homeB := t.TempDir()+ homeC := t.TempDir()// Start Node A (Client)t.Log("Starting Node A...")_ = 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")t.Log("Node A started.")+ // Wait for Node A to start and get its MCP address+ mcpAddrA := waitForMCPAddr(t, filepath.Join(homeA, "node.log"))+// Start Node B (Provider 1)t.Log("Starting Node B...")cmdB := 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")@@ -163,35 +160,25 @@ func TestCatalogRoutingAndFailover(t *testing.T) {// Wait for Node B and C to start and get their addressesaddrB := waitForPeerInfoInLog(t, filepath.Join(homeB, "node.log"))addrC := waitForPeerInfoInLog(t, filepath.Join(homeC, "node.log"))-+// Force Node A to connect to Node B and Node C- callMCP(t, socketPathA, "connect_peer", map[string]any{"peer_addr": addrB})- callMCP(t, socketPathA, "connect_peer", map[string]any{"peer_addr": addrC})+ callMCP(t, mcpAddrA, "connect_peer", map[string]any{"peer_addr": addrB})+ callMCP(t, mcpAddrA, "connect_peer", map[string]any{"peer_addr": addrC})// Wait for them to discover each other and publish catalog by polling get_mesh_infot.Log("Polling for discovery...")deadline := time.Now().Add(2 * time.Second)var connected bool-- oldTransport := http.DefaultClient.Transport- defer func() { http.DefaultClient.Transport = oldTransport }()-- http.DefaultClient.Transport = &http.Transport{- DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) {- return net.Dial("unix", socketPathA)- },- }-for time.Now().Before(deadline) {client := mcp.NewClient(&mcp.Implementation{Name: "test-client", Version: "0.1.0"}, nil)- session, err := client.Connect(context.Background(), &mcp.StreamableClientTransport{Endpoint: "http://localhost/"}, nil)+ session, err := client.Connect(context.Background(), &mcp.StreamableClientTransport{Endpoint: "http://" + mcpAddrA + "/"}, nil)if err != nil {t.Logf("Poll: failed to connect: %v", err)time.Sleep(500 * time.Millisecond)continue}-+result, err := session.CallTool(context.Background(), &mcp.CallToolParams{Name: "get_mesh_info", Arguments: map[string]any{}})if closeErr := session.Close(); closeErr != nil {t.Logf("Poll: failed to close session: %v", closeErr)@@ -201,7 +188,7 @@ func TestCatalogRoutingAndFailover(t *testing.T) {time.Sleep(500 * time.Millisecond)continue}-+var text stringfor _, content := range result.Content {if textContent, ok := content.(*mcp.TextContent); ok {@@ -233,7 +220,7 @@ func TestCatalogRoutingAndFailover(t *testing.T) {t.Fatalf("failed to discover peers (Hub + 2 nodes) in time")}- respData := callMCP(t, socketPathA, "send_message", map[string]any{"peer_id": "target-peer", "message": "hello"})+ respData := callMCP(t, mcpAddrA, "send_message", map[string]any{"peer_id": "target-peer", "message": "hello"})t.Logf("First call response: %s", respData)// Now kill Node B and assert failover to Node C@@ -244,6 +231,6 @@ func TestCatalogRoutingAndFailover(t *testing.T) {// Wait a bit for catalog update or failover to happen on next calltime.Sleep(500 * time.Millisecond)- respData2 := callMCP(t, socketPathA, "send_message", map[string]any{"peer_id": "target-peer", "message": "hello"})+ respData2 := callMCP(t, mcpAddrA, "send_message", map[string]any{"peer_id": "target-peer", "message": "hello"})t.Logf("Second call response: %s", respData2)}diff --git a/tests/integration/pubsub_test.go b/tests/integration/pubsub_test.goindex 7c135f05..921673c0 100644--- a/tests/integration/pubsub_test.go+++ b/tests/integration/pubsub_test.go@@ -16,8 +16,6 @@ package integration_testimport ("context"- "net"- "net/http""os""os/exec""path/filepath"@@ -43,15 +41,12 @@ func TestPubSubTools(t *testing.T) {}t.Logf("Node 2 logs at: %s/node2.log", tmpHome2)- socket1 := filepath.Join(tmpHome1, "mcp.sock")- socket2 := filepath.Join(tmpHome2, "mcp.sock")-ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)defer cancel()// Start Node 1env1 := append(os.Environ(), "HOME="+tmpHome1, "XDG_CONFIG_HOME="+filepath.Join(tmpHome1, ".config"))- cmd1 := exec.CommandContext(ctx, nodeBin, "run", "--hub", hubAddr, "--mcp-socket", socket1, "--listen", "/ip4/127.0.0.1/udp/5003/quic-v1", "--listen", "/ip4/127.0.0.1/tcp/5004", "--jwt", "dummy-token", "--log-level", "debug", "--discovery-interval", "100ms")+ cmd1 := exec.CommandContext(ctx, nodeBin, "run", "--hub", hubAddr, "--mcp-addr", "127.0.0.1:0", "--listen", "/ip4/127.0.0.1/udp/5003/quic-v1", "--listen", "/ip4/127.0.0.1/tcp/5004", "--jwt", "dummy-token", "--log-level", "debug", "--discovery-interval", "100ms")cmd1.Env = env1logFile1, err := os.Create(filepath.Join(tmpHome1, "node1.log"))if err != nil {@@ -66,7 +61,7 @@ func TestPubSubTools(t *testing.T) {// Start Node 2env2 := append(os.Environ(), "HOME="+tmpHome2, "XDG_CONFIG_HOME="+filepath.Join(tmpHome2, ".config"))- cmd2 := exec.CommandContext(ctx, nodeBin, "run", "--hub", hubAddr, "--mcp-socket", socket2, "--listen", "/ip4/127.0.0.1/udp/5005/quic-v1", "--listen", "/ip4/127.0.0.1/tcp/5006", "--jwt", "dummy-token", "--log-level", "debug", "--discovery-interval", "100ms")+ cmd2 := exec.CommandContext(ctx, nodeBin, "run", "--hub", hubAddr, "--mcp-addr", "127.0.0.1:0", "--listen", "/ip4/127.0.0.1/udp/5005/quic-v1", "--listen", "/ip4/127.0.0.1/tcp/5006", "--jwt", "dummy-token", "--log-level", "debug", "--discovery-interval", "100ms")cmd2.Env = env2logFile2, err := os.Create(filepath.Join(tmpHome2, "node2.log"))if err != nil {@@ -79,36 +74,38 @@ func TestPubSubTools(t *testing.T) {}defer func() { _ = cmd2.Process.Kill(); _ = logFile2.Close() }()- // Wait for sockets to appear- waitForSocket := func(socketPath string) {- for i := 0; i < 50; i++ {- if _, err := os.Stat(socketPath); err == nil {- return+ // Helper to wait for MCP addr in log+ waitForMCPAddr := func(t *testing.T, logPath string) string {+ t.Helper()+ deadline := time.Now().Add(5 * time.Second)+ for time.Now().Before(deadline) {+ data, _ := os.ReadFile(logPath)+ lines := strings.Split(string(data), "\n")+ for _, line := range lines {+ if strings.Contains(line, "Starting MCP server on TCP address ") {+ parts := strings.Split(line, "Starting MCP server on TCP address ")+ if len(parts) > 1 {+ return strings.TrimSpace(parts[1])+ }+ }}time.Sleep(100 * time.Millisecond)}- t.Fatalf("Socket %s did not appear", socketPath)+ t.Fatalf("timeout waiting for MCP addr in log: %s", logPath)+ return ""}- waitForSocket(socket1)- waitForSocket(socket2)- // Helper to call MCP tool- callTool := func(socketPath string, toolName string, params map[string]any) string {- oldTransport := http.DefaultClient.Transport- defer func() { http.DefaultClient.Transport = oldTransport }()-- http.DefaultClient.Transport = &http.Transport{- DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) {- return net.Dial("unix", socketPath)- },- }+ mcpAddr1 := waitForMCPAddr(t, filepath.Join(tmpHome1, "node1.log"))+ mcpAddr2 := waitForMCPAddr(t, filepath.Join(tmpHome2, "node2.log"))+ // Helper to call MCP tool+ callTool := func(mcpAddr string, toolName string, params map[string]any) string {client := mcp.NewClient(&mcp.Implementation{Name: "test-client",Version: "0.1.0",}, nil)- session, err := client.Connect(context.Background(), &mcp.StreamableClientTransport{Endpoint: "http://localhost/"}, nil)+ session, err := client.Connect(context.Background(), &mcp.StreamableClientTransport{Endpoint: "http://" + mcpAddr + "/"}, nil)if err != nil {t.Fatalf("Failed to connect: %v", err)}@@ -170,10 +167,10 @@ func TestPubSubTools(t *testing.T) {// Force Node 1 to connect to Node 2addr2 := waitForPeerInfoInLog(t, filepath.Join(tmpHome2, "node2.log"))t.Logf("Node 2 address: %s", addr2)- callTool(socket1, "connect_peer", map[string]any{"peer_addr": addr2})+ callTool(mcpAddr1, "connect_peer", map[string]any{"peer_addr": addr2})// Node 1 broadcasts on topic "test-topic"- broadcastResult := callTool(socket1, "mesh_pubsub_broadcast", map[string]any{+ broadcastResult := callTool(mcpAddr1, "mesh_pubsub_broadcast", map[string]any{"topic": "test-topic","payload": "hello from node 1",})@@ -182,7 +179,7 @@ func TestPubSubTools(t *testing.T) {}// Node 2 subscribes to topic "test-topic"- subscribeResult := callTool(socket2, "subscribe_topic", map[string]any{+ subscribeResult := callTool(mcpAddr2, "subscribe_topic", map[string]any{"topic": "test-topic",})if !strings.Contains(subscribeResult, "Subscribed") {@@ -193,7 +190,7 @@ func TestPubSubTools(t *testing.T) {deadline := time.Now().Add(10 * time.Second)for time.Now().Before(deadline) {// Node 1 broadcasts on topic "test-topic" again to ensure delivery after subscription- broadcastResult = callTool(socket1, "mesh_pubsub_broadcast", map[string]any{+ broadcastResult = callTool(mcpAddr1, "mesh_pubsub_broadcast", map[string]any{"topic": "test-topic","payload": "hello from node 1",})@@ -202,7 +199,7 @@ func TestPubSubTools(t *testing.T) {}// Node 2 polls for messages on topic "test-topic"- pollResult = callTool(socket2, "poll_messages", map[string]any{+ pollResult = callTool(mcpAddr2, "poll_messages", map[string]any{"topic": "test-topic",})if strings.Contains(pollResult, "hello from node 1") {