Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
Classify job-recipe bot checks separately from login failures (SKY-18228) (#8946)
Aaron Perez2d274fcf0c10
diff --git a/skyvern/core/script_generations/script_skyvern_page.py b/skyvern/core/script_generations/script_skyvern_page.pyindex 673732615..01004ca1a 100644--- a/skyvern/core/script_generations/script_skyvern_page.py+++ b/skyvern/core/script_generations/script_skyvern_page.py@@ -1218,6 +1218,7 @@ class ScriptSkyvernPage(SkyvernPage):# Retry logic matching agent mode (real_browser_state.navigate_to_url)last_error: Exception | None = None+ _get_scraped_page(self)._browser_state.begin_navigation()for attempt in range(max_retries):# Origin-authority policy runs before the network-touching SSRF/DNS check below, so a# blocked origin fails closed with ActionPolicyBlocked instead of an unrelated DNS error.@@ -1225,6 +1226,7 @@ class ScriptSkyvernPage(SkyvernPage):url = await asyncio.to_thread(validate_fetch_url, url)try:await _get_raw_page(self).goto(url, timeout=timeout, **kwargs)+ await _get_scraped_page(self)._browser_state.record_navigation_result(None, url=url)except Exception as e:last_error = e# A timed-out navigation may still commit; refresh before the next policy check.@@ -1253,6 +1255,7 @@ class ScriptSkyvernPage(SkyvernPage):if last_error is None:raise RuntimeError("Navigation failed but no error was captured")+ await _get_scraped_page(self)._browser_state.record_navigation_result(last_error)raise last_errorasync def magic_link(diff --git a/skyvern/forge/agent_functions.py b/skyvern/forge/agent_functions.pyindex f2720b10a..ba1b6be1d 100644--- a/skyvern/forge/agent_functions.py+++ b/skyvern/forge/agent_functions.py@@ -1080,6 +1080,26 @@ class AgentFunction:"""return None+ async def record_server_assigned_address_navigation_failure(+ self,+ *,+ browser_address: str,+ nav_error_code: str | None,+ run_id: str | None,+ workflow_permanent_id: str | None = None,+ ) -> None:+ """Report a failed navigation on a browser address this deployment assigned to the run."""+ return None++ async def record_server_assigned_address_navigation_success(+ self,+ *,+ browser_address: str,+ run_id: str | None,+ ) -> None:+ """Clear navigation-failure strikes after a server-assigned browser address navigates."""+ return None+async def capture_workflow_run_created(self,*,diff --git a/skyvern/services/task_v2_service.py b/skyvern/services/task_v2_service.pyindex aafe9b68c..6b74c5f03 100644--- a/skyvern/services/task_v2_service.py+++ b/skyvern/services/task_v2_service.py@@ -988,9 +988,12 @@ async def run_task_v2_helper(# Page failed to load properly, fallback to Googleif page:try:+ browser_state.begin_navigation()await page.goto(fallback_url, timeout=settings.BROWSER_LOADING_TIMEOUT_MS)+ await browser_state.record_navigation_result(None, url=fallback_url)should_fallback = True- except Exception:+ except Exception as navigation_error:+ await browser_state.record_navigation_result(navigation_error)LOG.exception("Failed to load Google fallback", exc_info=True, url=url, current_url=current_url)skip_completion_check_after_navigate_enabled = await planner_levers.skip_completion_check_after_navigate(diff --git a/skyvern/webeye/browser_state.py b/skyvern/webeye/browser_state.pyindex af9241a89..7a7ce4c5c 100644--- a/skyvern/webeye/browser_state.py+++ b/skyvern/webeye/browser_state.py@@ -118,6 +118,10 @@ class BrowserState(Protocol):wait_until: Literal["load", "domcontentloaded", "commit"] = "load",) -> None: ...+ def begin_navigation(self) -> None: ...++ async def record_navigation_result(self, error: BaseException | None, url: str | None = None) -> None: ...+async def get_or_create_page(self,url: str | None = None,@@ -132,6 +136,7 @@ class BrowserState(Protocol):browser_address: str | None = None,browser_profile_id: str | None = None,browser_session_id: str | None = None,+ navigation_run_id: str | None = None,) -> Page: ...async def list_valid_pages(self, max_pages: int = settings.BROWSER_MAX_PAGES_NUMBER) -> list[Page]: ...diff --git a/skyvern/webeye/cdp_download_interceptor.py b/skyvern/webeye/cdp_download_interceptor.pyindex e59221b7c..18ba4cf9a 100644--- a/skyvern/webeye/cdp_download_interceptor.py+++ b/skyvern/webeye/cdp_download_interceptor.py@@ -925,6 +925,8 @@ class CDPDownloadInterceptor:# Track auth attempts per requestId to prevent infinite retry loops# when proxy credentials are rejected (407 → ProvideCredentials → 407 → …)self._auth_attempts: dict[str, int] = {}+ self._auth_challenge_seen = False+ self._proxy_auth_rejection_seen = False# Track URLs already downloaded (dedup between Fetch interception and browser download monitor)self._downloaded_urls: set[str] = set()self._artifact_scope_lock = threading.Lock()@@ -1253,6 +1255,12 @@ class CDPDownloadInterceptor:return self._proxy_username, self._proxy_passwordreturn None+ def consume_navigation_auth_challenges(self) -> tuple[bool, bool]:+ challenges = (self._proxy_auth_rejection_seen, self._auth_challenge_seen)+ self._proxy_auth_rejection_seen = False+ self._auth_challenge_seen = False+ return challenges+def rebind_download_scope(self,*,@@ -2525,6 +2533,7 @@ class CDPDownloadInterceptor:request_id = event.get("requestId")source = ""request_origin = "<unknown>"+ self._auth_challenge_seen = Truetry:# Reduce a present request URL to its origin first: a malformed ``authChallenge`` (null) raises@@ -2561,6 +2570,8 @@ class CDPDownloadInterceptor:else:# Clean up attempt tracking for this requestself._auth_attempts.pop(request_id, None)+ if source == "Proxy" and self._proxy_username and self._proxy_password and attempts >= 1:+ self._proxy_auth_rejection_seen = Trueif attempts >= 1:LOG.warning("CDP proxy auth credentials rejected, cancelling to prevent retry loop",diff --git a/skyvern/webeye/real_browser_manager.py b/skyvern/webeye/real_browser_manager.pyindex ec899fd84..2079ff9b9 100644--- a/skyvern/webeye/real_browser_manager.py+++ b/skyvern/webeye/real_browser_manager.py@@ -1213,6 +1213,8 @@ class RealBrowserManager(BrowserManager):extra_http_headers=extra_http_headers,cdp_connect_headers=task.cdp_connect_headers,browser_address=task.browser_address,+ # Keep quarantine deduplication on the workflow run without changing browser-context scoping.+ navigation_run_id=task.workflow_run_id or task.task_id,browser_session_id=browser_session_id,)await self._start_frame_publisher(diff --git a/skyvern/webeye/real_browser_state.py b/skyvern/webeye/real_browser_state.pyindex 9ef23958c..660f5e3cf 100644--- a/skyvern/webeye/real_browser_state.py+++ b/skyvern/webeye/real_browser_state.py@@ -67,7 +67,7 @@ from skyvern.webeye.driver_connection import (driver_transport_error_future,kill_driver_process,)-from skyvern.webeye.navigation import is_permanent_navigation_error, navigate_with_retry+from skyvern.webeye.navigation import driver_nav_error_code, is_permanent_navigation_error, navigate_with_retryfrom skyvern.webeye.scraper import scraperfrom skyvern.webeye.scraper.scraped_page import CleanupElementTreeFunc, ScrapedPage, ScrapeExcludeFuncfrom skyvern.webeye.session_cookies import persist_session_cookies@@ -78,6 +78,7 @@ LOG = structlog.get_logger()SETTLE_TIME_MS = 750SETTLE_JITTER_MS = 500RECOVERABLE_BLANK_PAGE_URLS = {":"}+BROWSER_ADDRESS_RESULT_TIMEOUT_SECONDS = 0.5class _BrowserConnectionProbeFailed(str):@@ -216,6 +217,8 @@ class RealBrowserState(BrowserState):weakref.WeakKeyDictionary())self.__page = page+ self._browser_address: str | None = None+ self._navigation_run_id: str | None = None# An explicitly selected tab (set by NEW_TAB/SWITCH_TAB). When set, it overrides the# last-page default in get_working_page so multi-tab targeting is deterministic.self.__active_page: Page | None = None@@ -648,6 +651,67 @@ class RealBrowserState(BrowserState):# No initial navigation ran (page already existed, or no/same URL): arm now that a working page exists.self._arm_display_recorder()+ def begin_navigation(self) -> None:+ browser_context = getattr(self, "_browser_context", None)+ interceptor = getattr(browser_context, "_skyvern_cdp_download_interceptor", None)+ consume_auth_challenges = getattr(interceptor, "consume_navigation_auth_challenges", None)+ if consume_auth_challenges is not None:+ consume_auth_challenges()++ async def record_navigation_result(self, error: BaseException | None, url: str | None = None) -> None:+ browser_context = getattr(self, "_browser_context", None)+ interceptor = getattr(browser_context, "_skyvern_cdp_download_interceptor", None)+ consume_auth_challenges = getattr(interceptor, "consume_navigation_auth_challenges", None)+ proxy_auth_rejection_seen, auth_challenge_seen = (+ consume_auth_challenges() if consume_auth_challenges is not None else (False, False)+ )+ context = skyvern_context.current()+ browser_address = getattr(self, "_browser_address", None)+ if not browser_address or context is None or not context.browser_address_is_server_assigned:+ return++ run_id = (+ context.workflow_run_id or getattr(self, "_navigation_run_id", None) or context.task_id or context.run_id+ )+ try:+ if error is None:+ if (+ url is not None+ and urlparse(url).scheme.lower() in {"http", "https"}+ and getattr(interceptor, "proxy_auth_credentials", None)+ ):+ await asyncio.wait_for(+ app.AGENT_FUNCTION.record_server_assigned_address_navigation_success(+ browser_address=browser_address,+ run_id=run_id,+ ),+ timeout=BROWSER_ADDRESS_RESULT_TIMEOUT_SECONDS,+ )+ else:+ if not getattr(interceptor, "proxy_auth_credentials", None) or (+ auth_challenge_seen and not proxy_auth_rejection_seen+ ):+ return+ nav_error_code = (+ error.nav_error_code+ if isinstance(error, FailedToNavigateToUrl)+ else driver_nav_error_code(str(error))+ )+ await asyncio.wait_for(+ app.AGENT_FUNCTION.record_server_assigned_address_navigation_failure(+ browser_address=browser_address,+ nav_error_code=nav_error_code,+ run_id=run_id,+ workflow_permanent_id=context.workflow_permanent_id,+ ),+ timeout=BROWSER_ADDRESS_RESULT_TIMEOUT_SECONDS,+ )+ except Exception:+ LOG.warning(+ "Failed to record a navigation result against the run's assigned browser address",+ exc_info=True,+ )+def _arm_display_recorder(self) -> None:"""Begin the whole-display recorder's timeline once a working page exists (two-phase capture,SKY-15466). Exactly-once and ownership-neutral in the recorder; a failed arm is surfaced, never raised."""@@ -685,14 +749,20 @@ class RealBrowserState(BrowserState):landed_url = response_url if isinstance(response_url, str) else Nonereturn response- self.last_navigation_status = await navigate_with_retry(- navigate=goto,- url=url,- retry_times=retry_times,- settle=self._wait_for_settle,- wait_until=wait_until,- )+ self.begin_navigation()+ try:+ self.last_navigation_status = await navigate_with_retry(+ navigate=goto,+ url=url,+ retry_times=retry_times,+ settle=self._wait_for_settle,+ wait_until=wait_until,+ )+ except Exception as navigation_error:+ await self.record_navigation_result(navigation_error)+ raiseself.last_navigation_url = landed_url+ await self.record_navigation_result(None, url=url)await self._wait_for_challenge_solver(page=page)async def _wait_for_challenge_solver(self, page: Page) -> None:@@ -836,7 +906,12 @@ class RealBrowserState(BrowserState):browser_address: str | None = None,browser_profile_id: str | None = None,browser_session_id: str | None = None,+ navigation_run_id: str | None = None,) -> Page:+ if browser_address is not None:+ self._browser_address = browser_address+ if navigation_run_id or workflow_run_id or task_id:+ self._navigation_run_id = navigation_run_id or workflow_run_id or task_idpage = await self.get_working_page()if page is not None:return pagediff --git a/tests/unit/test_cdp_download_interceptor.py b/tests/unit/test_cdp_download_interceptor.pyindex ab84b64fb..04bb490e1 100644--- a/tests/unit/test_cdp_download_interceptor.py+++ b/tests/unit/test_cdp_download_interceptor.py@@ -1472,6 +1472,7 @@ class TestCDPDownloadInterceptorProxyAuth:},},)+ assert interceptor.consume_navigation_auth_challenges() == (False, True)@pytest.mark.asyncioasync def test_non_proxy_auth_cancels(self) -> None:@@ -1494,6 +1495,7 @@ class TestCDPDownloadInterceptorProxyAuth:"authChallengeResponse": {"response": "CancelAuth"},},)+ assert interceptor.consume_navigation_auth_challenges() == (False, True)@pytest.mark.asyncioasync def test_no_credentials_cancels_proxy_auth(self) -> None:@@ -2271,6 +2273,8 @@ class TestCDPDownloadInterceptorProxyAuth:await interceptor._handle_auth_required(event, cdp_session)second_call = cdp_session.send.call_argsassert second_call.args[1]["authChallengeResponse"]["response"] == "CancelAuth"+ assert interceptor.consume_navigation_auth_challenges() == (True, True)+ assert interceptor.consume_navigation_auth_challenges() == (False, False)@pytest.mark.asyncioasync def test_proxy_auth_success_log_redacts_url_and_credentials(self) -> None:diff --git a/tests/unit/test_real_browser_manager.py b/tests/unit/test_real_browser_manager.pyindex 3e3c5c961..306f05092 100644--- a/tests/unit/test_real_browser_manager.py+++ b/tests/unit/test_real_browser_manager.py@@ -1124,7 +1124,7 @@ async def test_task_does_not_cache_a_browser_rejected_by_terminal_session() -> N@pytest.mark.asyncioasync def test_task_browser_inherits_session_proxy_pin_when_no_browser_state() -> None:manager = RealBrowserManager()- task = make_task("tsk_1", proxy_location="RESIDENTIAL")+ task = make_task("tsk_1", proxy_location="RESIDENTIAL", workflow_run_id="wr_1")task.extra_http_headers = {"X-Test": "1"}new_browser_state = MagicMock()new_browser_state.get_or_create_page = AsyncMock()@@ -1148,6 +1148,8 @@ async def test_task_browser_inherits_session_proxy_pin_when_no_browser_state() -assert mock_create.await_args.kwargs["extra_http_headers"] == expected_headersassert new_browser_state.get_or_create_page.await_args.kwargs["extra_http_headers"] == expected_headersassert new_browser_state.get_or_create_page.await_args.kwargs["browser_session_id"] == "pbs_123"+ assert new_browser_state.get_or_create_page.await_args.kwargs["navigation_run_id"] == "wr_1"+ assert "workflow_run_id" not in new_browser_state.get_or_create_page.await_args.kwargsassert task.extra_http_headers == {"X-Test": "1"}diff --git a/tests/unit/test_real_browser_state_navigate.py b/tests/unit/test_real_browser_state_navigate.pyindex 2949f21d0..4c8d48e4d 100644--- a/tests/unit/test_real_browser_state_navigate.py+++ b/tests/unit/test_real_browser_state_navigate.py@@ -4,6 +4,7 @@ Covers SKY-8818: pages whose subresources never finish loading must stillsucceed if the DOM has parsed, via progressive wait_until degradation."""+import asyncioimport socketimport threadingfrom functools import partial@@ -17,7 +18,10 @@ from skyvern.config import settingsfrom skyvern.exceptions import BlockedNavigationDestination, FailedToNavigateToUrlfrom skyvern.forge import agent as agent_modulefrom skyvern.forge.agent import ForgeAgent+from skyvern.forge.sdk.core import skyvern_context+from skyvern.forge.sdk.core.skyvern_context import SkyvernContextfrom skyvern.webeye import real_browser_state+from skyvern.webeye.cdp_download_interceptor import CDPDownloadInterceptorfrom skyvern.webeye.navigation import navigate_with_retryfrom skyvern.webeye.real_browser_state import RealBrowserState, _same_page_ignoring_fragment@@ -45,6 +49,15 @@ def _instant_sleep(monkeypatch: pytest.MonkeyPatch) -> None:monkeypatch.setattr("skyvern.utils.url_validators.socket.getaddrinfo", resolves_public)+def _navigation_interceptor(proxy_auth_configured: bool) -> CDPDownloadInterceptor:+ return CDPDownloadInterceptor(+ proxy_username="user" if proxy_auth_configured else None,+ proxy_password="password" if proxy_auth_configured else None,+ network_egress_monitor=MagicMock(),+ redirect_hop_authorizer=MagicMock(),+ )++def test_same_page_ignoring_fragment_matches_fragment_only_differences() -> None:assert _same_page_ignoring_fragment("https://example.test/results#section", "https://example.test/results") is Trueassert _same_page_ignoring_fragment("https://example.test/results/", "https://example.test/results") is True@@ -388,3 +401,192 @@ async def test_navigate_to_url_succeeds_on_first_try_with_default_load()assert calls == ["load"]+++ ("server_assigned", "proxy_auth_configured", "challenge_sources", "expected_reports"),+ [+ (True, True, None, 1),+ (True, True, ("Proxy",), 0),+ (True, True, ("Proxy", "Proxy"), 1),+ (True, True, ("Proxy", "Server"), 0),+ (True, True, ("Server",), 0),+ (True, False, None, 0),+ (False, True, ("Proxy", "Proxy"), 0),+ ],+)+async def test_navigation_failure_is_reported_only_for_authenticated_server_assigned_address(+ browser_state: RealBrowserState,+ monkeypatch: pytest.MonkeyPatch,+ server_assigned: bool,+ proxy_auth_configured: bool,+ challenge_sources: tuple[str, ...] | None,+ expected_reports: int,+) -> None:+ """Count proxy rejections or missing challenges, not successful proxy or target-site auth."""+ report = AsyncMock()+ monkeypatch.setattr(agent_module.app.AGENT_FUNCTION, "record_server_assigned_address_navigation_failure", report)+ browser_state._browser_address = "http://10.0.36.234:9225"+ interceptor = _navigation_interceptor(proxy_auth_configured)+ browser_state._browser_context = SimpleNamespace(+ _skyvern_cdp_download_interceptor=interceptor,+ )+ browser_state.begin_navigation()+ if challenge_sources is not None:+ cdp_session = MagicMock()+ cdp_session.send = AsyncMock()+ for source in challenge_sources:+ await interceptor._handle_auth_required(+ {+ "requestId": f"request-{source}",+ "authChallenge": {"source": source},+ "request": {"url": "https://example.test/"},+ },+ cdp_session,+ )+ skyvern_context.set(+ SkyvernContext(+ workflow_run_id="wr_1",+ task_id="task_1",+ workflow_permanent_id="workflow_1",+ browser_address_is_server_assigned=server_assigned,+ ),+ )+ try:+ await browser_state.record_navigation_result(+ FailedToNavigateToUrl(+ url="https://example.test/",+ error_message="Page.goto: net::ERR_INVALID_AUTH_CREDENTIALS at https://example.test/",+ nav_error_code="net::ERR_INVALID_AUTH_CREDENTIALS",+ )+ )+ finally:+ skyvern_context.reset()++ assert report.await_count == expected_reports+ if expected_reports:+ assert report.await_args.kwargs == {+ "browser_address": "http://10.0.36.234:9225",+ "nav_error_code": "net::ERR_INVALID_AUTH_CREDENTIALS",+ "run_id": "wr_1",+ "workflow_permanent_id": "workflow_1",+ }++[email protected]("proxy_auth_configured", [True, False])+async def test_success_clears_strikes_only_for_authenticated_server_assigned_address(+ browser_state: RealBrowserState,+ monkeypatch: pytest.MonkeyPatch,+ proxy_auth_configured: bool,+) -> None:+ report = AsyncMock()+ monkeypatch.setattr(agent_module.app.AGENT_FUNCTION, "record_server_assigned_address_navigation_success", report)+ browser_state._browser_address = "http://10.0.36.234:9225"+ interceptor = _navigation_interceptor(proxy_auth_configured)+ browser_state._browser_context = SimpleNamespace(+ _skyvern_cdp_download_interceptor=interceptor,+ )+ skyvern_context.set(SkyvernContext(workflow_run_id="wr_1", browser_address_is_server_assigned=True))+ try:+ await browser_state.record_navigation_result(None, url="https://example.test/")+ finally:+ skyvern_context.reset()++ if proxy_auth_configured:+ report.assert_awaited_once_with(browser_address="http://10.0.36.234:9225", run_id="wr_1")+ else:+ report.assert_not_awaited()++[email protected]("url", ["about:blank", "", " "])+async def test_non_network_success_does_not_clear_strikes(+ browser_state: RealBrowserState,+ monkeypatch: pytest.MonkeyPatch,+ url: str,+) -> None:+ report = AsyncMock()+ monkeypatch.setattr(agent_module.app.AGENT_FUNCTION, "record_server_assigned_address_navigation_success", report)+ browser_state._browser_address = "http://10.0.36.234:9225"+ browser_state._browser_context = SimpleNamespace(+ _skyvern_cdp_download_interceptor=_navigation_interceptor(proxy_auth_configured=True),+ )+ skyvern_context.set(SkyvernContext(workflow_run_id="wr_1", browser_address_is_server_assigned=True))+ try:+ await browser_state.record_navigation_result(None, url=url)+ finally:+ skyvern_context.reset()++ report.assert_not_awaited()+++async def test_navigation_result_report_is_bounded(+ browser_state: RealBrowserState,+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ async def slow_report(**_: object) -> None:+ await asyncio.sleep(10)++ report = AsyncMock(side_effect=slow_report)+ monkeypatch.setattr(agent_module.app.AGENT_FUNCTION, "record_server_assigned_address_navigation_success", report)+ monkeypatch.setattr(real_browser_state, "BROWSER_ADDRESS_RESULT_TIMEOUT_SECONDS", 0.01)+ browser_state._browser_address = "http://10.0.36.234:9225"+ browser_state._browser_context = SimpleNamespace(+ _skyvern_cdp_download_interceptor=_navigation_interceptor(proxy_auth_configured=True),+ )+ skyvern_context.set(SkyvernContext(workflow_run_id="wr_1", browser_address_is_server_assigned=True))+ try:+ await browser_state.record_navigation_result(None, url="https://example.test/")+ finally:+ skyvern_context.reset()++ report.assert_awaited_once()+++async def test_deferred_navigation_keeps_server_address_and_workflow_identity(+ browser_state: RealBrowserState,+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ page = MagicMock()+ monkeypatch.setattr(browser_state, "get_working_page", AsyncMock(return_value=page))++ result = await browser_state.get_or_create_page(+ browser_address="http://10.0.36.234:9225",+ task_id="task_1",+ navigation_run_id="wr_1",+ )++ assert result is page+ assert browser_state._browser_address == "http://10.0.36.234:9225"+ assert browser_state._navigation_run_id == "wr_1"+++async def test_a_failed_report_does_not_change_how_the_run_fails(+ browser_state: RealBrowserState,+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ monkeypatch.setattr(+ agent_module.app.AGENT_FUNCTION,+ "record_server_assigned_address_navigation_failure",+ AsyncMock(side_effect=RuntimeError("redis is down")),+ )+ browser_state._browser_address = "http://10.0.36.234:9225"+ browser_state._browser_context = SimpleNamespace(+ _skyvern_cdp_download_interceptor=_navigation_interceptor(proxy_auth_configured=True),+ )+ skyvern_context.set(SkyvernContext(workflow_run_id="wr_1", browser_address_is_server_assigned=True))+ try:+ await browser_state.record_navigation_result(+ FailedToNavigateToUrl(+ url="https://example.test/",+ error_message="Page.goto: net::ERR_INVALID_AUTH_CREDENTIALS",+ nav_error_code="net::ERR_INVALID_AUTH_CREDENTIALS",+ )+ )+ finally:+ skyvern_context.reset()diff --git a/tests/unit/test_script_skyvern_page.py b/tests/unit/test_script_skyvern_page.pyindex 17859fb60..55a00ba55 100644--- a/tests/unit/test_script_skyvern_page.py+++ b/tests/unit/test_script_skyvern_page.py@@ -103,7 +103,7 @@ def _selected_engine():class _ScrapedPageStub:def __init__(self) -> None:- self._browser_state = SimpleNamespace()+ self._browser_state = SimpleNamespace(begin_navigation=MagicMock(), record_navigation_result=AsyncMock())@pytest.fixture(autouse=True)@@ -156,6 +156,24 @@ async def test_page_navigation_accepts_public_destination(page_type, mock_scrapeawait page.goto("https://93.184.216.34/path")raw_page.goto.assert_awaited_once()+ if page_type is ScriptSkyvernPage:+ mock_scraped_page._browser_state.record_navigation_result.assert_awaited_once_with(+ None,+ url="https://93.184.216.34/path",+ )+++async def test_script_page_reports_deferred_navigation_failure(mock_scraped_page, mock_ai):+ page, raw_page = _build_navigation_page(ScriptSkyvernPage, mock_scraped_page, mock_ai)+ error = RuntimeError("net::ERR_INVALID_AUTH_CREDENTIALS")+ raw_page.goto = AsyncMock(side_effect=error)++ with pytest.raises(RuntimeError, match="ERR_INVALID_AUTH_CREDENTIALS"):+ await page.goto("https://93.184.216.34/path", max_retries=1)++ mock_scraped_page._browser_state.begin_navigation.assert_called_once_with()+ mock_scraped_page._browser_state.record_navigation_result.assert_awaited_once_with(error)@pytest.mark.asyncio