Skip to content

Automate browser based workflows with AI

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.py
index 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_id
browser = 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.md
index 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__.py
index 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_bro
mcp.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.py
new file mode 100644
index 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.py
index 62c2e783b..2ec8e3a3a 100644
--- a/skyvern/cli/mcp_tools/session.py
+++ b/skyvern/cli/mcp_tools/session.py
@@ -8,13 +8,20 @@ from pydantic import Field
from skyvern.cli.core.api_key_hash import hash_api_key_for_cache
from skyvern.cli.core.client import get_active_api_key
from 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 Extensions
from skyvern.schemas.runs import proxy_location_to_request
from ._common import BrowserContext, ErrorCode, Timer, make_error, make_result
from ._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_id
session = 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.py
index 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_id
browser_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.py
index 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.asyncio
async 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.asyncio
async 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.py
new file mode 100644
index 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_create
diff --git a/tests/unit/test_mcp_session_lifecycle.py b/tests/unit/test_mcp_session_lifecycle.py
index 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, MagicMock
import pytest
from skyvern.cli.core import client as client_mod
-from skyvern.cli.core import session_manager
+from skyvern.cli.core import session_manager, session_ops
from skyvern.cli.core.result import BrowserContext
from skyvern.cli.core.session_ops import SessionCloseResult, coerce_proxy_location
from 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.asyncio
async 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.asyncio
async 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.py
index 11e7a2e93..5fb1517db 100644
--- a/tests/unit/test_sdk_run_metadata.py
+++ b/tests/unit/test_sdk_run_metadata.py
@@ -1,11 +1,14 @@
import json
from datetime import UTC, datetime
+from types import SimpleNamespace
+from unittest.mock import AsyncMock
import httpx
import pytest
from skyvern.client import AsyncSkyvern, Skyvern
from skyvern.client.types.workflow_run_request_output import WorkflowRunRequestOutput as WorkflowRunRequest
+from skyvern.library.skyvern import Skyvern as LibrarySkyvern
def 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]] = []