ouroboros-ai 0.26.7.dev3__tar.gz → 0.26.7.dev5__tar.gz

{ouroboros_ai-0.26.7.dev3 → ouroboros_ai-0.26.7.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.26.7.dev3
+Version: 0.26.7.dev5
 Summary: Specification-first workflow engine for AI coding agents. Works with Claude Code and Codex CLI.
 Author-email: Q00 <jqyu.lee@gmail.com>
 License-File: LICENSE

{ouroboros_ai-0.26.7.dev3 → ouroboros_ai-0.26.7.dev5}/src/ouroboros/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.26.7.dev3'
-__version_tuple__ = version_tuple = (0, 26, 7, 'dev3')
+__version__ = version = '0.26.7.dev5'
+__version_tuple__ = version_tuple = (0, 26, 7, 'dev5')
 
 __commit_id__ = commit_id = None

{ouroboros_ai-0.26.7.dev3 → ouroboros_ai-0.26.7.dev5}/src/ouroboros/mcp/client/adapter.py

@@ -289,26 +289,21 @@ class MCPClientAdapter:
     async def disconnect(self) -> Result[None, MCPClientError]:
         """Disconnect from the current MCP server.
 
+        Releases both the MCP session and the underlying transport context
+        manager in reverse acquisition order.  Always attempts to close both
+        resources even when one teardown raises.
+
         Returns:
             Result containing None on success or MCPClientError on failure.
         """
         if self._session is None and self._transport_cm is None:
             return Result.ok(None)
 
-        session = self._session
-        transport_cm = self._transport_cm
-        self._session = None
-        self._transport_cm = None
-        self._read_stream = None
-        self._write_stream = None
-        self._server_info = None
+        server_name = self._config.name if self._config else "unknown"
 
         try:
-            if session is not None:
-                await session.__aexit__(None, None, None)
-            if transport_cm is not None:
-                await transport_cm.__aexit__(None, None, None)
-            log.info("mcp.disconnected", server=self._config.name if self._config else "unknown")
+            await self._reset_connection_state()
+            log.info("mcp.disconnected", server=server_name)
             return Result.ok(None)
         except Exception as e:
             return Result.err(

{ouroboros_ai-0.26.7.dev3 → ouroboros_ai-0.26.7.dev5}/src/ouroboros/mcp/server/adapter.py

@@ -569,6 +569,7 @@ def create_ouroboros_server(
     state_dir: Any | None = None,
     runtime_backend: str | None = None,
     llm_backend: str | None = None,
+    mcp_bridge: Any | None = None,
 ) -> MCPServerAdapter:
     """Create an Ouroboros MCP server with all tools and dependencies wired.
 
@@ -1239,6 +1240,15 @@ def create_ouroboros_server(
     # The server owns the shared event store lifecycle
     server.register_owned_resource(event_store)
 
+    # Inject bridge into all BridgeAwareMixin handlers (loop-based auto-discovery)
+    if mcp_bridge is not None:
+        from ouroboros.mcp.tools.bridge_mixin import inject_bridge
+
+        injected = [type(h).__name__ for h in tool_handlers if inject_bridge(h, mcp_bridge)]
+        if injected:
+            log.info("mcp.bridge.injected", handlers=injected)
+        server.register_owned_resource(mcp_bridge)
+
     # Register all tools with the server
     for handler in tool_handlers:
         server.register_tool(handler)

ouroboros_ai-0.26.7.dev5/src/ouroboros/mcp/tools/bridge_mixin.py

@@ -0,0 +1,52 @@
+"""BridgeAwareMixin for MCP tool handlers that need external MCP access.
+
+Handlers that inherit from this mixin will automatically receive
+an MCPClientManager reference when an MCPBridge is configured,
+via loop-based injection in the composition root.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class BridgeAwareMixin:
+    """Mixin for handlers that need access to external MCP servers.
+
+    Provides ``mcp_manager`` and ``mcp_tool_prefix`` fields that are
+    injected by the composition root when an MCPBridge is configured.
+    Both fields default to None/"" so handlers work without a bridge.
+
+    Usage::
+
+        @dataclass
+        class MyHandler(BridgeAwareMixin):
+            other_field: str = ""
+
+            async def handle(self, arguments):
+                if self.mcp_manager:
+                    tools = await self.mcp_manager.list_all_tools()
+    """
+
+    mcp_manager: Any | None = field(default=None, repr=False)
+    mcp_tool_prefix: str = ""
+
+
+def inject_bridge(handler: object, bridge: object | None) -> bool:
+    """Inject bridge manager into a BridgeAwareMixin handler.
+
+    Args:
+        handler: A tool handler, possibly BridgeAwareMixin.
+        bridge: An MCPBridge instance (must have .manager and .tool_prefix).
+
+    Returns:
+        True if injection was performed, False otherwise.
+    """
+    if bridge is None or not isinstance(handler, BridgeAwareMixin):
+        return False
+
+    handler.mcp_manager = getattr(bridge, "manager", None)
+    handler.mcp_tool_prefix = getattr(bridge, "tool_prefix", "")
+    return True

{ouroboros_ai-0.26.7.dev3 → ouroboros_ai-0.26.7.dev5}/src/ouroboros/mcp/tools/execution_handlers.py

@@ -32,6 +32,7 @@ from ouroboros.core.worktree import (
 from ouroboros.evaluation.verification_artifacts import build_verification_artifacts
 from ouroboros.mcp.errors import MCPServerError, MCPToolError
 from ouroboros.mcp.job_manager import JobLinks, JobManager
+from ouroboros.mcp.tools.bridge_mixin import BridgeAwareMixin
 from ouroboros.mcp.types import (
     ContentType,
     MCPContentItem,
@@ -97,7 +98,7 @@ def _extract_inherited_effective_tools(arguments: dict[str, Any]) -> list[str] |
 
 
 @dataclass
-class ExecuteSeedHandler:
+class ExecuteSeedHandler(BridgeAwareMixin):
     """Handler for the execute_seed tool.
 
     Executes a seed (task specification) in the Ouroboros system.
@@ -394,6 +395,8 @@ class ExecuteSeedHandler:
                     adapter=agent_adapter,
                     event_store=event_store,
                     console=console,
+                    mcp_manager=self.mcp_manager,
+                    mcp_tool_prefix=self.mcp_tool_prefix,
                     debug=False,
                     enable_decomposition=True,
                     inherited_runtime_handle=inherited_runtime_handle,

ouroboros_ai-0.26.7.dev5/tests/unit/mcp/client/test_adapter_transport_lifecycle.py

@@ -0,0 +1,225 @@
+"""Tests for STDIO transport context manager lifecycle in MCPClientAdapter.
+
+Covers the edge cases identified in PR #263 review:
+1. Rollback on failed initialization (transport entered but session fails)
+2. disconnect() cleans transport when session is None (partial connect)
+3. disconnect() closes transport even when session.__aexit__ raises
+4. Transport teardown errors are surfaced, not swallowed
+"""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from ouroboros.mcp.client.adapter import MCPClientAdapter
+from ouroboros.mcp.types import MCPServerConfig, TransportType
+
+
+def _make_stdio_config(name: str = "test") -> MCPServerConfig:
+    return MCPServerConfig(
+        name=name,
+        transport=TransportType.STDIO,
+        command="echo",
+        args=("hello",),
+    )
+
+
+def _mock_transport_cm(read=None, write=None):
+    """Create a mock stdio_client context manager."""
+    cm = MagicMock()
+    cm.__aenter__ = AsyncMock(return_value=(read or MagicMock(), write or MagicMock()))
+    cm.__aexit__ = AsyncMock(return_value=None)
+    return cm
+
+
+def _mock_session(*, init_fail=False, exit_fail=False):
+    """Create a mock ClientSession."""
+    session = MagicMock()
+    session.__aenter__ = AsyncMock(return_value=session)
+    if exit_fail:
+        session.__aexit__ = AsyncMock(side_effect=RuntimeError("session exit boom"))
+    else:
+        session.__aexit__ = AsyncMock(return_value=None)
+    if init_fail:
+        session.initialize = AsyncMock(side_effect=ConnectionError("init failed"))
+    else:
+        session.initialize = AsyncMock(
+            return_value=MagicMock(
+                serverInfo=MagicMock(name="test", version="1.0"),
+                protocolVersion="2024-11-05",
+                capabilities=MagicMock(tools=None, resources=None, prompts=None, logging=None),
+            )
+        )
+    return session
+
+
+class TestConnectRollback:
+    """Finding #1: rollback transport on failed session init."""
+
+    @pytest.mark.asyncio
+    async def test_transport_closed_when_session_init_fails(self):
+        """If initialize() fails after transport is entered, transport must be closed."""
+        adapter = MCPClientAdapter(max_retries=1)
+        transport_cm = _mock_transport_cm()
+        session = _mock_session(init_fail=True)
+
+        with (
+            patch("mcp.client.stdio.stdio_client", return_value=transport_cm),
+            patch("mcp.ClientSession", return_value=session),
+        ):
+            result = await adapter.connect(_make_stdio_config())
+
+        assert result.is_err
+        # Transport must have been cleaned up (called once per retry attempt)
+        transport_cm.__aexit__.assert_called_with(None, None, None)
+        assert adapter._transport_cm is None
+        assert adapter._session is None
+
+    @pytest.mark.asyncio
+    async def test_transport_closed_when_session_enter_fails(self):
+        """If session.__aenter__ fails, transport must be closed."""
+        adapter = MCPClientAdapter()
+        transport_cm = _mock_transport_cm()
+        session = MagicMock()
+        session.__aenter__ = AsyncMock(side_effect=RuntimeError("session enter boom"))
+
+        with (
+            patch("mcp.client.stdio.stdio_client", return_value=transport_cm),
+            patch("mcp.ClientSession", return_value=session),
+        ):
+            result = await adapter.connect(_make_stdio_config())
+
+        assert result.is_err
+        transport_cm.__aexit__.assert_called_once()
+        assert adapter._transport_cm is None
+
+
+class TestDisconnectPartialConnect:
+    """Finding #2: disconnect() must clean transport even when session is None."""
+
+    @pytest.mark.asyncio
+    async def test_disconnect_cleans_orphaned_transport(self):
+        """If _session is None but _transport_cm is set, disconnect must close it."""
+        adapter = MCPClientAdapter()
+        adapter._config = _make_stdio_config()
+        adapter._session = None  # No session
+
+        transport_cm = _mock_transport_cm()
+        adapter._transport_cm = transport_cm  # But transport is open
+
+        result = await adapter.disconnect()
+        assert result.is_ok
+        transport_cm.__aexit__.assert_called_once_with(None, None, None)
+        assert adapter._transport_cm is None
+
+    @pytest.mark.asyncio
+    async def test_disconnect_noop_when_both_none(self):
+        """If both session and transport are None, disconnect is a no-op."""
+        adapter = MCPClientAdapter()
+        result = await adapter.disconnect()
+        assert result.is_ok
+
+
+class TestDisconnectSessionFailure:
+    """Finding #3: transport cleanup must run even when session exit raises."""
+
+    @pytest.mark.asyncio
+    async def test_transport_closed_when_session_exit_raises(self):
+        """If session.__aexit__ raises, transport must still be closed."""
+        adapter = MCPClientAdapter()
+        adapter._config = _make_stdio_config()
+
+        session = _mock_session(exit_fail=True)
+        adapter._session = session
+
+        transport_cm = _mock_transport_cm()
+        adapter._transport_cm = transport_cm
+
+        result = await adapter.disconnect()
+        # Should report the error
+        assert result.is_err
+        # But transport must still be cleaned up
+        transport_cm.__aexit__.assert_called_once_with(None, None, None)
+        assert adapter._transport_cm is None
+        assert adapter._session is None
+
+
+class TestDisconnectErrorReporting:
+    """Finding #4: transport teardown errors must be surfaced."""
+
+    @pytest.mark.asyncio
+    async def test_transport_exit_error_is_reported(self):
+        """If transport.__aexit__ raises, the error must be in the Result."""
+        adapter = MCPClientAdapter()
+        adapter._config = _make_stdio_config()
+        adapter._session = None  # Only transport
+
+        transport_cm = MagicMock()
+        transport_cm.__aexit__ = AsyncMock(side_effect=OSError("pipe broken"))
+        adapter._transport_cm = transport_cm
+
+        result = await adapter.disconnect()
+        assert result.is_err
+        assert "pipe broken" in str(result.error)
+        # Transport ref still cleaned up
+        assert adapter._transport_cm is None
+
+    @pytest.mark.asyncio
+    async def test_both_errors_reported_session_first(self):
+        """If both session and transport raise, session error is primary."""
+        adapter = MCPClientAdapter()
+        adapter._config = _make_stdio_config()
+
+        session = _mock_session(exit_fail=True)
+        adapter._session = session
+
+        transport_cm = MagicMock()
+        transport_cm.__aexit__ = AsyncMock(side_effect=OSError("transport boom"))
+        adapter._transport_cm = transport_cm
+
+        result = await adapter.disconnect()
+        assert result.is_err
+        # First error (session) is primary
+        assert "session exit boom" in str(result.error)
+        # Both resources cleaned up
+        assert adapter._session is None
+        assert adapter._transport_cm is None
+
+
+class TestHappyPath:
+    """Verify the fix doesn't break normal connect/disconnect."""
+
+    @pytest.mark.asyncio
+    async def test_normal_connect_stores_transport_cm(self):
+        adapter = MCPClientAdapter()
+        transport_cm = _mock_transport_cm()
+        session = _mock_session()
+
+        with (
+            patch("mcp.client.stdio.stdio_client", return_value=transport_cm),
+            patch("mcp.ClientSession", return_value=session),
+        ):
+            result = await adapter.connect(_make_stdio_config())
+
+        assert result.is_ok
+        assert adapter._transport_cm is transport_cm
+        assert adapter._session is not None
+
+    @pytest.mark.asyncio
+    async def test_normal_disconnect_cleans_both(self):
+        adapter = MCPClientAdapter()
+        adapter._config = _make_stdio_config()
+
+        session = _mock_session()
+        adapter._session = session
+        transport_cm = _mock_transport_cm()
+        adapter._transport_cm = transport_cm
+
+        result = await adapter.disconnect()
+        assert result.is_ok
+        session.__aexit__.assert_called_once()
+        transport_cm.__aexit__.assert_called_once()
+        assert adapter._session is None
+        assert adapter._transport_cm is None

ouroboros_ai-0.26.7.dev5/tests/unit/mcp/tools/test_mcp_manager_wiring.py

@@ -0,0 +1,145 @@
+"""Tests for mcp_manager wiring via BridgeAwareMixin and inject_bridge.
+
+Covers:
+- BridgeAwareMixin fields default to None/""
+- ExecuteSeedHandler inherits BridgeAwareMixin
+- inject_bridge auto-discovers and injects into mixin handlers
+- create_ouroboros_server loop-based bridge injection
+"""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+from ouroboros.mcp.tools.bridge_mixin import BridgeAwareMixin, inject_bridge
+from ouroboros.mcp.tools.definitions import get_ouroboros_tools
+from ouroboros.mcp.tools.execution_handlers import ExecuteSeedHandler
+
+
+class TestBridgeAwareMixin:
+    """Verify the mixin provides correct defaults."""
+
+    def test_handler_is_bridge_aware(self):
+        assert issubclass(ExecuteSeedHandler, BridgeAwareMixin)
+
+    def test_defaults_to_none(self):
+        handler = ExecuteSeedHandler()
+        assert handler.mcp_manager is None
+        assert handler.mcp_tool_prefix == ""
+
+    def test_accepts_mcp_manager_directly(self):
+        mock = MagicMock()
+        handler = ExecuteSeedHandler(mcp_manager=mock, mcp_tool_prefix="pfx_")
+        assert handler.mcp_manager is mock
+        assert handler.mcp_tool_prefix == "pfx_"
+
+
+class TestInjectBridge:
+    """Verify inject_bridge auto-discovery and injection."""
+
+    def test_injects_into_bridge_aware_handler(self):
+        handler = ExecuteSeedHandler()
+        bridge = MagicMock()
+        bridge.manager = MagicMock(name="FakeManager")
+        bridge.tool_prefix = "ext_"
+
+        result = inject_bridge(handler, bridge)
+
+        assert result is True
+        assert handler.mcp_manager is bridge.manager
+        assert handler.mcp_tool_prefix == "ext_"
+
+    def test_skips_non_bridge_aware_handler(self):
+        handler = MagicMock(spec=[])  # No BridgeAwareMixin
+        bridge = MagicMock()
+
+        result = inject_bridge(handler, bridge)
+        assert result is False
+
+    def test_skips_when_bridge_is_none(self):
+        handler = ExecuteSeedHandler()
+        result = inject_bridge(handler, None)
+        assert result is False
+        assert handler.mcp_manager is None
+
+    def test_handles_bridge_without_tool_prefix(self):
+        handler = ExecuteSeedHandler()
+        bridge = MagicMock(spec=["manager"])  # No tool_prefix attr
+        bridge.manager = MagicMock()
+
+        result = inject_bridge(handler, bridge)
+        assert result is True
+        assert handler.mcp_manager is bridge.manager
+        assert handler.mcp_tool_prefix == ""  # getattr fallback
+
+
+class TestGetOuroborosTools:
+    """Verify tools can be created and later injected."""
+
+    def test_default_tools_have_no_manager(self):
+        tools = get_ouroboros_tools()
+        exec_handler = tools[0]
+        assert isinstance(exec_handler, ExecuteSeedHandler)
+        assert exec_handler.mcp_manager is None
+
+    def test_tool_count_unchanged(self):
+        tools = get_ouroboros_tools()
+        assert len(tools) >= 20  # Sanity check
+
+
+class TestCompositionRoot:
+    """Verify create_ouroboros_server loop-based bridge injection."""
+
+    def test_bridge_injected_into_execute_handler(self):
+        from ouroboros.mcp.server.adapter import create_ouroboros_server
+
+        mock_bridge = MagicMock()
+        mock_bridge.manager = MagicMock(name="FakeManager")
+        mock_bridge.tool_prefix = "ext_"
+
+        server = create_ouroboros_server(mcp_bridge=mock_bridge)
+
+        exec_handler = None
+        for handler in server._tool_handlers.values():
+            if isinstance(handler, ExecuteSeedHandler):
+                exec_handler = handler
+                break
+
+        assert exec_handler is not None
+        assert exec_handler.mcp_manager is mock_bridge.manager
+        assert exec_handler.mcp_tool_prefix == "ext_"
+
+    def test_bridge_registered_as_owned_resource(self):
+        from ouroboros.mcp.server.adapter import create_ouroboros_server
+
+        mock_bridge = MagicMock()
+        mock_bridge.manager = MagicMock()
+        mock_bridge.tool_prefix = ""
+
+        server = create_ouroboros_server(mcp_bridge=mock_bridge)
+        assert mock_bridge in server._owned_resources
+
+    def test_no_bridge_leaves_handler_with_none(self):
+        from ouroboros.mcp.server.adapter import create_ouroboros_server
+
+        server = create_ouroboros_server()
+
+        exec_handler = None
+        for handler in server._tool_handlers.values():
+            if isinstance(handler, ExecuteSeedHandler):
+                exec_handler = handler
+                break
+
+        assert exec_handler is not None
+        assert exec_handler.mcp_manager is None
+
+    def test_no_bridge_not_in_owned_resources(self):
+        from ouroboros.mcp.server.adapter import create_ouroboros_server
+
+        server = create_ouroboros_server()
+        bridge_resources = [
+            r
+            for r in server._owned_resources
+            if hasattr(r, "tool_prefix") and hasattr(r, "manager")
+        ]
+        assert len(bridge_resources) == 0