agent-relay 3.2.2 → 3.2.4

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

@@ -0,0 +1,147 @@
+"""Tests for the Claude Agent SDK Python adapter."""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+# Mock claude_agent_sdk module before it's imported in the adapter
+claude_mock = MagicMock()
+sys.modules["claude_agent_sdk"] = claude_mock
+sys.modules["claude_agent_sdk.types"] = claude_mock.types
+
+class MockHookResult:
+    def __init__(self, system_message=None, should_continue=False):
+        self.system_message = system_message
+        self.should_continue = should_continue
+
+claude_mock.types.HookResult = MockHookResult
+
+def _adapter_module():
+    import importlib
+    # Ensure module is reloaded to pick up mocks if needed
+    if "agent_relay.communicate.adapters.claude_sdk" in sys.modules:
+        importlib.reload(sys.modules["agent_relay.communicate.adapters.claude_sdk"])
+    return importlib.import_module("agent_relay.communicate.adapters.claude_sdk")
+
+@pytest.fixture
+def mock_relay():
+    relay = MagicMock()
+    relay.agent_name = "TestAgent"
+    relay.inbox = AsyncMock(return_value=[])
+    return relay
+
+@pytest.fixture
+def mock_options():
+    # Mocking ClaudeAgentOptions structure
+    class MockOptions:
+        def __init__(self):
+            self.mcp_servers = []
+            self.hooks = MagicMock(spec=["post_tool_use", "stop"])
+            self.hooks.post_tool_use = None
+            self.hooks.stop = None
+    return MockOptions()
+
+def test_on_relay_injects_mcp_server(mock_relay, mock_options):
+    adapter = _adapter_module()
+
+    result = adapter.on_relay("TestAgent", mock_options, relay=mock_relay)
+
+    assert result is mock_options
+    assert len(mock_options.mcp_servers) == 1
+    server = mock_options.mcp_servers[0]
+    assert server["name"] == "relaycast"
+    # It should probably have some command/args for the relaycast MCP server
+    assert "command" in server
+
+@pytest.mark.asyncio
+async def test_post_tool_use_hook_drains_inbox(mock_relay, mock_options):
+    adapter = _adapter_module()
+    from agent_relay.communicate.types import Message
+
+    mock_relay.inbox.return_value = [
+        Message(sender="Other", text="Hello", message_id="1")
+    ]
+
+    adapter.on_relay("TestAgent", mock_options, relay=mock_relay)
+    post_tool_use = mock_options.hooks.post_tool_use
+
+    assert post_tool_use is not None
+
+    # Call the hook
+    hook_result = await post_tool_use()
+
+    assert mock_relay.inbox.called
+    assert hook_result is not None
+    assert "Relay message from Other" in hook_result.system_message
+    assert "Hello" in hook_result.system_message
+
+@pytest.mark.asyncio
+async def test_post_tool_use_hook_returns_none_if_inbox_empty(mock_relay, mock_options):
+    adapter = _adapter_module()
+    mock_relay.inbox.return_value = []
+
+    adapter.on_relay("TestAgent", mock_options, relay=mock_relay)
+    hook_result = await mock_options.hooks.post_tool_use()
+
+    assert hook_result is None
+
+@pytest.mark.asyncio
+async def test_stop_hook_drains_inbox_and_continues(mock_relay, mock_options):
+    adapter = _adapter_module()
+    from agent_relay.communicate.types import Message
+
+    mock_relay.inbox.return_value = [
+        Message(sender="Other", text="Wait!", message_id="2")
+    ]
+
+    adapter.on_relay("TestAgent", mock_options, relay=mock_relay)
+    stop_hook = mock_options.hooks.stop
+
+    assert stop_hook is not None
+
+    hook_result = await stop_hook()
+
+    assert hook_result is not None
+    assert "Relay message from Other" in hook_result.system_message
+    assert hook_result.should_continue is True
+
+@pytest.mark.asyncio
+async def test_stop_hook_returns_none_if_inbox_empty(mock_relay, mock_options):
+    adapter = _adapter_module()
+    mock_relay.inbox.return_value = []
+
+    adapter.on_relay("TestAgent", mock_options, relay=mock_relay)
+    hook_result = await mock_options.hooks.stop()
+
+    assert hook_result is None
+
+@pytest.mark.asyncio
+async def test_hooks_chaining(mock_relay, mock_options):
+    adapter = _adapter_module()
+
+    original_post_tool_use = AsyncMock(return_value=MagicMock(system_message="Original"))
+    mock_options.hooks.post_tool_use = original_post_tool_use
+
+    adapter.on_relay("TestAgent", mock_options, relay=mock_relay)
+
+    # When inbox is empty, it should return original result
+    mock_relay.inbox.return_value = []
+    hook_result = await mock_options.hooks.post_tool_use()
+    assert original_post_tool_use.called
+    assert hook_result.system_message == "Original"
+
+    # When inbox has messages, it should combine?
+    # Or as per requirement: "returns systemMessage if non-empty, None if empty"
+    # Wait, if it's chained, it should probably combine them.
+    # The requirement says: "Chaining with existing hooks (existing PostToolUse/Stop preserved)"
+
+    from agent_relay.communicate.types import Message
+    mock_relay.inbox.return_value = [Message(sender="A", text="B")]
+
+    hook_result = await mock_options.hooks.post_tool_use()
+    assert "Original" in hook_result.system_message
+    assert "Relay message from A" in hook_result.system_message

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

