Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
Allow MCP browser sessions to use browser profiles (#6798)
Suchintan7638e7d8f6cb
diff --git a/skyvern/cli/core/session_ops.py b/skyvern/cli/core/session_ops.pyindex d495bbc43..3df12bf3f 100644--- a/skyvern/cli/core/session_ops.py+++ b/skyvern/cli/core/session_ops.py@@ -63,11 +63,17 @@ async def do_session_create(timeout: int = 60,proxy_location: ProxyLocationInput | str | None = None,extensions: list[Extensions] | None = None,+ browser_profile_id: str | None = None,+ generate_browser_profile: bool = False,local: bool = False,headless: bool = False,) -> tuple[Any, SessionCreateResult]:"""Create browser session. Returns (browser, result)."""if local:+ if browser_profile_id is not None or generate_browser_profile:+ raise ValueError(+ "browser_profile_id and generate_browser_profile are only supported for cloud sessions, not local=True."+ )browser = await skyvern.launch_local_browser(headless=headless)return browser, SessionCreateResult(session_id=None, local=True, headless=headless)@@ -75,13 +81,90 @@ async def do_session_create(launch_kwargs: dict[str, Any] = {"timeout": timeout, "proxy_location": proxy}if extensions is not None:launch_kwargs["extensions"] = extensions+ if browser_profile_id is not None:+ launch_kwargs["browser_profile_id"] = browser_profile_idbrowser = await skyvern.launch_cloud_browser(**launch_kwargs)+ session_id = browser.browser_session_id+ if generate_browser_profile and session_id:+ await do_session_arm_generate_browser_profile(skyvern, session_id, browser=browser)return browser, SessionCreateResult(- session_id=browser.browser_session_id,+ session_id=session_id,timeout_minutes=timeout,)+async def do_session_arm_generate_browser_profile(+ skyvern: Any,+ session_id: str,+ *,+ browser: Any | None = None,+) -> None:+ """Arm profile capture on a freshly created session, rolling the session back if arming fails.++ Shared by the stateful and stateless create paths so the create -> PATCH -> rollback contract+ lives in one place. Pass ``browser`` for the stateful path so its local CDP connection is torn+ down on rollback too.+ """+ try:+ await do_session_update_generate_browser_profile(skyvern, session_id, True)+ except Exception as exc:+ await do_session_rollback_created_session(skyvern, session_id, exc, browser=browser)+ raise+++async def do_session_update_generate_browser_profile(+ skyvern: Any,+ session_id: str,+ generate_browser_profile: bool,+) -> None:+ """PATCH a live browser session's profile-capture flag via the private SDK wrapper.++ The generated Fern client has no browser-session update method yet (the route exists and is+ annotated for Fern), so we reach through the wrapper deliberately until the SDK is regenerated.+ """+ response = await skyvern._client_wrapper.httpx_client.request(+ f"v1/browser_sessions/{session_id}",+ method="PATCH",+ json={"generate_browser_profile": generate_browser_profile},+ headers={"content-type": "application/json"},+ )+ if response.status_code >= 400:+ try:+ body = response.json()+ detail = body.get("detail", response.text) if isinstance(body, dict) else response.text+ except (ValueError, json.JSONDecodeError):+ detail = response.text+ raise RuntimeError(f"Failed to update browser session {session_id}: HTTP {response.status_code}: {detail}")+++async def do_session_rollback_created_session(+ skyvern: Any,+ session_id: str,+ failure: Exception,+ *,+ browser: Any | None = None,+) -> None:+ """Close a just-created cloud session (and its local browser) after later setup fails.++ Tears down both the remote session and, when provided, the local CDP/Playwright connection. If+ either cleanup fails, the original ``failure`` is preserved and the cleanup error is appended.+ """+ cleanup_errors: list[str] = []+ try:+ await do_session_close(skyvern, session_id)+ except Exception as session_error:+ cleanup_errors.append(f"failed to close browser session {session_id}: {session_error}")+ if browser is not None:+ try:+ await browser.close()+ except Exception as browser_error:+ cleanup_errors.append(f"failed to close local browser for {session_id}: {browser_error}")+ if cleanup_errors:+ raise RuntimeError(+ f"{failure}; additionally {'; '.join(cleanup_errors)} after session setup failed"+ ) from failure++async def do_session_close(skyvern: Any, session_id: str) -> SessionCloseResult:"""Close a browser session by ID."""await skyvern.close_browser_session(session_id)diff --git a/skyvern/cli/mcp_tools/README.md b/skyvern/cli/mcp_tools/README.mdindex a00cf0158..bc3a37e60 100644--- a/skyvern/cli/mcp_tools/README.md+++ b/skyvern/cli/mcp_tools/README.md@@ -77,6 +77,9 @@ Manual config for any MCP client:### Browser Sessions`skyvern_browser_session_create`, `skyvern_browser_session_close`, `skyvern_browser_session_list`, `skyvern_browser_session_get`, `skyvern_browser_session_connect`+### Browser Profiles+`skyvern_browser_profile_create`, `skyvern_browser_profile_list`, `skyvern_browser_profile_get`, `skyvern_browser_profile_update`, `skyvern_browser_profile_delete`+### Browser Actions`skyvern_act` (natural language), `skyvern_navigate`, `skyvern_click`, `skyvern_type`, `skyvern_hover`, `skyvern_scroll`, `skyvern_select_option`, `skyvern_press_key`, `skyvern_drag`, `skyvern_file_upload`, `skyvern_wait`diff --git a/skyvern/cli/mcp_tools/__init__.py b/skyvern/cli/mcp_tools/__init__.pyindex a0276e048..4df9cdd08 100644--- a/skyvern/cli/mcp_tools/__init__.py+++ b/skyvern/cli/mcp_tools/__init__.py@@ -75,6 +75,13 @@ from .browser import (skyvern_validate,skyvern_wait,)+from .browser_profiles import (+ skyvern_browser_profile_create,+ skyvern_browser_profile_delete,+ skyvern_browser_profile_get,+ skyvern_browser_profile_list,+ skyvern_browser_profile_update,+)from .credential import (skyvern_credential_delete,skyvern_credential_get,@@ -349,6 +356,13 @@ mcp.tool(tags={"session"}, annotations=_ro("List Browser Sessions"))(skyvern_bromcp.tool(tags={"session"}, annotations=_ro("Get Browser Session"))(skyvern_browser_session_get)mcp.tool(tags={"session"}, annotations=_web_mut("Connect to Browser Session"))(skyvern_browser_session_connect)+# -- Browser profile management --+mcp.tool(tags={"browser_profile"}, annotations=_mut("Create Browser Profile"))(skyvern_browser_profile_create)+mcp.tool(tags={"browser_profile"}, annotations=_ro("List Browser Profiles"))(skyvern_browser_profile_list)+mcp.tool(tags={"browser_profile"}, annotations=_ro("Get Browser Profile"))(skyvern_browser_profile_get)+mcp.tool(tags={"browser_profile"}, annotations=_mut("Update Browser Profile"))(skyvern_browser_profile_update)+mcp.tool(tags={"browser_profile"}, annotations=_dest("Delete Browser Profile"))(skyvern_browser_profile_delete)+# -- Primary tools (AI-powered exploration + observation) --# Browser tools run against arbitrary websites. Read-only inspection remains# non-destructive, but still open-world because the target site is unbounded.@@ -485,6 +499,12 @@ __all__ = ["skyvern_browser_session_list","skyvern_browser_session_get","skyvern_browser_session_connect",+ # Browser profiles+ "skyvern_browser_profile_create",+ "skyvern_browser_profile_list",+ "skyvern_browser_profile_get",+ "skyvern_browser_profile_update",+ "skyvern_browser_profile_delete",# Primary (AI-powered)"skyvern_act","skyvern_extract",diff --git a/skyvern/cli/mcp_tools/browser_profiles.py b/skyvern/cli/mcp_tools/browser_profiles.pynew file mode 100644index 000000000..1cf8d25f0--- /dev/null+++ b/skyvern/cli/mcp_tools/browser_profiles.py@@ -0,0 +1,224 @@+from __future__ import annotations++from datetime import datetime+from typing import Annotated, Any++from pydantic import Field++from skyvern.client.types.browser_profile import BrowserProfile++from ._common import BrowserContext, ErrorCode, Timer, make_error, make_result+from ._session import get_skyvern+++def _profile_to_dict(profile: BrowserProfile) -> dict[str, Any]:+ data = {+ "browser_profile_id": profile.browser_profile_id,+ "organization_id": profile.organization_id,+ "name": profile.name,+ "description": profile.description,+ "source_browser_type": profile.source_browser_type,+ "created_at": _serialize_timestamp(profile.created_at),+ "modified_at": _serialize_timestamp(profile.modified_at),+ "deleted_at": _serialize_timestamp(profile.deleted_at),+ }+ return {key: value for key, value in data.items() if value is not None}+++def _serialize_timestamp(value: Any) -> str | None:+ if value is None:+ return None+ if isinstance(value, datetime):+ return value.isoformat()+ return str(value)+++async def skyvern_browser_profile_create(+ name: Annotated[str, Field(description="Name for the browser profile.")],+ description: Annotated[str | None, Field(description="Optional profile description.")] = None,+ browser_session_id: Annotated[+ str | None,+ Field(+ description=(+ "Persistent browser session to capture into a profile. The session must have been started with "+ "generate_browser_profile enabled and then closed so its profile archive exists."+ )+ ),+ ] = None,+ workflow_run_id: Annotated[+ str | None,+ Field(description="Workflow run whose persisted session should be captured into a profile."),+ ] = None,+) -> dict[str, Any]:+ """Create a browser profile from a persistent browser session or workflow run."""+ with Timer() as timer:+ try:+ if browser_session_id and workflow_run_id:+ return make_result(+ "skyvern_browser_profile_create",+ ok=False,+ timing_ms=timer.timing_ms,+ error=make_error(+ ErrorCode.INVALID_INPUT,+ "Provide only one profile source",+ "Use either browser_session_id or workflow_run_id, not both.",+ ),+ )++ source_browser_session_id = browser_session_id+ if not source_browser_session_id and not workflow_run_id:+ return make_result(+ "skyvern_browser_profile_create",+ ok=False,+ timing_ms=timer.timing_ms,+ error=make_error(+ ErrorCode.INVALID_INPUT,+ "No browser profile source provided",+ "Pass a browser_session_id or workflow_run_id. The source session must have been started "+ "with generate_browser_profile enabled and already closed (its profile archive is created "+ "on close).",+ ),+ )++ profile = await get_skyvern().create_browser_profile(+ name=name,+ description=description,+ browser_session_id=source_browser_session_id,+ workflow_run_id=workflow_run_id,+ )+ timer.mark("sdk")+ browser_context = (+ BrowserContext(mode="cloud_session", session_id=source_browser_session_id)+ if source_browser_session_id+ else None+ )+ return make_result(+ "skyvern_browser_profile_create",+ browser_context=browser_context,+ data=_profile_to_dict(profile),+ timing_ms=timer.timing_ms,+ )+ except Exception as e:+ return make_result(+ "skyvern_browser_profile_create",+ ok=False,+ timing_ms=timer.timing_ms,+ error=make_error(ErrorCode.SDK_ERROR, str(e), "Failed to create browser profile"),+ )+++async def skyvern_browser_profile_list(+ page: Annotated[int | None, Field(description="Page number for paginated profile listing.")] = None,+ page_size: Annotated[int | None, Field(description="Page size for paginated profile listing.")] = None,+ include_deleted: Annotated[bool | None, Field(description="Include soft-deleted browser profiles.")] = None,+ search_key: Annotated[+ str | None,+ Field(description="Case-insensitive substring search across browser profile name and description."),+ ] = None,+) -> dict[str, Any]:+ """List browser profiles for the organization."""+ with Timer() as timer:+ try:+ profiles = await get_skyvern().list_browser_profiles(+ page=page,+ page_size=page_size,+ include_deleted=include_deleted,+ search_key=search_key,+ )+ timer.mark("sdk")+ serialized_profiles = [_profile_to_dict(profile) for profile in profiles]+ return make_result(+ "skyvern_browser_profile_list",+ data={"profiles": serialized_profiles, "count": len(serialized_profiles)},+ timing_ms=timer.timing_ms,+ )+ except Exception as e:+ return make_result(+ "skyvern_browser_profile_list",+ ok=False,+ timing_ms=timer.timing_ms,+ error=make_error(ErrorCode.SDK_ERROR, str(e), "Failed to list browser profiles"),+ )+++async def skyvern_browser_profile_get(+ browser_profile_id: Annotated[str, Field(description="Browser profile ID. Browser profile IDs start with bp_.")],+) -> dict[str, Any]:+ """Get a browser profile by ID."""+ with Timer() as timer:+ try:+ profile = await get_skyvern().get_browser_profile(browser_profile_id)+ timer.mark("sdk")+ return make_result(+ "skyvern_browser_profile_get",+ data=_profile_to_dict(profile),+ timing_ms=timer.timing_ms,+ )+ except Exception as e:+ return make_result(+ "skyvern_browser_profile_get",+ ok=False,+ timing_ms=timer.timing_ms,+ error=make_error(ErrorCode.SDK_ERROR, str(e), "Failed to get browser profile"),+ )+++async def skyvern_browser_profile_update(+ browser_profile_id: Annotated[str, Field(description="Browser profile ID. Browser profile IDs start with bp_.")],+ name: Annotated[str | None, Field(description="New browser profile name.")] = None,+ description: Annotated[str | None, Field(description="New browser profile description.")] = None,+) -> dict[str, Any]:+ """Update a browser profile's name and/or description."""+ with Timer() as timer:+ try:+ if name is None and description is None:+ return make_result(+ "skyvern_browser_profile_update",+ ok=False,+ timing_ms=timer.timing_ms,+ error=make_error(+ ErrorCode.INVALID_INPUT,+ "No browser profile updates provided",+ "Pass name, description, or both.",+ ),+ )+ profile = await get_skyvern().update_browser_profile(+ browser_profile_id,+ name=name,+ description=description,+ )+ timer.mark("sdk")+ return make_result(+ "skyvern_browser_profile_update",+ data=_profile_to_dict(profile),+ timing_ms=timer.timing_ms,+ )+ except Exception as e:+ return make_result(+ "skyvern_browser_profile_update",+ ok=False,+ timing_ms=timer.timing_ms,+ error=make_error(ErrorCode.SDK_ERROR, str(e), "Failed to update browser profile"),+ )+++async def skyvern_browser_profile_delete(+ browser_profile_id: Annotated[str, Field(description="Browser profile ID. Browser profile IDs start with bp_.")],+) -> dict[str, Any]:+ """Delete a browser profile."""+ with Timer() as timer:+ try:+ await get_skyvern().delete_browser_profile(browser_profile_id)+ timer.mark("sdk")+ return make_result(+ "skyvern_browser_profile_delete",+ data={"browser_profile_id": browser_profile_id, "deleted": True},+ timing_ms=timer.timing_ms,+ )+ except Exception as e:+ return make_result(+ "skyvern_browser_profile_delete",+ ok=False,+ timing_ms=timer.timing_ms,+ error=make_error(ErrorCode.SDK_ERROR, str(e), "Failed to delete browser profile"),+ )diff --git a/skyvern/cli/mcp_tools/session.py b/skyvern/cli/mcp_tools/session.pyindex 62c2e783b..2ec8e3a3a 100644--- a/skyvern/cli/mcp_tools/session.py+++ b/skyvern/cli/mcp_tools/session.py@@ -8,13 +8,20 @@ from pydantic import Fieldfrom skyvern.cli.core.api_key_hash import hash_api_key_for_cachefrom skyvern.cli.core.client import get_active_api_keyfrom skyvern.cli.core.session_manager import is_stateless_http_mode-from skyvern.cli.core.session_ops import coerce_proxy_location, do_session_close, do_session_create, do_session_list+from skyvern.cli.core.session_ops import (+ coerce_proxy_location,+ do_session_arm_generate_browser_profile,+ do_session_close,+ do_session_create,+ do_session_list,+)from skyvern.client.types.extensions import Extensionsfrom skyvern.schemas.runs import proxy_location_to_requestfrom ._common import BrowserContext, ErrorCode, Timer, make_error, make_resultfrom ._session import (SessionState,+ close_current_session,get_current_session,get_skyvern,resolve_browser,@@ -38,6 +45,18 @@ def _should_default_to_cdp() -> tuple[bool, str | None]:return False, None+def _session_create_data(+ session_id: str | None, timeout_minutes: int | None, generate_browser_profile: bool+) -> dict[str, Any]:+ data = {+ "session_id": session_id,+ "timeout_minutes": timeout_minutes,+ }+ if generate_browser_profile:+ data["generate_browser_profile"] = True+ return data++async def skyvern_browser_session_create(timeout: Annotated[int | None, Field(description="Session timeout in minutes (5-1440)")] = 60,proxy_location: Annotated[@@ -53,6 +72,26 @@ async def skyvern_browser_session_create(list[Extensions] | None,Field(description='Browser extensions to install, for example ["captcha-solver"].'),] = None,+ browser_profile_id: Annotated[+ str | None,+ Field(+ description=(+ "Browser profile ID to load into the cloud session, restoring persisted cookies, localStorage, "+ "and other profile state. Browser profile IDs start with bp_."+ )+ ),+ ] = None,+ generate_browser_profile: Annotated[+ bool,+ Field(+ description=(+ "When true, this session opts into exporting its browser profile when it closes. To turn that "+ "export into a reusable profile, call skyvern_browser_profile_create(name=..., browser_session_id=...) "+ "after the session closes. Sessions that don't load a profile and don't set this flag normally skip "+ "the export."+ )+ ),+ ] = False,local: Annotated[bool, Field(description="Launch local browser instead of cloud")] = False,headless: Annotated[bool, Field(description="Run local browser in headless mode")] = False,) -> dict[str, Any]:@@ -66,6 +105,16 @@ async def skyvern_browser_session_create(# internally, so we don't need to call it again here.use_cdp, cdp_url = _should_default_to_cdp()if use_cdp and not local and cdp_url:+ if browser_profile_id is not None or generate_browser_profile:+ return make_result(+ "skyvern_browser_session_create",+ ok=False,+ error=make_error(+ ErrorCode.INVALID_INPUT,+ "browser_profile_id and generate_browser_profile require a cloud session",+ "Unset BROWSER_TYPE=cdp-connect, or drop the browser profile options.",+ ),+ )with Timer() as timer:try:_browser, ctx = await resolve_browser(cdp_url=cdp_url)@@ -102,13 +151,28 @@ async def skyvern_browser_session_create(),)+ if local and (browser_profile_id is not None or generate_browser_profile):+ return make_result(+ "skyvern_browser_session_create",+ ok=False,+ error=make_error(+ ErrorCode.INVALID_INPUT,+ "browser_profile_id and generate_browser_profile require a cloud session",+ "Remove local=true, or drop the browser profile options.",+ ),+ )+skyvern = get_skyvern()if is_stateless_http_mode():proxy = proxy_location_to_request(coerce_proxy_location(proxy_location))create_kwargs: dict[str, Any] = {"timeout": timeout or 60, "proxy_location": proxy}if extensions is not None:create_kwargs["extensions"] = extensions+ if browser_profile_id is not None:+ create_kwargs["browser_profile_id"] = browser_profile_idsession = await skyvern.create_browser_session(**create_kwargs)+ if generate_browser_profile:+ await do_session_arm_generate_browser_profile(skyvern, session.browser_session_id)timer.mark("sdk")ctx = BrowserContext(mode="cloud_session",@@ -118,10 +182,7 @@ async def skyvern_browser_session_create(return make_result("skyvern_browser_session_create",browser_context=ctx,- data={- "session_id": session.browser_session_id,- "timeout_minutes": timeout or 60,- },+ data=_session_create_data(session.browser_session_id, timeout or 60, generate_browser_profile),timing_ms=timer.timing_ms,)@@ -130,6 +191,8 @@ async def skyvern_browser_session_create(timeout=timeout or 60,proxy_location=coerce_proxy_location(proxy_location),extensions=extensions,+ browser_profile_id=browser_profile_id,+ generate_browser_profile=generate_browser_profile,local=local,headless=headless,)@@ -175,10 +238,7 @@ async def skyvern_browser_session_create(return make_result("skyvern_browser_session_create",browser_context=ctx,- data={- "session_id": result.session_id,- "timeout_minutes": result.timeout_minutes,- },+ data=_session_create_data(result.session_id, result.timeout_minutes, generate_browser_profile),timing_ms=timer.timing_ms,)@@ -267,8 +327,7 @@ async def skyvern_browser_session_close()closed_id = current.context.session_id if current.context else None- await current.browser.close()- set_current_session(SessionState())+ await close_current_session()timer.mark("sdk")except Exception as e:diff --git a/skyvern/library/skyvern.py b/skyvern/library/skyvern.pyindex dbd018427..d7680c6d4 100644--- a/skyvern/library/skyvern.py+++ b/skyvern/library/skyvern.py@@ -556,6 +556,7 @@ class Skyvern(AsyncSkyvern):timeout: int | None = None,proxy_location: ProxyLocationInput = None,extensions: list[Extensions] | None = None,+ browser_profile_id: str | None = None,) -> SkyvernBrowser:"""Launch a new cloud-hosted browser session.@@ -567,6 +568,7 @@ class Skyvern(AsyncSkyvern):proxy_location: Geographic proxy location to route the browser traffic through.This is only available in Skyvern Cloud.extensions: Browser extensions to install in the session.+ browser_profile_id: Browser profile ID to load into the session.Returns:SkyvernBrowser: A browser instance connected to the new cloud session.@@ -578,6 +580,8 @@ class Skyvern(AsyncSkyvern):}if extensions is not None:create_kwargs["extensions"] = extensions+ if browser_profile_id is not None:+ create_kwargs["browser_profile_id"] = browser_profile_idbrowser_session = await self.create_browser_session(**create_kwargs)if self._environment == SkyvernEnvironment.CLOUD:LOG.info(diff --git a/tests/unit/test_cli_shared_core.py b/tests/unit/test_cli_shared_core.pyindex 201179d6a..45f0a1f78 100644--- a/tests/unit/test_cli_shared_core.py+++ b/tests/unit/test_cli_shared_core.py@@ -196,6 +196,19 @@ async def test_do_session_create_local() -> None:assert result.session_id is None+async def test_do_session_create_local_rejects_browser_profile_options() -> None:+ skyvern = MagicMock()+ skyvern.launch_local_browser = AsyncMock(return_value=MagicMock())++ with pytest.raises(ValueError, match="only supported for cloud sessions"):+ await do_session_create(skyvern, local=True, browser_profile_id="bp_123")+ with pytest.raises(ValueError, match="only supported for cloud sessions"):+ await do_session_create(skyvern, local=True, generate_browser_profile=True)++ skyvern.launch_local_browser.assert_not_awaited()++@pytest.mark.asyncioasync def test_do_session_create_cloud() -> None:skyvern = MagicMock()@@ -230,6 +243,101 @@ async def test_do_session_create_cloud_forwards_extensions() -> None:)+async def test_do_session_create_cloud_forwards_browser_profile_id() -> None:+ skyvern = MagicMock()+ browser_mock = MagicMock()+ browser_mock.browser_session_id = "pbs_profile"+ skyvern.launch_cloud_browser = AsyncMock(return_value=browser_mock)++ browser, result = await do_session_create(+ skyvern,+ timeout=30,+ browser_profile_id="bp_123",+ )++ assert browser is browser_mock+ assert result.session_id == "pbs_profile"+ skyvern.launch_cloud_browser.assert_awaited_once_with(+ timeout=30,+ proxy_location=None,+ browser_profile_id="bp_123",+ )+++async def test_do_session_create_cloud_enables_browser_profile_export() -> None:+ skyvern = MagicMock()+ browser_mock = MagicMock()+ browser_mock.browser_session_id = "pbs_profile"+ skyvern.launch_cloud_browser = AsyncMock(return_value=browser_mock)+ skyvern._client_wrapper.httpx_client.request = AsyncMock(+ return_value=MagicMock(status_code=200, text="", json=lambda: {})+ )++ browser, result = await do_session_create(+ skyvern,+ timeout=30,+ generate_browser_profile=True,+ )++ assert browser is browser_mock+ assert result.session_id == "pbs_profile"+ skyvern._client_wrapper.httpx_client.request.assert_awaited_once_with(+ "v1/browser_sessions/pbs_profile",+ method="PATCH",+ json={"generate_browser_profile": True},+ headers={"content-type": "application/json"},+ )+++async def test_do_session_create_cloud_rolls_back_when_browser_profile_export_patch_fails() -> None:+ skyvern = MagicMock()+ browser_mock = MagicMock()+ browser_mock.browser_session_id = "pbs_profile"+ browser_mock.close = AsyncMock()+ skyvern.launch_cloud_browser = AsyncMock(return_value=browser_mock)+ skyvern.close_browser_session = AsyncMock()+ skyvern._client_wrapper.httpx_client.request = AsyncMock(+ return_value=MagicMock(status_code=500, text="patch failed", json=lambda: {"detail": "patch failed"})+ )++ with pytest.raises(RuntimeError, match="Failed to update browser session pbs_profile"):+ await do_session_create(+ skyvern,+ timeout=30,+ generate_browser_profile=True,+ )++ skyvern.close_browser_session.assert_awaited_once_with("pbs_profile")+ browser_mock.close.assert_awaited_once()+++async def test_do_session_create_preserves_patch_failure_when_rollback_fails() -> None:+ skyvern = MagicMock()+ browser_mock = MagicMock()+ browser_mock.browser_session_id = "pbs_profile"+ browser_mock.close = AsyncMock()+ skyvern.launch_cloud_browser = AsyncMock(return_value=browser_mock)+ skyvern.close_browser_session = AsyncMock(side_effect=RuntimeError("close failed"))+ skyvern._client_wrapper.httpx_client.request = AsyncMock(+ return_value=MagicMock(status_code=500, text="patch failed", json=lambda: {"detail": "patch failed"})+ )++ with pytest.raises(RuntimeError) as exc_info:+ await do_session_create(+ skyvern,+ timeout=30,+ generate_browser_profile=True,+ )++ assert "Failed to update browser session pbs_profile" in str(exc_info.value)+ assert "close failed" in str(exc_info.value)+ skyvern.close_browser_session.assert_awaited_once_with("pbs_profile")++@pytest.mark.asyncioasync def test_do_session_close() -> None:skyvern = MagicMock()diff --git a/tests/unit/test_mcp_browser_profiles.py b/tests/unit/test_mcp_browser_profiles.pynew file mode 100644index 000000000..4725c93b5--- /dev/null+++ b/tests/unit/test_mcp_browser_profiles.py@@ -0,0 +1,203 @@+from __future__ import annotations++from datetime import UTC, datetime+from types import SimpleNamespace+from unittest.mock import AsyncMock, MagicMock++import pytest++from skyvern.cli.core import session_manager+from skyvern.cli.core.result import BrowserContext+from skyvern.cli.mcp_tools import browser_profiles as mcp_browser_profiles+from skyvern.cli.mcp_tools import skyvern_browser_profile_create+from skyvern.cli.mcp_tools._session import SessionState, set_current_session++[email protected](autouse=True)+def _reset_session_state() -> None:+ session_manager._current_session.set(None)+ session_manager._global_session = None+ yield+ session_manager._current_session.set(None)+ session_manager._global_session = None+++def _profile(profile_id: str = "bp_123") -> SimpleNamespace:+ now = datetime(2026, 1, 2, 3, 4, 5, tzinfo=UTC)+ return SimpleNamespace(+ browser_profile_id=profile_id,+ organization_id="org_123",+ name="Test profile",+ description="Reusable login state",+ source_browser_type="chrome",+ created_at=now,+ modified_at=now,+ deleted_at=None,+ )+++async def test_browser_profile_create_accepts_explicit_browser_session(monkeypatch: pytest.MonkeyPatch) -> None:+ fake_skyvern = MagicMock()+ fake_skyvern.create_browser_profile = AsyncMock(return_value=_profile())+ monkeypatch.setattr(mcp_browser_profiles, "get_skyvern", lambda: fake_skyvern)++ result = await mcp_browser_profiles.skyvern_browser_profile_create(+ name="Test profile",+ description="Reusable login state",+ browser_session_id="pbs_123",+ )++ assert result["ok"] is True+ assert result["browser_context"]["session_id"] == "pbs_123"+ assert result["data"]["browser_profile_id"] == "bp_123"+ fake_skyvern.create_browser_profile.assert_awaited_once_with(+ name="Test profile",+ description="Reusable login state",+ browser_session_id="pbs_123",+ workflow_run_id=None,+ )+++async def test_browser_profile_create_requires_explicit_source_even_with_active_session(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ fake_skyvern = MagicMock()+ fake_skyvern.create_browser_profile = AsyncMock(return_value=_profile())+ monkeypatch.setattr(mcp_browser_profiles, "get_skyvern", lambda: fake_skyvern)+ set_current_session(SessionState(context=BrowserContext(mode="cloud_session", session_id="pbs_123")))++ result = await mcp_browser_profiles.skyvern_browser_profile_create(name="Test profile")++ assert result["ok"] is False+ assert result["error"]["code"] == "INVALID_INPUT"+ fake_skyvern.create_browser_profile.assert_not_awaited()+++async def test_browser_profile_create_accepts_workflow_run_source(monkeypatch: pytest.MonkeyPatch) -> None:+ fake_skyvern = MagicMock()+ fake_skyvern.create_browser_profile = AsyncMock(return_value=_profile())+ monkeypatch.setattr(mcp_browser_profiles, "get_skyvern", lambda: fake_skyvern)++ result = await mcp_browser_profiles.skyvern_browser_profile_create(+ name="Workflow profile",+ workflow_run_id="wr_123",+ )++ assert result["ok"] is True+ fake_skyvern.create_browser_profile.assert_awaited_once_with(+ name="Workflow profile",+ description=None,+ browser_session_id=None,+ workflow_run_id="wr_123",+ )+++async def test_browser_profile_create_workflow_run_source_ignores_current_session(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ fake_skyvern = MagicMock()+ fake_skyvern.create_browser_profile = AsyncMock(return_value=_profile())+ monkeypatch.setattr(mcp_browser_profiles, "get_skyvern", lambda: fake_skyvern)+ set_current_session(SessionState(context=BrowserContext(mode="cloud_session", session_id="pbs_123")))++ result = await mcp_browser_profiles.skyvern_browser_profile_create(+ name="Workflow profile",+ workflow_run_id="wr_123",+ )++ assert result["ok"] is True+ fake_skyvern.create_browser_profile.assert_awaited_once_with(+ name="Workflow profile",+ description=None,+ browser_session_id=None,+ workflow_run_id="wr_123",+ )+++async def test_browser_profile_create_rejects_missing_source() -> None:+ result = await mcp_browser_profiles.skyvern_browser_profile_create(name="No source")++ assert result["ok"] is False+ assert result["error"]["code"] == "INVALID_INPUT"+ assert "timing_ms" in result+++async def test_browser_profile_create_rejects_multiple_sources() -> None:+ result = await mcp_browser_profiles.skyvern_browser_profile_create(+ name="Too many sources",+ browser_session_id="pbs_123",+ workflow_run_id="wr_123",+ )++ assert result["ok"] is False+ assert result["error"]["code"] == "INVALID_INPUT"+++async def test_browser_profile_list_forwards_filters(monkeypatch: pytest.MonkeyPatch) -> None:+ fake_skyvern = MagicMock()+ fake_skyvern.list_browser_profiles = AsyncMock(return_value=[_profile("bp_1"), _profile("bp_2")])+ monkeypatch.setattr(mcp_browser_profiles, "get_skyvern", lambda: fake_skyvern)++ result = await mcp_browser_profiles.skyvern_browser_profile_list(+ page=2,+ page_size=10,+ include_deleted=True,+ search_key="login",+ )++ assert result["ok"] is True+ assert result["data"]["count"] == 2+ assert [profile["browser_profile_id"] for profile in result["data"]["profiles"]] == ["bp_1", "bp_2"]+ fake_skyvern.list_browser_profiles.assert_awaited_once_with(+ page=2,+ page_size=10,+ include_deleted=True,+ search_key="login",+ )+++async def test_browser_profile_get_update_delete(monkeypatch: pytest.MonkeyPatch) -> None:+ fake_skyvern = MagicMock()+ fake_skyvern.get_browser_profile = AsyncMock(return_value=_profile())+ fake_skyvern.update_browser_profile = AsyncMock(return_value=_profile())+ fake_skyvern.delete_browser_profile = AsyncMock(return_value=None)+ monkeypatch.setattr(mcp_browser_profiles, "get_skyvern", lambda: fake_skyvern)++ get_result = await mcp_browser_profiles.skyvern_browser_profile_get("bp_123")+ update_result = await mcp_browser_profiles.skyvern_browser_profile_update(+ "bp_123",+ name="Renamed",+ description="Updated",+ )+ delete_result = await mcp_browser_profiles.skyvern_browser_profile_delete("bp_123")++ assert get_result["ok"] is True+ assert update_result["ok"] is True+ assert delete_result["data"] == {"browser_profile_id": "bp_123", "deleted": True}+ fake_skyvern.get_browser_profile.assert_awaited_once_with("bp_123")+ fake_skyvern.update_browser_profile.assert_awaited_once_with(+ "bp_123",+ name="Renamed",+ description="Updated",+ )+ fake_skyvern.delete_browser_profile.assert_awaited_once_with("bp_123")+++async def test_browser_profile_update_rejects_empty_update() -> None:+ result = await mcp_browser_profiles.skyvern_browser_profile_update("bp_123")++ assert result["ok"] is False+ assert result["error"]["code"] == "INVALID_INPUT"+++def test_browser_profile_tools_are_exported() -> None:+ assert skyvern_browser_profile_create is mcp_browser_profiles.skyvern_browser_profile_creatediff --git a/tests/unit/test_mcp_session_lifecycle.py b/tests/unit/test_mcp_session_lifecycle.pyindex 4eaf19a44..d4d69e18b 100644--- a/tests/unit/test_mcp_session_lifecycle.py+++ b/tests/unit/test_mcp_session_lifecycle.py@@ -7,7 +7,7 @@ from unittest.mock import AsyncMock, MagicMockimport pytestfrom skyvern.cli.core import client as client_mod-from skyvern.cli.core import session_manager+from skyvern.cli.core import session_manager, session_opsfrom skyvern.cli.core.result import BrowserContextfrom skyvern.cli.core.session_ops import SessionCloseResult, coerce_proxy_locationfrom skyvern.cli.mcp_tools import session as mcp_session@@ -541,6 +541,87 @@ async def test_session_close_matching_context_without_browser_returns_error(assert mcp_session.get_current_session().context is None+async def test_session_close_without_id_closes_cloud_session_via_api_first(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ """A no-arg close of the current cloud session must close via the API before tearing down the+ local CDP context, so the server snapshots session-only cookies (login state) into the exported+ profile while the shared context is still alive."""+ call_order: list[str] = []++ current_browser = MagicMock()+ current_browser._browser_session_id = "pbs_noarg"++ async def _browser_close(*args: object, **kwargs: object) -> None:+ call_order.append("browser_close")++ current_browser.close = AsyncMock(side_effect=_browser_close)+ mcp_session.set_current_session(+ mcp_session.SessionState(+ browser=current_browser,+ context=BrowserContext(mode="cloud_session", session_id="pbs_noarg"),+ )+ )++ fake_skyvern = MagicMock()+ monkeypatch.setattr(session_manager, "get_skyvern", lambda: fake_skyvern)++ async def _api_close(skyvern: object, session_id: str) -> SessionCloseResult:+ call_order.append("api_close")+ return SessionCloseResult(session_id=session_id, closed=True)++ do_session_close = AsyncMock(side_effect=_api_close)+ monkeypatch.setattr("skyvern.cli.core.session_ops.do_session_close", do_session_close)++ result = await mcp_session.skyvern_browser_session_close()++ assert result["ok"] is True+ assert result["data"] == {"session_id": "pbs_noarg", "closed": True}+ do_session_close.assert_awaited_once_with(fake_skyvern, "pbs_noarg")+ current_browser.close.assert_awaited_once()+ assert call_order == ["api_close", "browser_close"]+ # SkyvernBrowser.close() must not fire a second, redundant API close.+ assert current_browser._browser_session_id is None+ assert mcp_session.get_current_session().browser is None+++async def test_session_close_without_id_is_best_effort_when_api_close_fails(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ """A no-arg close is best-effort cleanup: a failed server-side close is logged and swallowed, the+ local browser is still torn down, and state is cleared. Pinning this keeps the swallow a deliberate+ contract (matching the CLI close path) rather than an accident, and documents that the redundant-+ close suppression only applies once the API close has succeeded."""+ current_browser = MagicMock()+ current_browser._browser_session_id = "pbs_beff"+ current_browser.close = AsyncMock()+ mcp_session.set_current_session(+ mcp_session.SessionState(+ browser=current_browser,+ context=BrowserContext(mode="cloud_session", session_id="pbs_beff"),+ )+ )++ fake_skyvern = MagicMock()+ monkeypatch.setattr(session_manager, "get_skyvern", lambda: fake_skyvern)++ do_session_close = AsyncMock(side_effect=ConnectionError("API close failed"))+ monkeypatch.setattr("skyvern.cli.core.session_ops.do_session_close", do_session_close)++ result = await mcp_session.skyvern_browser_session_close()++ assert result["ok"] is True+ assert result["data"] == {"session_id": "pbs_beff", "closed": True}+ do_session_close.assert_awaited_once_with(fake_skyvern, "pbs_beff")+ current_browser.close.assert_awaited_once()+ # The API close failed before the suppression line ran, so _browser_session_id stays set and+ # SkyvernBrowser.close() retries the server close on the real object.+ assert current_browser._browser_session_id == "pbs_beff"+ assert mcp_session.get_current_session().browser is None++# ---------------------------------------------------------------------------# Tests for close_current_session() — cloud session API cleanup# ---------------------------------------------------------------------------@@ -723,6 +804,96 @@ async def test_session_create_stateless_mode_forwards_extensions()+async def test_session_create_stateless_mode_forwards_browser_profile_id(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ session_manager.set_stateless_http_mode(True)+ fake_skyvern = MagicMock()+ fake_skyvern.create_browser_session = AsyncMock(return_value=SimpleNamespace(browser_session_id="pbs_profile"))+ monkeypatch.setattr(mcp_session, "get_skyvern", lambda: fake_skyvern)++ try:+ result = await mcp_session.skyvern_browser_session_create(+ timeout=45,+ browser_profile_id="bp_123",+ )+ finally:+ session_manager.set_stateless_http_mode(False)++ assert result["ok"] is True+ fake_skyvern.create_browser_session.assert_awaited_once_with(+ timeout=45,+ proxy_location=None,+ browser_profile_id="bp_123",+ )+++async def test_session_create_stateless_mode_enables_browser_profile_export(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ session_manager.set_stateless_http_mode(True)+ fake_skyvern = MagicMock()+ fake_skyvern.create_browser_session = AsyncMock(return_value=SimpleNamespace(browser_session_id="pbs_profile"))+ arm_generate_browser_profile = AsyncMock()+ monkeypatch.setattr(mcp_session, "get_skyvern", lambda: fake_skyvern)+ monkeypatch.setattr(+ mcp_session,+ "do_session_arm_generate_browser_profile",+ arm_generate_browser_profile,+ )++ try:+ result = await mcp_session.skyvern_browser_session_create(+ timeout=45,+ generate_browser_profile=True,+ )+ finally:+ session_manager.set_stateless_http_mode(False)++ assert result["ok"] is True+ assert result["data"] == {+ "session_id": "pbs_profile",+ "timeout_minutes": 45,+ "generate_browser_profile": True,+ }+ arm_generate_browser_profile.assert_awaited_once_with(fake_skyvern, "pbs_profile")+++async def test_session_create_stateless_mode_rolls_back_on_browser_profile_export_patch_failure(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ session_manager.set_stateless_http_mode(True)+ fake_skyvern = MagicMock()+ fake_skyvern.create_browser_session = AsyncMock(return_value=SimpleNamespace(browser_session_id="pbs_profile"))+ fake_skyvern.close_browser_session = AsyncMock()+ update_generate_browser_profile = AsyncMock(side_effect=RuntimeError("PATCH failed"))+ monkeypatch.setattr(mcp_session, "get_skyvern", lambda: fake_skyvern)+ monkeypatch.setattr(+ session_ops,+ "do_session_update_generate_browser_profile",+ update_generate_browser_profile,+ )++ try:+ result = await mcp_session.skyvern_browser_session_create(+ timeout=45,+ generate_browser_profile=True,+ )+ finally:+ session_manager.set_stateless_http_mode(False)++ assert result["ok"] is False+ assert result["error"]["code"] == mcp_session.ErrorCode.SDK_ERROR+ assert "PATCH failed" in result["error"]["message"]+ update_generate_browser_profile.assert_awaited_once_with(fake_skyvern, "pbs_profile", True)+ fake_skyvern.close_browser_session.assert_awaited_once_with("pbs_profile")+ assert mcp_session.get_current_session().browser is None+ assert mcp_session.get_current_session().context is None++@pytest.mark.asyncioasync def test_session_create_stateless_mode_rejects_local() -> None:session_manager.set_stateless_http_mode(True)@@ -735,6 +906,22 @@ async def test_session_create_stateless_mode_rejects_local() -> None:assert result["error"]["code"] == mcp_session.ErrorCode.INVALID_INPUT+async def test_session_create_cdp_connect_rejects_profile_options(monkeypatch: pytest.MonkeyPatch) -> None:+ monkeypatch.setenv("BROWSER_TYPE", "cdp-connect")+ resolve_browser = AsyncMock()+ monkeypatch.setattr(mcp_session, "resolve_browser", resolve_browser)++ profile_result = await mcp_session.skyvern_browser_session_create(browser_profile_id="bp_123")+ generate_result = await mcp_session.skyvern_browser_session_create(generate_browser_profile=True)++ assert profile_result["ok"] is False+ assert profile_result["error"]["code"] == mcp_session.ErrorCode.INVALID_INPUT+ assert generate_result["ok"] is False+ assert generate_result["error"]["code"] == mcp_session.ErrorCode.INVALID_INPUT+ resolve_browser.assert_not_awaited()++@pytest.mark.asyncioasync def test_session_create_forwards_extensions_to_stateful_session_create(monkeypatch: pytest.MonkeyPatch,@@ -762,6 +949,77 @@ async def test_session_create_forwards_extensions_to_stateful_session_create(timeout=60,proxy_location=None,extensions=[CAPTCHA_SOLVER_EXTENSION],+ browser_profile_id=None,+ generate_browser_profile=False,+ local=False,+ headless=False,+ )+++async def test_session_create_forwards_browser_profile_id_to_stateful_session_create(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ fake_skyvern = MagicMock()+ monkeypatch.setattr(mcp_session, "get_skyvern", lambda: fake_skyvern)++ fake_browser = MagicMock()+ do_session_create = AsyncMock(+ return_value=(+ fake_browser,+ SimpleNamespace(local=False, session_id="pbs_profile", timeout_minutes=60, headless=False),+ )+ )+ monkeypatch.setattr(mcp_session, "do_session_create", do_session_create)++ result = await mcp_session.skyvern_browser_session_create(+ timeout=60,+ browser_profile_id="bp_123",+ )++ assert result["ok"] is True+ do_session_create.assert_awaited_once_with(+ fake_skyvern,+ timeout=60,+ proxy_location=None,+ extensions=None,+ browser_profile_id="bp_123",+ generate_browser_profile=False,+ local=False,+ headless=False,+ )+++async def test_session_create_forwards_generate_browser_profile_to_stateful_session_create(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ fake_skyvern = MagicMock()+ monkeypatch.setattr(mcp_session, "get_skyvern", lambda: fake_skyvern)++ fake_browser = MagicMock()+ do_session_create = AsyncMock(+ return_value=(+ fake_browser,+ SimpleNamespace(local=False, session_id="pbs_profile", timeout_minutes=60, headless=False),+ )+ )+ monkeypatch.setattr(mcp_session, "do_session_create", do_session_create)++ result = await mcp_session.skyvern_browser_session_create(+ timeout=60,+ generate_browser_profile=True,+ )++ assert result["ok"] is True+ assert result["data"]["generate_browser_profile"] is True+ do_session_create.assert_awaited_once_with(+ fake_skyvern,+ timeout=60,+ proxy_location=None,+ extensions=None,+ browser_profile_id=None,+ generate_browser_profile=True,local=False,headless=False,)diff --git a/tests/unit/test_sdk_run_metadata.py b/tests/unit/test_sdk_run_metadata.pyindex 11e7a2e93..5fb1517db 100644--- a/tests/unit/test_sdk_run_metadata.py+++ b/tests/unit/test_sdk_run_metadata.py@@ -1,11 +1,14 @@import jsonfrom datetime import UTC, datetime+from types import SimpleNamespace+from unittest.mock import AsyncMockimport httpximport pytestfrom skyvern.client import AsyncSkyvern, Skyvernfrom skyvern.client.types.workflow_run_request_output import WorkflowRunRequestOutput as WorkflowRunRequest+from skyvern.library.skyvern import Skyvern as LibrarySkyverndef test_workflow_run_request_accepts_run_metadata() -> None:@@ -20,6 +23,29 @@ def test_workflow_run_request_accepts_max_elapsed_time() -> None:assert request.max_elapsed_time_minutes == 10+async def test_launch_cloud_browser_sends_browser_profile_id(monkeypatch: pytest.MonkeyPatch) -> None:+ client = LibrarySkyvern(base_url="https://api.example.test", api_key="test-key")+ browser_session = SimpleNamespace(browser_session_id="pbs_123", app_url=None)+ browser = object()+ create_browser_session = AsyncMock(return_value=browser_session)+ connect_to_session = AsyncMock(return_value=browser)++ monkeypatch.setattr(client, "_ensure_cloud_environment", lambda: None)+ monkeypatch.setattr(client, "create_browser_session", create_browser_session)+ monkeypatch.setattr(client, "_connect_to_cloud_browser_session", connect_to_session)++ result = await client.launch_cloud_browser(timeout=30, browser_profile_id="bp_123")++ assert result is browser+ create_browser_session.assert_awaited_once_with(+ timeout=30,+ proxy_location=None,+ browser_profile_id="bp_123",+ )+ connect_to_session.assert_awaited_once_with(browser_session)++def test_run_workflow_sends_run_metadata() -> None:captured_bodies: list[dict[str, object]] = []