agent-relay 3.2.2 → 3.2.4

package/packages/sdk-py/tests/communicate/adapters/e2e_test_crewai.py

@@ -0,0 +1,234 @@
+"""Real end-to-end test of the CrewAI Python adapter against live Relaycast."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import time
+import uuid
+
+import pytest
+
+from agent_relay.communicate.core import Relay
+from agent_relay.communicate.types import RelayConfig
+
+pytestmark = pytest.mark.asyncio
+
+RATE_LIMIT_PAUSE = 5  # seconds between tests to avoid 429
+
+
+@pytest.fixture(autouse=True)
+async def _rate_limit_pause():
+    """Pause between tests to respect the 60 req/min rate limit."""
+    yield
+    await asyncio.sleep(RATE_LIMIT_PAUSE)
+
+
+def _e2e_config() -> RelayConfig:
+    config = RelayConfig.resolve(
+        workspace=os.environ.get("RELAY_WORKSPACE"),
+        api_key=os.environ.get("RELAY_API_KEY"),
+        base_url=os.environ.get("RELAY_BASE_URL"),
+        channels=[],
+        auto_cleanup=False,
+    )
+    if not config.workspace or not config.api_key:
+        pytest.fail("RELAY_WORKSPACE and RELAY_API_KEY must be set.")
+    return config
+
+
+def _unique_name(prefix: str) -> str:
+    ts = int(time.time() * 1000)
+    return f"{prefix}-{ts}-{uuid.uuid4().hex[:6]}"
+
+
+async def test_crewai_on_relay_adds_tools():
+    """on_relay() should attach four relay tools to a CrewAI Agent."""
+    from crewai import Agent as CrewAgent
+    from agent_relay.communicate.adapters.crewai import on_relay
+
+    config = _e2e_config()
+    agent_name = _unique_name("e2e-crewai-tools")
+
+    relay = Relay(agent_name, config)
+    try:
+        crew_agent = CrewAgent(
+            role="Test worker",
+            goal="Verify relay tools",
+            backstory="Test agent.",
+            llm="gpt-4o-mini",
+        )
+        original_tool_count = len(crew_agent.tools)
+
+        wrapped = on_relay(crew_agent, relay)
+        assert wrapped is crew_agent
+
+        tool_names = {t.name for t in crew_agent.tools}
+        expected = {"relay_send", "relay_inbox", "relay_post", "relay_agents"}
+        assert expected.issubset(tool_names), f"Missing tools: {expected - tool_names}"
+        assert len(crew_agent.tools) >= original_tool_count + 4
+    finally:
+        await relay.close()
+
+
+async def test_crewai_relay_agents_lists_live_agents():
+    """relay_agents tool should list agents from the live workspace."""
+    from crewai import Agent as CrewAgent
+    from agent_relay.communicate.adapters.crewai import on_relay
+
+    config = _e2e_config()
+    agent_name = _unique_name("e2e-crewai-list")
+
+    relay = Relay(agent_name, config)
+    try:
+        crew_agent = CrewAgent(
+            role="Lister",
+            goal="List agents",
+            backstory="Lists agents.",
+            llm="gpt-4o-mini",
+        )
+        on_relay(crew_agent, relay)
+
+        tools_by_name = {t.name: t for t in crew_agent.tools}
+        agents_tool = tools_by_name["relay_agents"]
+
+        result = await agents_tool.func()
+        assert isinstance(result, str)
+        assert agent_name in result, f"Expected {agent_name} in agents list, got: {result}"
+    finally:
+        await relay.close()
+
+
+async def test_crewai_relay_send_dm():
+    """relay_send tool should successfully send a DM via live API."""
+    from crewai import Agent as CrewAgent
+    from agent_relay.communicate.adapters.crewai import on_relay
+
+    config = _e2e_config()
+    sender_name = _unique_name("e2e-crewai-sender")
+    receiver_name = _unique_name("e2e-crewai-recv")
+
+    sender_relay = Relay(sender_name, config)
+    receiver_relay = Relay(receiver_name, config)
+    try:
+        sender_agent = CrewAgent(
+            role="Sender",
+            goal="Send messages",
+            backstory="Sends.",
+            llm="gpt-4o-mini",
+        )
+        on_relay(sender_agent, relay=sender_relay)
+
+        # Connect receiver so it exists
+        await receiver_relay._ensure_connected()
+
+        tools_by_name = {t.name: t for t in sender_agent.tools}
+        send_tool = tools_by_name["relay_send"]
+
+        result = await send_tool.func(receiver_name, f"hello-{uuid.uuid4().hex[:8]}")
+        assert result == "Message sent"
+    finally:
+        await asyncio.gather(sender_relay.close(), receiver_relay.close())
+
+
+async def test_crewai_relay_post_channel():
+    """relay_post tool should successfully post to a channel via live API."""
+    from crewai import Agent as CrewAgent
+    from agent_relay.communicate.adapters.crewai import on_relay
+
+    config = _e2e_config()
+    agent_name = _unique_name("e2e-crewai-post")
+
+    relay = Relay(agent_name, config)
+    try:
+        crew_agent = CrewAgent(
+            role="Poster",
+            goal="Post to channel",
+            backstory="Posts.",
+            llm="gpt-4o-mini",
+        )
+        on_relay(crew_agent, relay=relay)
+
+        # Join general before posting
+        await relay.join("general")
+
+        tools_by_name = {t.name: t for t in crew_agent.tools}
+        post_tool = tools_by_name["relay_post"]
+
+        msg_text = f"e2e-crewai-post-{uuid.uuid4().hex[:8]}"
+        result = await post_tool.func("general", msg_text)
+        assert result == "Message posted"
+    finally:
+        await relay.close()
+
+
+async def test_crewai_backstory_wrapping():
+    """on_relay() should wrap backstory so it includes relay messages."""
+    from crewai import Agent as CrewAgent
+    from agent_relay.communicate.adapters.crewai import on_relay
+
+    config = _e2e_config()
+    agent_name = _unique_name("e2e-crewai-backstory")
+
+    relay = Relay(agent_name, config)
+    try:
+        original_backstory = "Expert researcher."
+        crew_agent = CrewAgent(
+            role="Researcher",
+            goal="Research things",
+            backstory=original_backstory,
+            llm="gpt-4o-mini",
+        )
+        on_relay(crew_agent, relay=relay)
+
+        backstory_str = str(crew_agent.backstory)
+        assert "Expert researcher." in backstory_str
+    finally:
+        await relay.close()
+
+
+async def test_crewai_full_round_trip():
+    """Full round-trip: register, list agents, send DM, post to channel, close."""
+    from crewai import Agent as CrewAgent
+    from agent_relay.communicate.adapters.crewai import on_relay
+
+    config = _e2e_config()
+    agent_name = _unique_name("e2e-crewai-full")
+    peer_name = _unique_name("e2e-crewai-peer")
+
+    relay = Relay(agent_name, config)
+    peer_relay = Relay(peer_name, config)
+
+    try:
+        crew_agent = CrewAgent(
+            role="Full test",
+            goal="Run full e2e",
+            backstory="Full round trip.",
+            llm="gpt-4o-mini",
+        )
+        on_relay(crew_agent, relay=relay)
+        await peer_relay._ensure_connected()
+
+        tools = {t.name: t for t in crew_agent.tools}
+
+        # 1. list_agents
+        agents_result = await tools["relay_agents"].func()
+        assert agent_name in agents_result
+        assert peer_name in agents_result
+
+        # 2. send DM
+        dm_text = f"e2e-roundtrip-{uuid.uuid4().hex[:8]}"
+        send_result = await tools["relay_send"].func(peer_name, dm_text)
+        assert send_result == "Message sent"
+
+        # 3. post to channel
+        await relay.join("general")
+        post_text = f"e2e-channel-{uuid.uuid4().hex[:8]}"
+        post_result = await tools["relay_post"].func("general", post_text)
+        assert post_result == "Message posted"
+
+        # 4. inbox (may or may not have messages, just verify it runs)
+        inbox_result = await tools["relay_inbox"].func()
+        assert isinstance(inbox_result, str)
+    finally:
+        await asyncio.gather(relay.close(), peer_relay.close())

package/packages/sdk-py/tests/communicate/adapters/e2e_test_google_adk.py

@@ -0,0 +1,182 @@
+"""E2E test: Google ADK Python adapter against live Relaycast.
+
+Single consolidated test to stay within the 60 req/min rate limit.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+import time
+import uuid
+from types import ModuleType
+from unittest.mock import MagicMock
+
+import pytest
+
+from agent_relay.communicate.core import Relay
+from agent_relay.communicate.types import RelayConfig
+
+
+def _install_google_modules(monkeypatch):
+    """Inject fake google.adk / google.genai modules so the adapter can import."""
+    google_module = ModuleType("google")
+    google_adk_module = ModuleType("google.adk")
+    google_adk_agents_module = ModuleType("google.adk.agents")
+    google_genai_module = ModuleType("google.genai")
+    google_genai_types_module = ModuleType("google.genai.types")
+
+    class Part:
+        def __init__(self, text: str):
+            self.text = text
+
+    class Content:
+        def __init__(self, role: str, parts: list):
+            self.role = role
+            self.parts = parts
+
+    google_module.adk = google_adk_module
+    google_module.genai = google_genai_module
+    google_adk_module.agents = google_adk_agents_module
+    google_genai_module.types = google_genai_types_module
+    google_genai_types_module.Content = Content
+    google_genai_types_module.Part = Part
+
+    monkeypatch.setitem(sys.modules, "google", google_module)
+    monkeypatch.setitem(sys.modules, "google.adk", google_adk_module)
+    monkeypatch.setitem(sys.modules, "google.adk.agents", google_adk_agents_module)
+    monkeypatch.setitem(sys.modules, "google.genai", google_genai_module)
+    monkeypatch.setitem(sys.modules, "google.genai.types", google_genai_types_module)
+
+    return google_genai_types_module
+
+
+def _live_config() -> RelayConfig:
+    return RelayConfig.resolve(
+        workspace=os.environ.get("RELAY_WORKSPACE"),
+        api_key=os.environ.get("RELAY_API_KEY"),
+        base_url=os.environ.get("RELAY_BASE_URL"),
+        channels=[],
+        auto_cleanup=False,
+    )
+
+
+def _unique_name(prefix: str = "e2e-adk-py") -> str:
+    return f"{prefix}-{int(time.time() * 1000)}-{uuid.uuid4().hex[:8]}"
+
+
+def _make_mock_agent(name: str):
+    agent = MagicMock()
+    agent.name = name
+    agent.tools = []
+    agent.before_model_callback = None
+    type(agent).__module__ = "google.adk.agents"
+    return agent
+
+
+def _tool_by_name(agent, name: str):
+    return next(t for t in agent.tools if t.__name__ == name)
+
+
+@pytest.mark.asyncio
+async def test_google_adk_e2e_full_round_trip(monkeypatch):
+    """Full round-trip: real Relay, mock ADK Agent, live Relaycast API.
+
+    Exercises on_relay tool injection, list_agents, post, send/inbox,
+    before_model_callback, and cleanup -- all in one test to stay
+    within rate limits.
+    """
+    types_mod = _install_google_modules(monkeypatch)
+    from agent_relay.communicate.adapters.google_adk import on_relay
+
+    sender_name = _unique_name("adk-sender")
+    receiver_name = _unique_name("adk-recv")
+    config = _live_config()
+
+    sender_relay = Relay(sender_name, config)
+    receiver_relay = Relay(receiver_name, config)
+    sender_agent = _make_mock_agent(sender_name)
+    receiver_agent = _make_mock_agent(receiver_name)
+
+    try:
+        # -- Step 1: on_relay injects 4 tools + before_model_callback --
+        wrapped_s = on_relay(sender_agent, sender_relay)
+        wrapped_r = on_relay(receiver_agent, receiver_relay)
+
+        assert wrapped_s is sender_agent
+        assert wrapped_r is receiver_agent
+
+        expected_tools = {"relay_send", "relay_inbox", "relay_post", "relay_agents"}
+        assert set(t.__name__ for t in sender_agent.tools) == expected_tools
+        assert set(t.__name__ for t in receiver_agent.tools) == expected_tools
+        assert receiver_agent.before_model_callback is not None
+
+        # -- Step 2: list_agents via tool closure (live API) --
+        # Ensure both agents are registered before any cross-agent calls
+        agents_result = await _tool_by_name(sender_agent, "relay_agents")()
+        assert isinstance(agents_result, str)
+        assert sender_name in agents_result
+
+        receiver_agents = await _tool_by_name(receiver_agent, "relay_agents")()
+        assert receiver_name in receiver_agents
+
+        # -- Step 3: post to general channel via tool closure --
+        await sender_relay.join("general")
+        post_result = await _tool_by_name(sender_agent, "relay_post")(
+            "general", f"adk-e2e-{uuid.uuid4().hex[:8]}"
+        )
+        assert post_result == "Message posted"
+
+        # -- Step 4: send DM and verify inbox round-trip --
+        dm_text = f"adk-dm-{uuid.uuid4().hex[:8]}"
+        send_fn = _tool_by_name(sender_agent, "relay_send")
+        result = await send_fn(receiver_name, dm_text)
+        assert result == "Message sent"
+
+        inbox_fn = _tool_by_name(receiver_agent, "relay_inbox")
+        deadline = asyncio.get_event_loop().time() + 15.0
+        found = False
+        while asyncio.get_event_loop().time() < deadline:
+            inbox_result = await inbox_fn()
+            if dm_text in inbox_result:
+                found = True
+                break
+            await asyncio.sleep(0.5)
+        assert found, f"DM containing '{dm_text}' not received within timeout"
+
+        # -- Step 5: before_model_callback injects relay messages --
+        cb_text = f"adk-cb-{uuid.uuid4().hex[:8]}"
+        await sender_relay.send(receiver_name, cb_text)
+
+        deadline = asyncio.get_event_loop().time() + 15.0
+        while asyncio.get_event_loop().time() < deadline:
+            msgs = await receiver_relay.peek()
+            if any(cb_text in m.text for m in msgs):
+                break
+            await asyncio.sleep(0.5)
+
+        llm_request = MagicMock()
+        llm_request.contents = []
+        cb_result = await receiver_agent.before_model_callback(llm_request)
+        assert cb_result is None
+
+        injected = [p.text for c in llm_request.contents for p in c.parts]
+        assert any(cb_text in t for t in injected), (
+            f"Expected '{cb_text}' in callback-injected contents, got: {injected}"
+        )
+
+        # -- Step 6: cleanup -- close sender, verify internal state reset --
+        await sender_relay.close()
+        assert not sender_relay._connected
+        assert not sender_relay._ws_connected
+
+    finally:
+        try:
+            await sender_relay.close()
+        except Exception:
+            pass
+        try:
+            await receiver_relay.close()
+        except Exception:
+            pass

