Skip to content

Automate browser based workflows with AI

fix(SKY-10141): preserve copilot browser session context (#6103)

Andrew Neilson97faa10ba5e0
diff --git a/skyvern/cli/core/client.py b/skyvern/cli/core/client.py
index 1fe2b3cfe..af68a0563 100644
--- a/skyvern/cli/core/client.py
+++ b/skyvern/cli/core/client.py
@@ -97,6 +97,11 @@ def get_active_api_key() -> str | None:
return _api_key_override.get() or _resolve_api_key()
+def has_api_key_override() -> bool:
+ """Return whether the current context carries a request-scoped API key."""
+ return _api_key_override.get() is not None
+
+
def set_api_key_override(api_key: str | None) -> Token[str | None]:
"""Set request-scoped API key override for MCP HTTP requests."""
_skyvern_instance.set(None)
diff --git a/skyvern/cli/core/session_manager.py b/skyvern/cli/core/session_manager.py
index 396aa9add..20791b887 100644
--- a/skyvern/cli/core/session_manager.py
+++ b/skyvern/cli/core/session_manager.py
@@ -13,7 +13,7 @@ from typing import TYPE_CHECKING, Any, AsyncIterator
import structlog
from .api_key_hash import hash_api_key_for_cache
-from .client import get_active_api_key, get_skyvern
+from .client import get_active_api_key, get_skyvern, has_api_key_override
from .result import BrowserContext, ErrorCode, make_error
LOG = structlog.get_logger(__name__)
@@ -212,14 +212,12 @@ async def resolve_browser(
# Check copilot session registry (cross-task fallback when ContextVar
# does not propagate through FastMCP in-process transport).
registered = _copilot_sessions.get(session_id) if session_id else None
- if (
- registered is not None
- and registered.browser is not None
- and registered.context is not None
- and _hashes_equal(registered.api_key_hash, active_api_key_hash)
- ):
- _current_session.set(registered)
- return registered.browser, registered.context
+ if registered is not None and registered.browser is not None and registered.context is not None:
+ if _hashes_equal(registered.api_key_hash, active_api_key_hash) or not has_api_key_override():
+ # FastMCP in-process tool tasks may miss the parent ContextVar.
+ # Explicit request overrides still win; otherwise use the temporary Copilot registry.
+ _current_session.set(registered)
+ return registered.browser, registered.context
browser: SkyvernBrowser | None = None
try:
diff --git a/skyvern/forge/sdk/copilot/mcp_adapter.py b/skyvern/forge/sdk/copilot/mcp_adapter.py
index 50a1daec0..989b5bc95 100644
--- a/skyvern/forge/sdk/copilot/mcp_adapter.py
+++ b/skyvern/forge/sdk/copilot/mcp_adapter.py
@@ -247,12 +247,11 @@ class SkyvernOverlayMCPServer(MCPServer):
mcp_args["session_id"] = copilot_ctx.browser_session_id
try:
- call = self._client.call_tool(mcp_name, mcp_args, raise_on_error=False)
if overlay.requires_browser:
async with mcp_browser_context(copilot_ctx):
- raw_result = await call
+ raw_result = await self._client.call_tool(mcp_name, mcp_args, raise_on_error=False)
else:
- raw_result = await call
+ raw_result = await self._client.call_tool(mcp_name, mcp_args, raise_on_error=False)
except Exception as e:
LOG.warning(
"MCP tool call failed",
diff --git a/skyvern/forge/sdk/copilot/tools.py b/skyvern/forge/sdk/copilot/tools.py
index a6d8cd743..a2b1b4611 100644
--- a/skyvern/forge/sdk/copilot/tools.py
+++ b/skyvern/forge/sdk/copilot/tools.py
@@ -2618,9 +2618,13 @@ async def _fallback_page_info(ctx: AgentContext) -> tuple[str, str]:
if not ctx.browser_session_id:
return "", ""
try:
- from skyvern.cli.core.session_manager import get_page
-
- page, _ = await get_page(session_id=ctx.browser_session_id)
+ browser_state = await app.PERSISTENT_SESSIONS_MANAGER.get_browser_state(
+ session_id=ctx.browser_session_id,
+ organization_id=ctx.organization_id,
+ )
+ if not browser_state:
+ return "", ""
+ page = await browser_state.get_or_create_page()
if page:
return page.url, await page.title()
except Exception:
diff --git a/tests/unit/test_copilot_hooks.py b/tests/unit/test_copilot_hooks.py
index e99c81d28..ea15a15b7 100644
--- a/tests/unit/test_copilot_hooks.py
+++ b/tests/unit/test_copilot_hooks.py
@@ -3,9 +3,11 @@
from __future__ import annotations
import json
+from contextlib import asynccontextmanager
from dataclasses import dataclass, field
+from types import SimpleNamespace
from typing import Any
-from unittest.mock import MagicMock
+from unittest.mock import AsyncMock, MagicMock, call
import pytest
@@ -226,6 +228,184 @@ class TestSchemaOverlay:
class TestMCPFailedStepLoopDetection:
+ @pytest.mark.asyncio
+ async def test_browser_tool_call_is_created_inside_copilot_browser_context(
+ self, monkeypatch: pytest.MonkeyPatch
+ ) -> None:
+ from skyvern.forge.sdk.copilot import mcp_adapter
+ from skyvern.forge.sdk.copilot.mcp_adapter import SchemaOverlay, SkyvernOverlayMCPServer
+
+ class FakeRawResult:
+ structured_content = {"ok": True, "data": {}}
+ is_error = False
+ content: list[Any] = []
+
+ in_context = False
+ calls: list[tuple[str, dict[str, Any], bool]] = []
+
+ class FakeClient:
+ async def call_tool(
+ self,
+ name: str,
+ args: dict[str, Any],
+ raise_on_error: bool = False,
+ ) -> FakeRawResult:
+ calls.append((name, args, in_context))
+ return FakeRawResult()
+
+ async def fake_ensure_browser_session(ctx: Any) -> None:
+ ctx.browser_session_id = "pbs_copilot"
+ return None
+
+ @asynccontextmanager
+ async def fake_mcp_browser_context(ctx: Any) -> Any:
+ nonlocal in_context
+ in_context = True
+ try:
+ yield
+ finally:
+ in_context = False
+
+ monkeypatch.setattr(mcp_adapter, "ensure_browser_session", fake_ensure_browser_session)
+ monkeypatch.setattr(mcp_adapter, "mcp_browser_context", fake_mcp_browser_context)
+
+ ctx = MagicMock()
+ ctx.consecutive_tool_tracker = []
+ ctx.failed_tool_step_tracker = {}
+ server = SkyvernOverlayMCPServer(
+ transport=MagicMock(),
+ overlays={"get_browser_screenshot": SchemaOverlay(requires_browser=True)},
+ alias_map={},
+ allowlist=frozenset(),
+ context_provider=lambda: ctx,
+ )
+ server._client = FakeClient()
+
+ result = await server.call_tool("get_browser_screenshot", {})
+
+ assert result.isError is False
+ assert calls == [("get_browser_screenshot", {"session_id": "pbs_copilot"}, True)]
+
+ @pytest.mark.asyncio
+ async def test_browser_overlay_reaches_fastmcp_tool_with_registered_copilot_session(
+ self, monkeypatch: pytest.MonkeyPatch
+ ) -> None:
+ from skyvern.cli.core import client as client_mod
+ from skyvern.cli.core import session_manager
+ from skyvern.cli.mcp_tools import browser as browser_tools
+ from skyvern.cli.mcp_tools import mcp
+ from skyvern.forge.sdk.copilot import runtime
+ from skyvern.forge.sdk.copilot.mcp_adapter import SchemaOverlay, SkyvernOverlayMCPServer
+ from skyvern.forge.sdk.copilot.runtime import AgentContext
+ from skyvern.forge.sdk.copilot.tools import _screenshot_post_hook
+
+ client_mod._skyvern_instance.set(None)
+ client_mod._api_key_override.set(None)
+ client_mod._global_skyvern_instance = None
+ client_mod._api_key_clients.clear()
+ session_manager._current_session.set(None)
+ session_manager._global_session = None
+ session_manager._copilot_sessions.clear()
+ session_manager.set_stateless_http_mode(False)
+
+ raw_page = MagicMock()
+ raw_page.is_closed.return_value = False
+ raw_page.on = MagicMock()
+ raw_page.url = "https://example.com"
+ browser_context = SimpleNamespace(
+ pages=[raw_page],
+ on=MagicMock(),
+ )
+ browser_state = SimpleNamespace(browser_context=browser_context)
+ persistent_session_manager = SimpleNamespace(
+ get_browser_state=AsyncMock(return_value=browser_state),
+ )
+ monkeypatch.setattr(runtime.app, "PERSISTENT_SESSIONS_MANAGER", persistent_session_manager)
+
+ runtime_skyvern = MagicMock()
+ monkeypatch.setattr(runtime, "get_skyvern", lambda: runtime_skyvern)
+
+ class FakeSkyvernBrowser:
+ def __init__(
+ self,
+ skyvern: Any,
+ browser_context: Any,
+ *,
+ browser_session_id: str | None = None,
+ browser_address: str | None = None,
+ ) -> None:
+ del skyvern, browser_address
+ self._browser_context = browser_context
+ self._browser_session_id = browser_session_id
+
+ async def get_working_page(self) -> Any:
+ return SimpleNamespace(is_closed=lambda: False)
+
+ monkeypatch.setattr(runtime, "SkyvernBrowser", FakeSkyvernBrowser)
+
+ fallback_skyvern = MagicMock()
+ fallback_skyvern.connect_to_cloud_browser_session = AsyncMock(
+ side_effect=AssertionError("unexpected SDK reconnect")
+ )
+ monkeypatch.setattr(session_manager, "get_skyvern", lambda: fallback_skyvern)
+
+ observed_session_ids: list[str | None] = []
+
+ async def fake_do_screenshot(page: Any, full_page: bool = False, selector: str | None = None) -> Any:
+ del page, full_page, selector
+ current = session_manager.get_current_session()
+ observed_session_ids.append(current.context.session_id if current.context else None)
+ assert current.api_key_hash == session_manager._api_key_hash("sk-copilot-org")
+ return SimpleNamespace(data=b"fake-png")
+
+ monkeypatch.setattr(browser_tools, "do_screenshot", fake_do_screenshot)
+
+ ctx = AgentContext(
+ organization_id="org-1",
+ workflow_id="wf-1",
+ workflow_permanent_id="wfp-1",
+ workflow_yaml="",
+ browser_session_id="pbs_copilot",
+ stream=MagicMock(is_disconnected=AsyncMock(return_value=False)),
+ api_key="sk-copilot-org",
+ )
+
+ server = SkyvernOverlayMCPServer(
+ transport=mcp,
+ overlays={
+ "get_browser_screenshot": SchemaOverlay(
+ requires_browser=True,
+ forced_args={"inline": True},
+ post_hook=_screenshot_post_hook,
+ )
+ },
+ alias_map={"get_browser_screenshot": "skyvern_screenshot"},
+ allowlist=frozenset({"skyvern_screenshot"}),
+ context_provider=lambda: ctx,
+ )
+
+ await server.connect()
+ try:
+ result = await server.call_tool("get_browser_screenshot", {})
+ finally:
+ await server.cleanup()
+ session_manager._copilot_sessions.clear()
+
+ parsed = json.loads(result.content[0].text)
+ assert result.isError is False
+ assert parsed["ok"] is True
+ assert parsed["data"]["screenshot_base64"]
+ assert observed_session_ids == ["pbs_copilot"]
+ fallback_skyvern.connect_to_cloud_browser_session.assert_not_awaited()
+ persistent_session_manager.get_browser_state.assert_any_await(
+ session_id="pbs_copilot",
+ organization_id="org-1",
+ )
+ assert persistent_session_manager.get_browser_state.await_args_list[0] == call(
+ session_id="pbs_copilot",
+ organization_id="org-1",
+ )
+
@pytest.mark.asyncio
async def test_interleaved_same_step_failures_short_circuit_third_dispatch(self) -> None:
from skyvern.forge.sdk.copilot.mcp_adapter import SkyvernOverlayMCPServer
diff --git a/tests/unit/test_copilot_watchdog.py b/tests/unit/test_copilot_watchdog.py
index af5217b4f..a392e8b0a 100644
--- a/tests/unit/test_copilot_watchdog.py
+++ b/tests/unit/test_copilot_watchdog.py
@@ -29,6 +29,7 @@ from __future__ import annotations
from datetime import datetime, timezone
from types import SimpleNamespace
from typing import Any
+from unittest.mock import AsyncMock
import pytest
@@ -37,6 +38,7 @@ from skyvern.forge.sdk.copilot.tools import (
RUN_BLOCKS_SAFETY_CEILING_SECONDS,
RUN_BLOCKS_STAGNATION_WINDOW_SECONDS,
_any_quiet_block_requested,
+ _fallback_page_info,
_progress_marker,
_read_progress_sources,
_tool_loop_error,
@@ -246,6 +248,29 @@ class _ErrorCtx:
browser_session_id = None
+async def test_fallback_page_info_uses_persistent_session_state_without_sdk_reconnect(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ from skyvern.forge import app as forge_app
+
+ page = SimpleNamespace(url="https://example.test/current", title=AsyncMock(return_value="Current page"))
+ browser_state = SimpleNamespace(get_or_create_page=AsyncMock(return_value=page))
+ session_manager = SimpleNamespace(get_browser_state=AsyncMock(return_value=browser_state))
+ monkeypatch.setattr(forge_app, "PERSISTENT_SESSIONS_MANAGER", session_manager)
+
+ ctx = SimpleNamespace(organization_id="o_test", browser_session_id="pbs_copilot")
+
+ current_url, page_title = await _fallback_page_info(ctx)
+
+ assert current_url == "https://example.test/current"
+ assert page_title == "Current page"
+ session_manager.get_browser_state.assert_awaited_once_with(
+ session_id="pbs_copilot",
+ organization_id="o_test",
+ )
+
+
@pytest.mark.asyncio
async def test_stagnation_error_message_does_not_invite_retry() -> None:
"""The exact SKY-9163 bug: the old copy said "likely stuck repeating
diff --git a/tests/unit/test_mcp_session_lifecycle.py b/tests/unit/test_mcp_session_lifecycle.py
index 855b9115b..40e9190bc 100644
--- a/tests/unit/test_mcp_session_lifecycle.py
+++ b/tests/unit/test_mcp_session_lifecycle.py
@@ -30,6 +30,7 @@ def _reset_singletons() -> None:
session_manager._current_session.set(None)
session_manager._global_session = None
+ session_manager._copilot_sessions.clear()
session_manager.set_stateless_http_mode(False)
@@ -323,6 +324,33 @@ async def test_resolve_browser_does_not_reuse_session_for_different_api_key(
fake_skyvern.connect_to_cloud_browser_session.assert_awaited_once_with("pbs_123")
+async def test_resolve_browser_does_not_reuse_registered_copilot_session_for_different_api_key_override(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ registered_state = session_manager.SessionState(
+ browser=MagicMock(),
+ context=BrowserContext(mode="cloud_session", session_id="pbs_copilot"),
+ api_key_hash=session_manager._api_key_hash("sk_copilot_org"),
+ )
+ session_manager.register_copilot_session("pbs_copilot", registered_state)
+
+ fallback_browser = MagicMock()
+ fake_skyvern = MagicMock()
+ fake_skyvern.connect_to_cloud_browser_session = AsyncMock(return_value=fallback_browser)
+ monkeypatch.setattr(session_manager, "get_skyvern", lambda: fake_skyvern)
+
+ token = client_mod.set_api_key_override("sk_other_org")
+ try:
+ browser, ctx = await session_manager.resolve_browser(session_id="pbs_copilot")
+ finally:
+ client_mod.reset_api_key_override(token)
+
+ assert browser is fallback_browser
+ assert ctx.session_id == "pbs_copilot"
+ fake_skyvern.connect_to_cloud_browser_session.assert_awaited_once_with("pbs_copilot")
+
+
@pytest.mark.asyncio
async def test_resolve_browser_stateless_mode_does_not_write_global_session(monkeypatch: pytest.MonkeyPatch) -> None:
global_state = session_manager.SessionState(