Skip to content

Automate browser based workflows with AI

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.py
index 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_error
async def magic_link(
diff --git a/skyvern/forge/agent_functions.py b/skyvern/forge/agent_functions.py
index 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.py
index 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 Google
if 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.py
index 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.py
index 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_password
return 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 = True
try:
# 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 request
self._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 = True
if 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.py
index 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.py
index 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_retry
from skyvern.webeye.scraper import scraper
from skyvern.webeye.scraper.scraped_page import CleanupElementTreeFunc, ScrapedPage, ScrapeExcludeFunc
from skyvern.webeye.session_cookies import persist_session_cookies
@@ -78,6 +78,7 @@ LOG = structlog.get_logger()
SETTLE_TIME_MS = 750
SETTLE_JITTER_MS = 500
RECOVERABLE_BLANK_PAGE_URLS = {":"}
+BROWSER_ADDRESS_RESULT_TIMEOUT_SECONDS = 0.5
class _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 None
return 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)
+ raise
self.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_id
page = await self.get_working_page()
if page is not None:
return page
diff --git a/tests/unit/test_cdp_download_interceptor.py b/tests/unit/test_cdp_download_interceptor.py
index 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.asyncio
async 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.asyncio
async 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_args
assert 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.asyncio
async 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.py
index 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.asyncio
async 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_headers
assert new_browser_state.get_or_create_page.await_args.kwargs["extra_http_headers"] == expected_headers
assert 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.kwargs
assert 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.py
index 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 still
succeed if the DOM has parsed, via progressive wait_until degradation.
"""
+import asyncio
import socket
import threading
from functools import partial
@@ -17,7 +18,10 @@ from skyvern.config import settings
from skyvern.exceptions import BlockedNavigationDestination, FailedToNavigateToUrl
from skyvern.forge import agent as agent_module
from skyvern.forge.agent import ForgeAgent
+from skyvern.forge.sdk.core import skyvern_context
+from skyvern.forge.sdk.core.skyvern_context import SkyvernContext
from skyvern.webeye import real_browser_state
+from skyvern.webeye.cdp_download_interceptor import CDPDownloadInterceptor
from skyvern.webeye.navigation import navigate_with_retry
from 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 True
assert _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.py
index 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_scrape
await 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