@@ -0,0 +1,136 @@
+"""Tests for the CrewAI Python adapter."""
+
+from __future__ import annotations
+
+from inspect import isawaitable
+from types import ModuleType
+import sys
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+def _adapter_module():
+    import importlib
+    if "agent_relay.communicate.adapters.crewai" in sys.modules:
+        importlib.reload(sys.modules["agent_relay.communicate.adapters.crewai"])
+    return importlib.import_module("agent_relay.communicate.adapters.crewai")
+
+
+def _install_crewai_tools(monkeypatch):
+    crewai_module = ModuleType("crewai")
+    crewai_tools_module = ModuleType("crewai.tools")
+
+    def mock_tool_decorator(func):
+        tool = MagicMock()
+        tool.__name__ = func.__name__
+        tool.func = func
+        return tool
+
+    crewai_tools_module.tool = mock_tool_decorator
+    crewai_module.tools = crewai_tools_module
+    monkeypatch.setitem(sys.modules, "crewai", crewai_module)
+    monkeypatch.setitem(sys.modules, "crewai.tools", crewai_tools_module)
+    return crewai_tools_module
+
+@pytest.fixture
+def mock_relay():
+    relay = MagicMock()
+    relay.agent_name = "TestAgent"
+    relay.inbox = AsyncMock(return_value=[])
+    relay.inbox_sync = MagicMock(return_value=[])
+    relay.send = AsyncMock()
+    relay.post = AsyncMock()
+    relay.agents = AsyncMock(return_value=[])
+    return relay
+
+@pytest.fixture
+def mock_agent():
+    agent = MagicMock()
+    agent.tools = []
+    agent.backstory = "Expert researcher."
+    agent.goal = "Find answers."
+    return agent
+
+def test_on_relay_adds_tools(monkeypatch, mock_relay, mock_agent):
+    _install_crewai_tools(monkeypatch)
+    adapter = _adapter_module()
+
+    adapter.on_relay(mock_agent, mock_relay)
+
+    tools = {t.__name__: t for t in mock_agent.tools}
+    assert "relay_send" in tools
+    assert "relay_inbox" in tools
+
+@pytest.mark.asyncio
+async def test_tool_execution(monkeypatch, mock_relay, mock_agent):
+    _install_crewai_tools(monkeypatch)
+    adapter = _adapter_module()
+
+    adapter.on_relay(mock_agent, mock_relay)
+    tools = {t.__name__: t for t in mock_agent.tools}
+
+    # Test relay_send
+    mock_relay.send = AsyncMock()
+    await tools["relay_send"].func("Alice", "Hi")
+    mock_relay.send.assert_called_with("Alice", "Hi")
+
+    # Test relay_inbox
+    from agent_relay.communicate.types import Message
+    mock_relay.inbox.return_value = [Message(sender="Bob", text="Hey")]
+    inbox_res = await tools["relay_inbox"].func()
+    assert "Bob: Hey" in inbox_res
+
+    # Test relay_post
+    mock_relay.post = AsyncMock()
+    await tools["relay_post"].func("general", "Update")
+    mock_relay.post.assert_called_with("general", "Update")
+
+    # Test relay_agents
+    mock_relay.agents.return_value = ["Alice", "Bob"]
+    agents_res = await tools["relay_agents"].func()
+    assert "Alice, Bob" in agents_res
+
+@pytest.mark.asyncio
+async def test_backstory_wrapping(monkeypatch, mock_relay, mock_agent):
+    _install_crewai_tools(monkeypatch)
+    adapter = _adapter_module()
+    from agent_relay.communicate.types import Message
+
+    msg = Message(sender="Other", text="Crew message", message_id="1")
+    mock_relay.inbox.return_value = [msg]
+    mock_relay.inbox_sync.return_value = [msg]
+
+    adapter.on_relay(mock_agent, mock_relay)
+
+    backstory = mock_agent.backstory
+    if isawaitable(backstory):
+        backstory = await backstory
+    elif callable(backstory):
+        backstory = backstory()
+
+    assert "Expert researcher." in backstory
+    assert "Other: Crew message" in backstory
+
+@pytest.mark.asyncio
+async def test_backstory_wrapping_no_messages(monkeypatch, mock_relay, mock_agent):
+    """When inbox is empty, backstory is just the original."""
+    _install_crewai_tools(monkeypatch)
+    adapter = _adapter_module()
+
+    mock_relay.inbox_sync.return_value = []
+    adapter.on_relay(mock_agent, mock_relay)
+
+    backstory = mock_agent.backstory
+    if isawaitable(backstory):
+        backstory = await backstory
+    elif callable(backstory):
+        backstory = backstory()
+    assert backstory == "Expert researcher."
+
+def test_on_relay_returns_agent(monkeypatch, mock_relay, mock_agent):
+    """on_relay() returns the modified agent."""
+    _install_crewai_tools(monkeypatch)
+    adapter = _adapter_module()
+
+    result = adapter.on_relay(mock_agent, mock_relay)
+    assert result is mock_agent

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

