Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
Fix MCP-created sessions for code-only workflows (#SKY-13338) (#8022)
Aaron Perez408932445e66
diff --git a/skyvern/cli/core/session_manager.py b/skyvern/cli/core/session_manager.pyindex f6abc0ac6..213258e66 100644--- a/skyvern/cli/core/session_manager.py+++ b/skyvern/cli/core/session_manager.py@@ -436,6 +436,24 @@ async def resolve_browser(raise RuntimeError("Expected active browser and context for matching session")return current.browser, current.context+ # Cloud sessions created by the MCP session tool intentionally do not open a+ # second CDP connection. Connect lazily when a browser tool is used; this+ # leaves the initial page available to the backend persistent-session manager+ # for code-only workflow runs.+ if (+ current.browser is None+ and current.context is not None+ and current.context.mode == "cloud_session"+ and current.context.session_id+ and session_id is None+ and cdp_url is None+ and not local+ and _hashes_equal(current.api_key_hash, _api_key_hash(get_active_api_key()))+ ):+ connected_browser = await skyvern.connect_to_cloud_browser_session(current.context.session_id)+ current.browser = connected_browser+ return connected_browser, current.context+active_api_key_hash = _api_key_hash(get_active_api_key())# Check copilot session registry (cross-task fallback when ContextVardiff --git a/skyvern/cli/core/session_ops.py b/skyvern/cli/core/session_ops.pyindex c16fb3702..f4b902f04 100644--- a/skyvern/cli/core/session_ops.py+++ b/skyvern/cli/core/session_ops.py@@ -7,7 +7,7 @@ from dataclasses import dataclassfrom typing import Anyfrom skyvern.client.types.extensions import Extensions-from skyvern.schemas.runs import GeoTarget, ProxyLocation, ProxyLocationInput+from skyvern.schemas.runs import GeoTarget, ProxyLocation, ProxyLocationInput, proxy_location_to_request@dataclass@@ -16,6 +16,7 @@ class SessionCreateResult:local: bool = Falseheadless: bool = Falsetimeout_minutes: int | None = None+ app_url: str | None = None@dataclass@@ -67,6 +68,7 @@ async def do_session_create(generate_browser_profile: bool = False,local: bool = False,headless: bool = False,+ connect_browser: bool = True,) -> tuple[Any, SessionCreateResult]:"""Create browser session. Returns (browser, result)."""if local:@@ -78,6 +80,25 @@ async def do_session_create(return browser, SessionCreateResult(session_id=None, local=True, headless=headless)proxy = coerce_proxy_location(proxy_location)+ if not connect_browser:+ create_kwargs: dict[str, Any] = {+ "timeout": timeout,+ "proxy_location": proxy_location_to_request(proxy),+ }+ if extensions is not None:+ create_kwargs["extensions"] = extensions+ if browser_profile_id is not None:+ create_kwargs["browser_profile_id"] = browser_profile_id+ browser_session = await skyvern.create_browser_session(**create_kwargs)+ session_id = browser_session.browser_session_id+ if generate_browser_profile and session_id:+ await do_session_arm_generate_browser_profile(skyvern, session_id)+ return None, SessionCreateResult(+ session_id=session_id,+ timeout_minutes=timeout,+ app_url=browser_session.app_url,+ )+launch_kwargs: dict[str, Any] = {"timeout": timeout, "proxy_location": proxy}if extensions is not None:launch_kwargs["extensions"] = extensionsdiff --git a/skyvern/cli/mcp_tools/session.py b/skyvern/cli/mcp_tools/session.pyindex 004350042..087c3766c 100644--- a/skyvern/cli/mcp_tools/session.py+++ b/skyvern/cli/mcp_tools/session.py@@ -215,6 +215,10 @@ async def skyvern_browser_session_create(generate_browser_profile=generate_browser_profile,local=local,headless=headless,+ # Keep the MCP process from claiming the session's initial page.+ # Code blocks connect through the backend's persistent-session manager,+ # so an MCP-side CDP connection here can leave that manager with zero pages.+ connect_browser=local,)timer.mark("sdk")@@ -228,7 +232,7 @@ async def skyvern_browser_session_create()set_current_session(SessionState(browser=browser, context=ctx, api_key_hash=_session_api_key_hash()))- app_url = browser.app_url+ app_url = result.app_url if browser is None else browser.app_urlexcept ValueError as e:return make_result(@@ -312,6 +316,7 @@ async def skyvern_browser_session_close("""current = get_current_session()await drain_action_log_events()+ closed_id: str | None = Nonewith Timer() as timer:try:@@ -332,10 +337,9 @@ async def skyvern_browser_session_close(except Exception as e:close_error = e- if matching_cloud_session:- if current.browser is None:- set_current_session(SessionState())- raise RuntimeError("Expected active browser for matching cloud session")+ # A cloud session connects its browser lazily, so the matching session may+ # have no local browser to tear down.+ if matching_cloud_session and current.browser is not None:try:await current.browser.close()except Exception as browser_err:@@ -360,6 +364,23 @@ async def skyvern_browser_session_close(timing_ms=timer.timing_ms,)+ if current.browser is None and current.context and current.context.session_id:+ skyvern = get_skyvern()+ closed_id = current.context.session_id+ try:+ result = await do_session_close(skyvern, closed_id)+ finally:+ clear_session_ref_map(session_id=closed_id)+ delete_session_trajectories(closed_id)+ set_current_session(SessionState())+ timer.mark("sdk")+ recording_data = await _fetch_session_recording_data(skyvern, closed_id)+ return make_result(+ "skyvern_browser_session_close",+ data=_session_close_data(result.session_id, result.closed, recording_data),+ timing_ms=timer.timing_ms,+ )+if current.browser is None:return make_result("skyvern_browser_session_close",diff --git a/tests/unit/test_mcp_session_lifecycle.py b/tests/unit/test_mcp_session_lifecycle.pyindex fbb2e5c36..e91738fc2 100644--- a/tests/unit/test_mcp_session_lifecycle.py+++ b/tests/unit/test_mcp_session_lifecycle.py@@ -683,9 +683,11 @@ async def test_session_close_chains_exceptions_when_both_api_and_browser_fail(@pytest.mark.asyncio-async def test_session_close_matching_context_without_browser_returns_error(+async def test_session_close_by_id_succeeds_for_unconnected_current_cloud_session(monkeypatch: pytest.MonkeyPatch,) -> None:+ """A cloud session connects its browser lazily, so closing the current session by ID before any+ browser tool ran must report the successful remote close rather than a missing-browser error."""mcp_session.set_current_session(mcp_session.SessionState(browser=None,@@ -694,6 +696,7 @@ async def test_session_close_matching_context_without_browser_returns_error()fake_skyvern = MagicMock()+ fake_skyvern.get_browser_session = AsyncMock(side_effect=Exception("no recordings"))monkeypatch.setattr(mcp_session, "get_skyvern", lambda: fake_skyvern)do_session_close = AsyncMock(return_value=SessionCloseResult(session_id="pbs_999", closed=True))@@ -701,9 +704,8 @@ async def test_session_close_matching_context_without_browser_returns_error(result = await mcp_session.skyvern_browser_session_close(session_id="pbs_999")- assert result["ok"] is False- assert result["error"]["code"] == mcp_session.ErrorCode.SDK_ERROR- assert "Expected active browser for matching cloud session" in result["error"]["message"]+ assert result["ok"] is True+ assert result["data"] == {"session_id": "pbs_999", "closed": True}do_session_close.assert_awaited_once_with(fake_skyvern, "pbs_999")assert mcp_session.get_current_session().context is None@@ -1185,11 +1187,13 @@ async def test_session_create_stateless_mode_rejects_local() -> None:async def test_session_create_stateful_mode_uses_sdk_app_url(monkeypatch: pytest.MonkeyPatch,) -> None:- fake_browser = MagicMock()- fake_browser.browser_session_id = "pbs_stateful"- fake_browser.app_url = "https://app.example.test/sessions/pbs_stateful"fake_skyvern = MagicMock()- fake_skyvern.launch_cloud_browser = AsyncMock(return_value=fake_browser)+ fake_skyvern.create_browser_session = AsyncMock(+ return_value=SimpleNamespace(+ browser_session_id="pbs_stateful",+ app_url="https://app.example.test/sessions/pbs_stateful",+ )+ )fake_skyvern.get_browser_session = AsyncMock()monkeypatch.setattr(mcp_session, "get_skyvern", lambda: fake_skyvern)@@ -1201,15 +1205,135 @@ async def test_session_create_stateful_mode_uses_sdk_app_url(fake_skyvern.get_browser_session.assert_not_awaited()+async def test_session_create_cloud_mode_does_not_claim_initial_page(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ fake_skyvern = MagicMock()+ fake_skyvern.create_browser_session = AsyncMock(+ return_value=SimpleNamespace(+ browser_session_id="pbs_unclaimed",+ app_url="https://app.example.test/sessions/pbs_unclaimed",+ )+ )+ monkeypatch.setattr(mcp_session, "get_skyvern", lambda: fake_skyvern)++ result = await mcp_session.skyvern_browser_session_create(timeout=50)++ assert result["ok"] is True+ assert result["data"] == {+ "app_url": "https://app.example.test/sessions/pbs_unclaimed",+ "session_id": "pbs_unclaimed",+ "timeout_minutes": 50,+ }+ fake_skyvern.create_browser_session.assert_awaited_once_with(timeout=50, proxy_location=None)+ assert mcp_session.get_current_session().browser is None+ assert mcp_session.get_current_session().context == BrowserContext(+ mode="cloud_session", session_id="pbs_unclaimed", can_access_localhost=False+ )+++async def test_created_cloud_session_connects_lazily_for_browser_tools(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ session_manager.set_current_session(+ session_manager.SessionState(+ context=BrowserContext(mode="cloud_session", session_id="pbs_lazy"),+ api_key_hash=session_manager.active_api_key_hash(),+ )+ )+ browser = MagicMock()+ fake_skyvern = MagicMock()+ fake_skyvern.connect_to_cloud_browser_session = AsyncMock(return_value=browser)+ monkeypatch.setattr(session_manager, "get_skyvern", lambda: fake_skyvern)++ resolved_browser, context = await session_manager.resolve_browser()++ assert resolved_browser is browser+ assert context.session_id == "pbs_lazy"+ assert session_manager.get_current_session().browser is browser+ fake_skyvern.connect_to_cloud_browser_session.assert_awaited_once_with("pbs_lazy")+++async def test_session_close_closes_cloud_session_before_lazy_connection(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ session_manager.set_current_session(+ session_manager.SessionState(+ context=BrowserContext(mode="cloud_session", session_id="pbs_unconnected"),+ )+ )+ fake_skyvern = MagicMock()+ monkeypatch.setattr(mcp_session, "get_skyvern", lambda: fake_skyvern)+ close_session = AsyncMock(return_value=SessionCloseResult(session_id="pbs_unconnected", closed=True))+ monkeypatch.setattr(mcp_session, "do_session_close", close_session)++ result = await mcp_session.skyvern_browser_session_close()++ assert result["ok"] is True+ assert result["data"] == {"session_id": "pbs_unconnected", "closed": True}+ close_session.assert_awaited_once_with(fake_skyvern, "pbs_unconnected")+ assert session_manager.get_current_session().context is None+++async def test_session_close_clears_state_when_unconnected_cloud_close_fails(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ """A failed remote close must still clear local state, matching close_current_session(), so the+ next tool call is not wedged onto a session this process already tried to close."""+ session_manager.set_current_session(+ session_manager.SessionState(+ context=BrowserContext(mode="cloud_session", session_id="pbs_wedged"),+ api_key_hash="hash",+ )+ )+ session_manager.replace_session_ref_map({"ref_1": {"selector": "#a"}}, session_id="pbs_wedged")+ assert any("pbs_wedged" in key for key in session_manager._session_ref_maps)+ fake_skyvern = MagicMock()+ monkeypatch.setattr(mcp_session, "get_skyvern", lambda: fake_skyvern)+ close_session = AsyncMock(side_effect=ConnectionError("API close failed"))+ monkeypatch.setattr(mcp_session, "do_session_close", close_session)++ result = await mcp_session.skyvern_browser_session_close()++ assert result["ok"] is False+ assert "API close failed" in result["error"]["message"]+ assert session_manager.get_current_session().context is None+ assert not any("pbs_wedged" in key for key in session_manager._session_ref_maps)+++async def test_session_close_by_id_clears_state_when_unconnected_cloud_close_fails(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ session_manager.set_current_session(+ session_manager.SessionState(+ context=BrowserContext(mode="cloud_session", session_id="pbs_wedged_id"),+ )+ )+ fake_skyvern = MagicMock()+ monkeypatch.setattr(mcp_session, "get_skyvern", lambda: fake_skyvern)+ close_session = AsyncMock(side_effect=ConnectionError("API close failed"))+ monkeypatch.setattr(mcp_session, "do_session_close", close_session)++ result = await mcp_session.skyvern_browser_session_close(session_id="pbs_wedged_id")++ assert result["ok"] is False+ assert "API close failed" in result["error"]["message"]+ assert session_manager.get_current_session().context is None++@pytest.mark.asyncioasync def test_session_create_stateful_mode_omits_missing_sdk_app_url(monkeypatch: pytest.MonkeyPatch,) -> None:- fake_browser = MagicMock()- fake_browser.browser_session_id = "pbs_stateful"- fake_browser.app_url = Nonefake_skyvern = MagicMock()- fake_skyvern.launch_cloud_browser = AsyncMock(return_value=fake_browser)+ fake_skyvern.create_browser_session = AsyncMock(+ return_value=SimpleNamespace(browser_session_id="pbs_stateful", app_url=None)+ )fake_skyvern.get_browser_session = AsyncMock()monkeypatch.setattr(mcp_session, "get_skyvern", lambda: fake_skyvern)@@ -1283,6 +1407,7 @@ async def test_session_create_forwards_extensions_to_stateful_session_create(generate_browser_profile=False,local=False,headless=False,+ connect_browser=False,)@@ -1317,6 +1442,7 @@ async def test_session_create_forwards_browser_profile_id_to_stateful_session_crgenerate_browser_profile=False,local=False,headless=False,+ connect_browser=False,)@@ -1352,6 +1478,7 @@ async def test_session_create_forwards_generate_browser_profile_to_stateful_sessgenerate_browser_profile=True,local=False,headless=False,+ connect_browser=False,)