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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.26.7.dev3
+Version: 0.26.7.dev4
 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.dev4}/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.dev4'
+__version_tuple__ = version_tuple = (0, 26, 7, 'dev4')
 
 __commit_id__ = commit_id = None

{ouroboros_ai-0.26.7.dev3 → ouroboros_ai-0.26.7.dev4}/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.dev4/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