@@ -0,0 +1,125 @@
+"""Tests for the Google ADK Python adapter."""
+
+from __future__ import annotations
+
+from types import ModuleType
+import sys
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+def _adapter_module():
+    import importlib
+    if "agent_relay.communicate.adapters.google_adk" in sys.modules:
+        importlib.reload(sys.modules["agent_relay.communicate.adapters.google_adk"])
+    return importlib.import_module("agent_relay.communicate.adapters.google_adk")
+
+
+def _install_google_modules(monkeypatch):
+    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
+
+        def __repr__(self) -> str:
+            return f"Part(text={self.text!r})"
+
+    class Content:
+        def __init__(self, role: str, parts: list[Part]):
+            self.role = role
+            self.parts = parts
+
+        def __repr__(self) -> str:
+            return f"Content(role={self.role!r}, parts={self.parts!r})"
+
+    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)
+
+@pytest.fixture
+def mock_relay():
+    relay = MagicMock()
+    relay.agent_name = "TestAgent"
+    relay.inbox = AsyncMock(return_value=[])
+    relay.send = AsyncMock()
+    relay.post = AsyncMock()
+    relay.agents = AsyncMock()
+    return relay
+
+@pytest.fixture
+def mock_agent():
+    agent = MagicMock()
+    agent.tools = []
+    agent.before_model_callback = None
+    return agent
+
+def test_on_relay_adds_tools(monkeypatch, mock_relay, mock_agent):
+    _install_google_modules(monkeypatch)
+    adapter = _adapter_module()
+
+    adapter.on_relay(mock_agent, mock_relay)
+
+    tool_names = [t.__name__ for t in mock_agent.tools]
+    assert "relay_send" in tool_names
+    assert "relay_inbox" in tool_names
+    assert "relay_post" in tool_names
+    assert "relay_agents" in tool_names
+
+@pytest.mark.asyncio
+async def test_before_model_callback_drains_inbox(monkeypatch, mock_relay, mock_agent):
+    _install_google_modules(monkeypatch)
+    adapter = _adapter_module()
+    from agent_relay.communicate.types import Message
+
+    mock_relay.inbox.return_value = [
+        Message(sender="Other", text="Hello", message_id="1")
+    ]
+
+    adapter.on_relay(mock_agent, mock_relay)
+    callback = mock_agent.before_model_callback
+
+    assert callback is not None
+
+    # Mock LLM request object
+    llm_request = MagicMock()
+    llm_request.contents = []
+
+    # Call the callback
+    await callback(llm_request)
+
+    assert mock_relay.inbox.called
+    assert len(llm_request.contents) == 1
+    content = llm_request.contents[0]
+    assert content.role == "user"
+    assert content.parts[0].text == "[Relay] Other: Hello"
+
+@pytest.mark.asyncio
+async def test_before_model_callback_chains_existing(monkeypatch, mock_relay, mock_agent):
+    _install_google_modules(monkeypatch)
+    adapter = _adapter_module()
+
+    original_callback = AsyncMock()
+    mock_agent.before_model_callback = original_callback
+
+    adapter.on_relay(mock_agent, mock_relay)
+
+    llm_request = MagicMock()
+    llm_request.contents = []
+
+    await mock_agent.before_model_callback(llm_request)
+
+    assert original_callback.called

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