package/packages/sdk-py/tests/communicate/adapters/e2e_test_langgraph.py

@@ -0,0 +1,262 @@
+"""E2E test: LangGraph-style tool wrapping with core Relay against live Relaycast.
+
+There is no dedicated LangGraph Python adapter — this test demonstrates using
+the core Relay class with LangGraph-compatible tool functions (plain async
+callables that can be wrapped with @tool or used directly in a ToolNode).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import time
+import uuid
+
+import pytest
+
+from agent_relay.communicate.core import Relay
+from agent_relay.communicate.types import RelayConfig
+
+pytestmark = pytest.mark.asyncio
+
+RATE_LIMIT_PAUSE = 5  # seconds between tests to avoid 429
+
+
+@pytest.fixture(autouse=True)
+async def _rate_limit_pause():
+    """Pause between tests to respect the 60 req/min rate limit."""
+    yield
+    await asyncio.sleep(RATE_LIMIT_PAUSE)
+
+
+def _e2e_config() -> RelayConfig:
+    config = RelayConfig.resolve(
+        workspace=os.environ.get("RELAY_WORKSPACE"),
+        api_key=os.environ.get("RELAY_API_KEY"),
+        base_url=os.environ.get("RELAY_BASE_URL"),
+        channels=[],
+        auto_cleanup=False,
+    )
+    if not config.workspace or not config.api_key:
+        pytest.fail("RELAY_WORKSPACE and RELAY_API_KEY must be set.")
+    return config
+
+
+def _unique_name(prefix: str = "e2e-langgraph") -> str:
+    ts = int(time.time() * 1000)
+    return f"{prefix}-{ts}-{uuid.uuid4().hex[:6]}"
+
+
+# ---------------------------------------------------------------------------
+# LangGraph-style tool factories
+# These mirror what a real LangGraph ToolNode would use.
+# ---------------------------------------------------------------------------
+
+def make_relay_tools(relay: Relay) -> dict[str, object]:
+    """Create LangGraph-compatible async tool functions backed by a Relay instance."""
+
+    async def relay_send(to: str, message: str) -> str:
+        """Send a DM to another agent."""
+        await relay.send(to, message)
+        return "Message sent"
+
+    async def relay_inbox() -> str:
+        """Check the inbox for new messages."""
+        messages = await relay.inbox()
+        if not messages:
+            return "No new messages"
+        return "\n".join(f"[{m.sender}] {m.text}" for m in messages)
+
+    async def relay_agents() -> str:
+        """List all connected agents."""
+        agents = await relay.agents()
+        return ", ".join(agents) if agents else "No agents online"
+
+    async def relay_post(channel: str, message: str) -> str:
+        """Post a message to a channel."""
+        await relay.post(channel, message)
+        return "Message posted"
+
+    return {
+        "relay_send": relay_send,
+        "relay_inbox": relay_inbox,
+        "relay_agents": relay_agents,
+        "relay_post": relay_post,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Tests
+# ---------------------------------------------------------------------------
+
+async def test_langgraph_tool_creation():
+    """make_relay_tools() should return four async callables."""
+    config = _e2e_config()
+    agent_name = _unique_name("lg-tools")
+
+    relay = Relay(agent_name, config)
+    try:
+        tools = make_relay_tools(relay)
+        expected = {"relay_send", "relay_inbox", "relay_agents", "relay_post"}
+        assert set(tools.keys()) == expected
+        for fn in tools.values():
+            assert asyncio.iscoroutinefunction(fn)
+    finally:
+        await relay.close()
+
+
+async def test_langgraph_relay_agents_live():
+    """relay_agents tool should list agents from the live workspace."""
+    config = _e2e_config()
+    agent_name = _unique_name("lg-list")
+
+    relay = Relay(agent_name, config)
+    try:
+        tools = make_relay_tools(relay)
+        result = await tools["relay_agents"]()
+        assert isinstance(result, str)
+        assert agent_name in result, f"Expected {agent_name} in agents list, got: {result}"
+    finally:
+        await relay.close()
+
+
+async def test_langgraph_relay_send_dm():
+    """relay_send tool should successfully send a DM via live API."""
+    config = _e2e_config()
+    sender_name = _unique_name("lg-sender")
+    receiver_name = _unique_name("lg-recv")
+
+    sender_relay = Relay(sender_name, config)
+    receiver_relay = Relay(receiver_name, config)
+    try:
+        await receiver_relay._ensure_connected()
+
+        tools = make_relay_tools(sender_relay)
+        result = await tools["relay_send"](receiver_name, f"hello-{uuid.uuid4().hex[:8]}")
+        assert result == "Message sent"
+    finally:
+        await asyncio.gather(sender_relay.close(), receiver_relay.close())
+
+
+async def test_langgraph_relay_post_channel():
+    """relay_post tool should successfully post to a channel via live API."""
+    config = _e2e_config()
+    agent_name = _unique_name("lg-post")
+
+    relay = Relay(agent_name, config)
+    try:
+        await relay.join("general")
+
+        tools = make_relay_tools(relay)
+        msg_text = f"e2e-lg-post-{uuid.uuid4().hex[:8]}"
+        result = await tools["relay_post"]("general", msg_text)
+        assert result == "Message posted"
+    finally:
+        await relay.close()
+
+
+async def test_langgraph_inbox_round_trip():
+    """Send a DM and verify it appears in the receiver's inbox."""
+    config = _e2e_config()
+    sender_name = _unique_name("lg-inbox-s")
+    receiver_name = _unique_name("lg-inbox-r")
+
+    sender_relay = Relay(sender_name, config)
+    receiver_relay = Relay(receiver_name, config)
+    try:
+        sender_tools = make_relay_tools(sender_relay)
+        receiver_tools = make_relay_tools(receiver_relay)
+
+        dm_text = f"lg-dm-{uuid.uuid4().hex[:8]}"
+        await sender_tools["relay_send"](receiver_name, dm_text)
+
+        deadline = asyncio.get_event_loop().time() + 15.0
+        found = False
+        while asyncio.get_event_loop().time() < deadline:
+            inbox_result = await receiver_tools["relay_inbox"]()
+            if dm_text in inbox_result:
+                found = True
+                break
+            await asyncio.sleep(0.5)
+        assert found, f"DM containing '{dm_text}' not received within timeout"
+    finally:
+        await asyncio.gather(sender_relay.close(), receiver_relay.close())
+
+
+async def test_langgraph_full_round_trip():
+    """Full round-trip: register, list agents, send DM, post to channel, inbox, close."""
+    config = _e2e_config()
+    agent_name = _unique_name("lg-full")
+    peer_name = _unique_name("lg-peer")
+
+    relay = Relay(agent_name, config)
+    peer_relay = Relay(peer_name, config)
+
+    try:
+        tools = make_relay_tools(relay)
+        peer_tools = make_relay_tools(peer_relay)
+
+        # Ensure peer is connected
+        await peer_relay._ensure_connected()
+
+        # 1. list_agents — both should appear
+        agents_result = await tools["relay_agents"]()
+        assert agent_name in agents_result
+        assert peer_name in agents_result
+
+        # 2. send DM
+        dm_text = f"lg-roundtrip-{uuid.uuid4().hex[:8]}"
+        send_result = await tools["relay_send"](peer_name, dm_text)
+        assert send_result == "Message sent"
+
+        # 3. post to channel
+        await relay.join("general")
+        post_text = f"lg-channel-{uuid.uuid4().hex[:8]}"
+        post_result = await tools["relay_post"]("general", post_text)
+        assert post_result == "Message posted"
+
+        # 4. inbox on peer — verify DM arrived
+        deadline = asyncio.get_event_loop().time() + 15.0
+        found = False
+        while asyncio.get_event_loop().time() < deadline:
+            inbox_result = await peer_tools["relay_inbox"]()
+            if dm_text in inbox_result:
+                found = True
+                break
+            await asyncio.sleep(0.5)
+        assert found, f"DM containing '{dm_text}' not received within timeout"
+
+    finally:
+        await asyncio.gather(relay.close(), peer_relay.close())
+
+
+@pytest.mark.xfail(reason="Server TTL behavior — agent may linger after disconnect")
+async def test_langgraph_disconnect_removes_agent():
+    """After close(), the agent should no longer appear in the agents list."""
+    config = _e2e_config()
+    agent_name = _unique_name("lg-disc")
+    observer_name = _unique_name("lg-obs")
+
+    relay = Relay(agent_name, config)
+    observer_relay = Relay(observer_name, config)
+    try:
+        await relay._ensure_connected()
+        observer_tools = make_relay_tools(observer_relay)
+
+        # Verify agent is listed
+        agents_before = await observer_tools["relay_agents"]()
+        assert agent_name in agents_before
+
+        # Disconnect
+        await relay.close()
+        await asyncio.sleep(2)
+
+        # Agent should be gone (xfail: server TTL may keep it)
+        agents_after = await observer_tools["relay_agents"]()
+        assert agent_name not in agents_after
+    finally:
+        try:
+            await relay.close()
+        except Exception:
+            pass
+        await observer_relay.close()