Skip to content

Automate browser based workflows with AI

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.py
index 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 ContextVar
diff --git a/skyvern/cli/core/session_ops.py b/skyvern/cli/core/session_ops.py
index c16fb3702..f4b902f04 100644
--- a/skyvern/cli/core/session_ops.py
+++ b/skyvern/cli/core/session_ops.py
@@ -7,7 +7,7 @@ from dataclasses import dataclass
from typing import Any
from 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 = False
headless: bool = False
timeout_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"] = extensions
diff --git a/skyvern/cli/mcp_tools/session.py b/skyvern/cli/mcp_tools/session.py
index 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_url
except 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 = None
with 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.py
index 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.asyncio
async 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 = None
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=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_cr
generate_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_sess
generate_browser_profile=True,
local=False,
headless=False,
+ connect_browser=False,
)