@@ -0,0 +1,99 @@
+"""Tests for the OpenAI Agents Python adapter."""
+
+from __future__ import annotations
+
+from types import ModuleType
+import sys
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+def _adapter_module():
+    import importlib
+    if "agent_relay.communicate.adapters.openai_agents" in sys.modules:
+        importlib.reload(sys.modules["agent_relay.communicate.adapters.openai_agents"])
+    return importlib.import_module("agent_relay.communicate.adapters.openai_agents")
+
+
+def _install_agents_module(monkeypatch):
+    agents_module = ModuleType("agents")
+    agents_module.Agent = type("Agent", (), {})
+    agents_module.function_tool = MagicMock(side_effect=lambda func: func)
+    monkeypatch.setitem(sys.modules, "agents", agents_module)
+    return agents_module
+
+@pytest.fixture
+def mock_relay():
+    relay = MagicMock()
+    relay.agent_name = "TestAgent"
+    relay.inbox = AsyncMock(return_value=[])
+    relay.peek = AsyncMock(return_value=[])
+    return relay
+
+@pytest.fixture
+def mock_agent():
+    agent = MagicMock()
+    agent.tools = []
+    agent.instructions = "Be helpful."
+    return agent
+
+def test_on_relay_adds_tools(monkeypatch, mock_relay, mock_agent):
+    agents_module = _install_agents_module(monkeypatch)
+    adapter = _adapter_module()
+
+    adapter.on_relay(mock_agent, mock_relay)
+
+    assert agents_module.function_tool.call_count == 4
+    called_args = [call.args[0].__name__ for call in agents_module.function_tool.call_args_list]
+    assert "relay_send" in called_args
+
+@pytest.mark.asyncio
+async def test_instructions_wrapping_string(monkeypatch, mock_relay, mock_agent):
+    _install_agents_module(monkeypatch)
+    adapter = _adapter_module()
+    from agent_relay.communicate.types import Message
+
+    mock_relay.peek.return_value = [
+        Message(sender="Other", text="Hello", message_id="1")
+    ]
+
+    adapter.on_relay(mock_agent, mock_relay)
+
+    assert callable(mock_agent.instructions)
+
+    result = await mock_agent.instructions()
+    assert "Be helpful." in result
+    assert "Other: Hello" in result
+
+@pytest.mark.asyncio
+async def test_instructions_wrapping_callable(monkeypatch, mock_relay, mock_agent):
+    _install_agents_module(monkeypatch)
+    adapter = _adapter_module()
+
+    original_instructions = MagicMock(return_value="Original context.")
+    mock_agent.instructions = original_instructions
+
+    adapter.on_relay(mock_agent, mock_relay)
+
+    result = await mock_agent.instructions()
+    assert "Original context." in result
+    assert original_instructions.called
+
+
+@pytest.mark.asyncio
+async def test_instructions_wrapping_async_callable(monkeypatch, mock_relay, mock_agent):
+    _install_agents_module(monkeypatch)
+    adapter = _adapter_module()
+    from agent_relay.communicate.types import Message
+
+    async def original_instructions():
+        return "Async context."
+
+    mock_agent.instructions = original_instructions
+    mock_relay.peek.return_value = [Message(sender="Other", text="Hello", message_id="1")]
+
+    adapter.on_relay(mock_agent, mock_relay)
+
+    result = await mock_agent.instructions()
+    assert result.startswith("\n\nNew messages from other agents:\n  Other: Hello\n")
+    assert result.endswith("\n\nAsync context.")