Skip to content

Automate browser based workflows with AI

Share strategy-aware typing across Copilot surfaces (#8342)

Andrew Neilsonac38bc82d163
diff --git a/skyvern/cli/mcp_tools/browser.py b/skyvern/cli/mcp_tools/browser.py
index a9003eeec..5e8df217b 100644
--- a/skyvern/cli/mcp_tools/browser.py
+++ b/skyvern/cli/mcp_tools/browser.py
@@ -77,6 +77,7 @@ from skyvern.forge.sdk.core import skyvern_context
from skyvern.schemas.action_log import ActionLogOutcome, project_action_event
from skyvern.schemas.run_blocks import CredentialType
from skyvern.utils.url_validators import validate_fetch_url
+from skyvern.webeye.actions.handler_utils import strategy_aware_input
from ._common import (
AI_FALLBACK_DESCRIPTION,
@@ -1331,80 +1332,114 @@ async def skyvern_type(
)
source_url = _trajectory_source_url(page)
- # DOM-level guard: check if the target element is a password field
- if selector:
- try:
- is_password_field = await page.evaluate(
- "(s) => { const el = document.querySelector(s); return el && el.type === 'password' }",
- selector,
- )
- except Exception as exc:
- # Selector may not be a valid CSS selector (e.g. xpath=...) or page may
- # not be ready. Fall through to the existing regex guard in that case.
- LOG.debug("DOM password check failed for selector %r: %s", selector, exc)
- is_password_field = False
- if is_password_field:
- return action_result(
- "skyvern_type",
- ok=False,
- error=make_error(
- ErrorCode.INVALID_INPUT,
- TYPE_PASSWORD_REFUSAL_MESSAGE,
- CREDENTIAL_HINT,
- ),
- )
-
clear_content = clear if clear_first is None else clear_first
deterministic = selector is not None and selector_mode == "direct"
direct_action = is_direct_action(selector, ai_mode, deterministic=deterministic)
action_timeout = resolve_action_timeout_ms(timeout, direct_action=direct_action)
skip_element_prep = selector is not None and ai_mode is None and not deterministic
+ aggregate_timeout_seconds = action_timeout / 1000 if direct_action and action_timeout > 0 else None
with Timer() as timer:
try:
- # selector_mode="direct" pins the selector with no AI fall-back. Resilient (default) and
- # intent-only calls keep AI; emitted scripts keep the selector+prompt fallback via
- # sdk_equivalent for DOM-drift resilience.
- if coordinate_target is not None:
- assert x is not None and y is not None
- await do_type_at(
- page,
- x,
- y,
- text,
- clear_first=clear_content,
- press_enter=press_enter,
- )
- elif clear_content:
- if deterministic:
- assert selector is not None
- await page.fill(selector, text, mode="direct", timeout=action_timeout)
- elif ai_mode is not None:
- await page.fill(selector=selector, value=text, prompt=intent, ai=ai_mode, timeout=action_timeout) # type: ignore[arg-type]
- else:
- assert selector is not None
- fill_kwargs: dict[str, Any] = {"timeout": action_timeout}
- if isinstance(page, SkyvernPage):
- fill_kwargs["_skip_element_prep"] = skip_element_prep
- await page.fill(selector, text, **fill_kwargs)
- else:
- kwargs: dict[str, Any] = {"timeout": action_timeout}
- if delay is not None:
- kwargs["delay"] = delay
- if deterministic:
- await page.type(selector, text, ai=None, **kwargs)
- elif ai_mode is not None:
- loc = page.locator(selector=selector, prompt=intent, ai=ai_mode) # type: ignore[arg-type]
- await loc.type(text, **kwargs)
+ async with asyncio.timeout(aggregate_timeout_seconds):
+ # DOM-level guard: inspect the same active-scope first match used by direct strategy typing.
+ scoped_first_locator = None
+ if selector:
+ try:
+ scoped_first_locator = page.locator_scope.locator(selector).first
+ is_password_field = await scoped_first_locator.evaluate(
+ "el => el.tagName === 'INPUT' && "
+ "(el.getAttribute('type') || '').toLowerCase() === 'password'"
+ )
+ except Exception as exc:
+ # Selector may be invalid or the page may not be ready. Fall through to the
+ # existing credential-intent guard in that case.
+ LOG.debug("DOM password check failed for selector %r: %s", selector, exc)
+ is_password_field = False
+ if is_password_field:
+ return action_result(
+ "skyvern_type",
+ ok=False,
+ error=make_error(
+ ErrorCode.INVALID_INPUT,
+ TYPE_PASSWORD_REFUSAL_MESSAGE,
+ CREDENTIAL_HINT,
+ ),
+ )
+
+ # selector_mode="direct" pins the selector with no AI fall-back. Resilient (default) and
+ # intent-only calls keep AI; emitted scripts keep the selector+prompt fallback via
+ # sdk_equivalent for DOM-drift resilience.
+ if coordinate_target is not None:
+ assert x is not None and y is not None
+ await do_type_at(
+ page,
+ x,
+ y,
+ text,
+ clear_first=clear_content,
+ press_enter=press_enter,
+ )
+ elif clear_content:
+ if deterministic:
+ assert selector is not None
+ locator = (
+ scoped_first_locator
+ if scoped_first_locator is not None
+ else page.locator_scope.locator(selector).first
+ )
+ await strategy_aware_input(
+ locator,
+ text,
+ clear=True,
+ timeout=action_timeout,
+ dispatch_change_and_blur=True,
+ )
+ elif ai_mode is not None:
+ assert intent is not None
+ await page.fill(
+ selector=selector,
+ value=text,
+ prompt=intent,
+ ai=ai_mode,
+ timeout=action_timeout,
+ )
+ else:
+ assert selector is not None
+ fill_kwargs: dict[str, Any] = {"timeout": action_timeout}
+ if isinstance(page, SkyvernPage):
+ fill_kwargs["_skip_element_prep"] = skip_element_prep
+ await page.fill(selector, text, **fill_kwargs)
else:
- assert selector is not None
- if isinstance(page, SkyvernPage):
- kwargs["_skip_element_prep"] = skip_element_prep
- await page.type(selector, text, **kwargs)
- if coordinate_target is None and press_enter:
- raw_page = page.page if hasattr(page, "page") else page
- await raw_page.keyboard.press("Enter")
- timer.mark("sdk")
+ kwargs: dict[str, Any] = {"timeout": action_timeout}
+ if delay is not None:
+ kwargs["delay"] = delay
+ if deterministic:
+ assert selector is not None
+ locator = (
+ scoped_first_locator
+ if scoped_first_locator is not None
+ else page.locator_scope.locator(selector).first
+ )
+ await strategy_aware_input(
+ locator,
+ text,
+ clear=False,
+ timeout=action_timeout,
+ delay=delay,
+ )
+ elif ai_mode is not None:
+ loc = page.locator(selector=selector, prompt=intent, ai=ai_mode) # type: ignore[arg-type]
+ await loc.type(text, **kwargs)
+ else:
+ assert selector is not None
+ if isinstance(page, SkyvernPage):
+ kwargs["_skip_element_prep"] = skip_element_prep
+ await page.type(selector, text, **kwargs)
+ if coordinate_target is None and press_enter:
+ raw_page = page.page if hasattr(page, "page") else page
+ await raw_page.keyboard.press("Enter")
+ timer.mark("sdk")
except GuardError as e:
return action_result(
"skyvern_type",
@@ -1413,7 +1448,9 @@ async def skyvern_type(
timing_ms=timer.timing_ms,
error=make_error(ErrorCode.INVALID_INPUT, str(e), e.hint),
)
- except PlaywrightTimeoutError as e:
+ except (TimeoutError, PlaywrightTimeoutError) as e:
+ if isinstance(e, TimeoutError):
+ e = PlaywrightTimeoutError(f"Timeout {action_timeout}ms exceeded.")
if coordinate_target is not None:
return action_result(
"skyvern_type",
diff --git a/skyvern/forge/sdk/copilot/tools/mcp_hooks.py b/skyvern/forge/sdk/copilot/tools/mcp_hooks.py
index a8f737395..a134b540b 100644
--- a/skyvern/forge/sdk/copilot/tools/mcp_hooks.py
+++ b/skyvern/forge/sdk/copilot/tools/mcp_hooks.py
@@ -1951,8 +1951,9 @@ def _build_skyvern_mcp_overlays(
),
"type_text": SchemaOverlay(
description=(
- "Type text into an input element by CSS selector. The type is instant and "
- "deterministic. Derive the selector from page evidence; if it does not resolve, "
+ "Type text into an input element with Skyvern's active input event strategy while "
+ "targeting the supplied CSS selector directly. Derive the selector from page evidence; "
+ "if it does not resolve, "
"inspect the page again and derive a better one. "
"Optionally clear the field first. Use this for form filling. "
"NEVER type inline passwords, API keys, tokens, cookies, TOTP/OTP "
diff --git a/skyvern/forge/sdk/event/base.py b/skyvern/forge/sdk/event/base.py
index 7ed41844d..9a967f575 100644
--- a/skyvern/forge/sdk/event/base.py
+++ b/skyvern/forge/sdk/event/base.py
@@ -44,12 +44,35 @@ class InputEventStrategy(ABC):
"""Strategy for dispatching keyboard input events to a page."""
@abstractmethod
- async def type_text(self, page: Page, locator: Locator | None, text: str) -> None:
- pass
+ async def type_text(
+ self,
+ page: Page,
+ locator: Locator | None,
+ text: str,
+ *,
+ timeout: float | None,
+ delay: float | None = None,
+ no_wait_after: bool | None = None,
+ allow_batched_playwright: bool = False,
+ ) -> None:
+ """Type text while preserving caller-owned Playwright input options.
+
+ ``allow_batched_playwright`` lets the plain Playwright strategy collapse the text into one
+ locator call. Strategies that emit their own humanized events may retain their cadence.
+ """
@abstractmethod
- async def clear_field(self, page: Page, locator: Locator, char_count: int) -> None:
- pass
+ async def clear_field(
+ self,
+ page: Page,
+ locator: Locator,
+ char_count: int,
+ *,
+ timeout: float | None,
+ force: bool | None = None,
+ no_wait_after: bool | None = None,
+ ) -> None:
+ """Clear a field while preserving caller-owned Playwright input options."""
class ScrollEventStrategy(ABC):
diff --git a/skyvern/forge/sdk/event/default.py b/skyvern/forge/sdk/event/default.py
index d8661bb71..ff10f4e13 100644
--- a/skyvern/forge/sdk/event/default.py
+++ b/skyvern/forge/sdk/event/default.py
@@ -44,15 +44,45 @@ class DefaultCursorStrategy(CursorEventStrategy):
class DefaultInputStrategy(InputEventStrategy):
"""Input strategy that uses plain Playwright typing."""
- async def type_text(self, page: Page, locator: Locator | None, text: str) -> None:
+ async def type_text(
+ self,
+ page: Page,
+ locator: Locator | None,
+ text: str,
+ *,
+ timeout: float | None = settings.BROWSER_ACTION_TIMEOUT_MS,
+ delay: float | None = None,
+ no_wait_after: bool | None = None,
+ allow_batched_playwright: bool = False,
+ ) -> None:
if locator is not None:
+ type_options = {"timeout": timeout, "delay": TEXT_INPUT_DELAY if delay is None else delay}
+ if no_wait_after is not None:
+ type_options["no_wait_after"] = no_wait_after
+ if allow_batched_playwright:
+ await locator.type(text, **type_options)
+ return
for char in text:
- await locator.type(char, delay=TEXT_INPUT_DELAY, timeout=settings.BROWSER_ACTION_TIMEOUT_MS)
+ await locator.type(char, **type_options)
else:
await page.keyboard.type(text)
- async def clear_field(self, page: Page, locator: Locator, char_count: int) -> None:
- await locator.clear(timeout=settings.BROWSER_ACTION_TIMEOUT_MS)
+ async def clear_field(
+ self,
+ page: Page,
+ locator: Locator,
+ char_count: int,
+ *,
+ timeout: float | None = settings.BROWSER_ACTION_TIMEOUT_MS,
+ force: bool | None = None,
+ no_wait_after: bool | None = None,
+ ) -> None:
+ clear_options: dict[str, float | bool | None] = {"timeout": timeout}
+ if force is not None:
+ clear_options["force"] = force
+ if no_wait_after is not None:
+ clear_options["no_wait_after"] = no_wait_after
+ await locator.clear(**clear_options)
class DefaultScrollStrategy(ScrollEventStrategy):
diff --git a/skyvern/forge/sdk/event/factory.py b/skyvern/forge/sdk/event/factory.py
index 22d1a5d0c..96e8f9045 100644
--- a/skyvern/forge/sdk/event/factory.py
+++ b/skyvern/forge/sdk/event/factory.py
@@ -4,6 +4,7 @@ import structlog
from opentelemetry import metrics
from playwright.async_api import Locator, Page
+from skyvern.config import settings
from skyvern.forge.sdk.event.base import CursorEventStrategy, InputEventStrategy, ScrollEventStrategy
from skyvern.forge.sdk.event.default import DefaultCursorStrategy, DefaultInputStrategy, DefaultScrollStrategy
from skyvern.forge.sdk.settings_manager import SettingsManager
@@ -144,20 +145,60 @@ class EventStrategyFactory:
# -- input convenience methods ----------------------------------------------
@staticmethod
- async def type_text(page: Page, locator: Locator | None, text: str) -> None:
- """Type text using the active input strategy."""
+ async def type_text(
+ page: Page,
+ locator: Locator | None,
+ text: str,
+ *,
+ timeout: float | None = settings.BROWSER_ACTION_TIMEOUT_MS,
+ delay: float | None = None,
+ no_wait_after: bool | None = None,
+ allow_batched_playwright: bool = False,
+ ) -> None:
+ """Type text using the active input strategy under the caller's timeout contract."""
start = time.perf_counter()
try:
- await EventStrategyFactory.get_input_strategy().type_text(page, locator, text)
+ strategy = EventStrategyFactory.get_input_strategy()
+ if delay is None and no_wait_after is None and not allow_batched_playwright:
+ await strategy.type_text(page, locator, text, timeout=timeout)
+ else:
+ await strategy.type_text(
+ page,
+ locator,
+ text,
+ timeout=timeout,
+ delay=delay,
+ no_wait_after=no_wait_after,
+ allow_batched_playwright=allow_batched_playwright,
+ )
finally:
EventStrategyFactory.__metrics.record("type_text", time.perf_counter() - start)
@staticmethod
- async def clear_field(page: Page, locator: Locator, char_count: int) -> None:
- """Clear field using the active input strategy."""
+ async def clear_field(
+ page: Page,
+ locator: Locator,
+ char_count: int,
+ *,
+ timeout: float | None = settings.BROWSER_ACTION_TIMEOUT_MS,
+ force: bool | None = None,
+ no_wait_after: bool | None = None,
+ ) -> None:
+ """Clear field using the active input strategy under the caller's timeout contract."""
start = time.perf_counter()
try:
- await EventStrategyFactory.get_input_strategy().clear_field(page, locator, char_count)
+ strategy = EventStrategyFactory.get_input_strategy()
+ if force is None and no_wait_after is None:
+ await strategy.clear_field(page, locator, char_count, timeout=timeout)
+ else:
+ await strategy.clear_field(
+ page,
+ locator,
+ char_count,
+ timeout=timeout,
+ force=force,
+ no_wait_after=no_wait_after,
+ )
finally:
EventStrategyFactory.__metrics.record("clear_field", time.perf_counter() - start)
diff --git a/skyvern/forge/sdk/workflow/models/block.py b/skyvern/forge/sdk/workflow/models/block.py
index 694bead03..05d1c0a0d 100644
--- a/skyvern/forge/sdk/workflow/models/block.py
+++ b/skyvern/forge/sdk/workflow/models/block.py
@@ -266,6 +266,7 @@ from skyvern.webeye.browser_object_predicates import is_page_like
from skyvern.webeye.browser_state import BrowserState, get_browser_state_diagnostic
from skyvern.webeye.cdp_download_interceptor import normalize_download_filename, settle_browser_downloads_for_context
from skyvern.webeye.navigation import default_navigation_settle, navigate_with_retry, redact_url_secrets
+from skyvern.webeye.playwright_input import playwright_input_defaults_for_page
from skyvern.webeye.real_browser_state import RealBrowserState
from skyvern.webeye.utils.captcha_solver import CaptchaChallengeUnsolvedError, solve_challenge_ladder
from skyvern.webeye.utils.page import SkyvernFrame
@@ -5668,10 +5669,11 @@ async def wrapper({default_args}):
# failure must fail closed — callers gate copilot-only behavior on this, and it must
# never mask a block failure.
try:
- return await app.DATABASE.workflows.is_workflow_copilot_authored(
+ copilot_authored = await app.DATABASE.workflows.is_workflow_copilot_authored(
workflow_permanent_id=workflow.workflow_permanent_id,
organization_id=workflow.organization_id,
)
+ return copilot_authored is True
except Exception:
LOG.warning(
"Copilot-lineage lookup failed; failing closed",
@@ -7021,6 +7023,8 @@ async def wrapper({default_args}):
# Every code block gets a container task v1 + step so its recorded calls render through
# the standard action/artifact timeline and are billable; on prompt-bearing blocks the
# task also seats a later agent takeover on failure.
+ strategy_aware_typing = await self._workflow_is_copilot_authored(workflow_run_context)
+ playwright_input_defaults = playwright_input_defaults_for_page(page) if strategy_aware_typing else None
recorder = CodeBlockActionRecording(
code_block=self,
page=page,
@@ -7030,6 +7034,8 @@ async def wrapper({default_args}):
workflow_run_context=workflow_run_context,
redaction_parameters=serialized_parameter_values,
credential_release_guard=credential_release_guard if credential_release_guard.is_armed else None,
+ strategy_aware_typing=strategy_aware_typing,
+ playwright_input_defaults=playwright_input_defaults,
)
if credential_release_guard.is_armed:
credential_release_guard.log_armed()
diff --git a/skyvern/forge/sdk/workflow/models/code_block_recorder.py b/skyvern/forge/sdk/workflow/models/code_block_recorder.py
index 866b20e86..ad7124b00 100644
--- a/skyvern/forge/sdk/workflow/models/code_block_recorder.py
+++ b/skyvern/forge/sdk/workflow/models/code_block_recorder.py
@@ -4,22 +4,50 @@ import asyncio
import inspect
import sys
import time
+from collections.abc import Awaitable, Callable
from dataclasses import dataclass
from os import PathLike, fspath
from types import FrameType
-from typing import Any, Awaitable, Callable
+from typing import Any, Literal, cast
import pydantic
import structlog
+from playwright.async_api import BrowserContext, Locator, Page
from skyvern.forge.sdk.db.datetime_utils import naive_utc_now
from skyvern.forge.sdk.db.id import generate_action_id
from skyvern.forge.sdk.workflow.models.credential_release import CredentialReleaseGuard
from skyvern.webeye.actions.action_types import ActionType
from skyvern.webeye.actions.actions import Action, ActionStatus, SelectOption
+from skyvern.webeye.actions.handler_utils import strategy_aware_input
+from skyvern.webeye.playwright_input import PlaywrightInputDefaults
LOG = structlog.get_logger()
+_LOCATOR_STRATEGY_INPUT_OPTIONS = frozenset({"delay", "force", "no_wait_after", "text", "timeout", "value"})
+_PAGE_STRATEGY_INPUT_OPTIONS = frozenset(
+ {"delay", "force", "no_wait_after", "selector", "strict", "text", "timeout", "value"}
+)
+
+
+def _effective_playwright_timeout(defaults: PlaywrightInputDefaults, timeout: float | None) -> float:
+ """Resolve one aggregate deadline while preserving explicit zero."""
+ return defaults.timeout_ms if timeout is None else timeout
+
+
+def _page_strategy_input_locator(
+ page: Page,
+ selector: str,
+ strict: bool | None,
+ defaults: PlaywrightInputDefaults,
+) -> Locator:
+ """Build the locator equivalent of Page.fill/type without changing context strictness."""
+ locator = page.locator(selector)
+ if strict is not None:
+ return locator if strict else locator.first
+ return locator if defaults.strict_selectors else locator.first
+
+
CODE_BLOCK_FILENAME = "<code_block>"
# full_code = "\nasync def wrapper(...):\n<user code from line 3>"; user line = frame line - 2
CODE_LINE_OFFSET = 2
@@ -300,12 +328,16 @@ class _Recorder:
on_action: OnAction | None = None,
credential_release_guard: CredentialReleaseGuard | None = None,
on_pending_action: OnPendingAction | None = None,
+ strategy_aware_typing: bool = False,
+ playwright_input_defaults: PlaywrightInputDefaults | None = None,
) -> None:
self.actions: list[Action] = []
self.last_exception: BaseException | None = None
self._on_action = on_action
self._on_pending_action = on_pending_action
self.credential_release_guard = credential_release_guard
+ self.strategy_aware_typing = strategy_aware_typing
+ self.playwright_input_defaults = playwright_input_defaults or PlaywrightInputDefaults()
def _emit_pending_action(self, pending_action: PendingAction) -> None:
if self._on_pending_action is None:
@@ -500,7 +532,42 @@ class RecordingLocator:
async def recorded(*args: Any, **kwargs: Any) -> Any:
async def call() -> Any:
+ if self.__recorder.strategy_aware_typing and name in ("fill", "type"):
+ inspect.signature(attr).bind(*args, **kwargs)
await self.__recorder.enforce_credential_release(self.__locator, f"locator.{name}", args, kwargs)
+ if (
+ self.__recorder.strategy_aware_typing
+ and name in ("fill", "type")
+ and hasattr(self.__locator, "page")
+ and kwargs.keys() <= _LOCATOR_STRATEGY_INPUT_OPTIONS
+ ):
+ value = kwargs.get("value" if name == "fill" else "text", args[0] if args else None)
+ if isinstance(value, str):
+ authored_timeout = kwargs.get("timeout")
+ if authored_timeout is None or isinstance(authored_timeout, int | float):
+ timeout = _effective_playwright_timeout(
+ self.__recorder.playwright_input_defaults,
+ authored_timeout,
+ )
+ force = kwargs.get("force")
+ delay = kwargs.get("delay")
+ no_wait_after = kwargs.get("no_wait_after")
+ if force is None and delay is None and no_wait_after is None:
+ return await strategy_aware_input(
+ self.__locator,
+ value,
+ clear=name == "fill",
+ timeout=timeout,
+ )
+ return await strategy_aware_input(
+ self.__locator,
+ value,
+ clear=name == "fill",
+ timeout=timeout,
+ force=force,
+ delay=delay,
+ no_wait_after=no_wait_after,
+ )
return await attr(*args, **kwargs)
return await self.__recorder.record(action_type, f"locator.{name}", self.__selector, call, args, kwargs)
@@ -543,12 +610,27 @@ class RecordingKeyboard:
return recorded
+class RecordingBrowserContext:
+ def __init__(self, context: BrowserContext, recorder: _Recorder) -> None:
+ self.__context = context
+ self.__recorder = recorder
+
+ def __getattr__(self, name: str) -> Any:
+ attr = getattr(self.__context, name)
+ if name != "set_default_timeout" or not callable(attr):
+ return attr
+
+ def set_default_timeout(timeout: float) -> None:
+ attr(timeout)
+ self.__recorder.playwright_input_defaults.set_context_timeout(timeout)
+
+ return set_default_timeout
+
+
class RecordingPage:
- """Proxy around a playwright page that records mapped calls as Actions.
+ """Proxy that records mapped Playwright calls as Actions.
- Name-mangled private state keeps casual user code away from recorder
- internals, but the mangled `_RecordingPage__*` form is still reachable;
- treat recordings as telemetry, not a tamper-proof audit trail.
+ Recordings are telemetry, not a tamper-proof audit trail.
"""
def __init__(
@@ -557,9 +639,17 @@ class RecordingPage:
on_action: OnAction | None = None,
credential_release_guard: CredentialReleaseGuard | None = None,
on_pending_action: OnPendingAction | None = None,
+ strategy_aware_typing: bool = False,
+ playwright_input_defaults: PlaywrightInputDefaults | None = None,
) -> None:
self.__page = page
- self.__recorder = _Recorder(on_action, credential_release_guard, on_pending_action)
+ self.__recorder = _Recorder(
+ on_action,
+ credential_release_guard,
+ on_pending_action,
+ strategy_aware_typing=strategy_aware_typing,
+ playwright_input_defaults=playwright_input_defaults,
+ )
def recorded_actions(self) -> list[Action]:
return list(self.__recorder.actions)
@@ -567,6 +657,47 @@ class RecordingPage:
def last_recorded_exception(self) -> BaseException | None:
return self.__recorder.last_exception
+ def _brokered_default_timeout(self, scope: Literal["page", "context"]) -> float | None:
+ """Return the trusted timeout that a secure-runner block must restore."""
+ if scope == "page":
+ return self.__recorder.playwright_input_defaults.page_timeout_ms
+ return self.__recorder.playwright_input_defaults.context_timeout_ms
+
+ def _restore_brokered_default_timeout(
+ self,
+ scope: Literal["page", "context"],
+ timeout: float | None,
+ ) -> None:
+ """Restore the pre-block override, including Page inheritance from BrowserContext."""
+ if scope == "page":
+ # The generated public wrapper forwards None to Playwright's supported optional
+ # timeout setting, clearing a Page override without inspecting implementation state.
+ setter = cast(Callable[[float | None], None], self.__page.set_default_timeout)
+ setter(timeout)
+ self.__recorder.playwright_input_defaults.restore_page_timeout(timeout)
+ return
+ if timeout is None:
+ raise ValueError("context default timeout cannot inherit from another scope")
+ self.__page.context.set_default_timeout(timeout)
+ self.__recorder.playwright_input_defaults.set_context_timeout(timeout)
+
+ def _set_brokered_default_timeout(self, scope: Literal["page", "context"], timeout: float) -> None:
+ """Apply a synchronous Playwright setter received over the secure-runner transport."""
+ if not self.__recorder.strategy_aware_typing:
+ raise RuntimeError("brokered default timeout is unavailable")
+ if scope == "page":
+ self.__page.set_default_timeout(timeout)
+ self.__recorder.playwright_input_defaults.set_page_timeout(timeout)
+ return
+ if scope == "context":
+ self.__page.context.set_default_timeout(timeout)
+ self.__recorder.playwright_input_defaults.set_context_timeout(timeout)
+ return
+ raise ValueError(f"unsupported default-timeout scope: {scope}")
+
+ def _supports_brokered_default_timeout(self) -> bool:
+ return self.__recorder.strategy_aware_typing
+
def locator(self, selector: str, **kwargs: Any) -> RecordingLocator:
return RecordingLocator(self.__page.locator(selector, **kwargs), self.__recorder, selector)
@@ -576,6 +707,15 @@ class RecordingPage:
def __getattr__(self, name: str) -> Any:
attr = getattr(self.__page, name)
+ if name == "context" and self.__recorder.strategy_aware_typing:
+ return RecordingBrowserContext(attr, self.__recorder)
+ if name == "set_default_timeout" and self.__recorder.strategy_aware_typing and callable(attr):
+
+ def set_default_timeout(timeout: float) -> None:
+ attr(timeout)
+ self.__recorder.playwright_input_defaults.set_page_timeout(timeout)
+
+ return set_default_timeout
if name in _LOCATOR_FACTORY_METHODS and callable(attr):
def factory(*args: Any, **kwargs: Any) -> RecordingLocator:
@@ -605,7 +745,54 @@ class RecordingPage:
description = " ".join(prompt.split())[:200]
async def call() -> Any:
+ if self.__recorder.strategy_aware_typing and name in ("fill", "type"):
+ inspect.signature(attr).bind(*args, **kwargs)
await self.__recorder.enforce_credential_release(self.__page, f"page.{name}", args, kwargs)
+ if (
+ self.__recorder.strategy_aware_typing
+ and name in ("fill", "type")
+ and kwargs.keys() <= _PAGE_STRATEGY_INPUT_OPTIONS
+ ):
+ selector = kwargs.get("selector", args[0] if args else None)
+ value_index = 1
+ value = kwargs.get("value" if name == "fill" else "text", _arg(args, value_index))
+ strict = kwargs.get("strict")
+ authored_timeout = kwargs.get("timeout")
+ if (
+ isinstance(selector, str)
+ and isinstance(value, str)
+ and strict in (None, False, True)
+ and (authored_timeout is None or isinstance(authored_timeout, int | float))
+ ):
+ locator = _page_strategy_input_locator(
+ self.__page,
+ selector,
+ strict,
+ self.__recorder.playwright_input_defaults,
+ )
+ timeout = _effective_playwright_timeout(
+ self.__recorder.playwright_input_defaults,
+ authored_timeout,
+ )
+ force = kwargs.get("force")
+ delay = kwargs.get("delay")
+ no_wait_after = kwargs.get("no_wait_after")
+ if force is None and delay is None and no_wait_after is None:
+ return await strategy_aware_input(
+ locator,
+ value,
+ clear=name == "fill",
+ timeout=timeout,
+ )
+ return await strategy_aware_input(
+ locator,
+ value,
+ clear=name == "fill",
+ timeout=timeout,
+ force=force,
+ delay=delay,
+ no_wait_after=no_wait_after,
+ )
return await attr(*args, **kwargs)
return await self.__recorder.record(
diff --git a/skyvern/forge/sdk/workflow/models/code_block_recording.py b/skyvern/forge/sdk/workflow/models/code_block_recording.py
index d3e6956b9..9cabcf1e2 100644
--- a/skyvern/forge/sdk/workflow/models/code_block_recording.py
+++ b/skyvern/forge/sdk/workflow/models/code_block_recording.py
@@ -16,6 +16,7 @@ from skyvern.forge.sdk.schemas.tasks import TaskStatus
from skyvern.forge.sdk.workflow.models.code_block_recorder import (
RECORDED_FAILURE_RESPONSE_MAX_CHARS,
PendingAction,
+ PlaywrightInputDefaults,
RecordingPage,
recorded_action_from_payload,
)
@@ -95,6 +96,8 @@ class CodeBlockActionRecording:
workflow_run_context: WorkflowRunContext,
redaction_parameters: dict[str, object] | None = None,
credential_release_guard: CredentialReleaseGuard | None = None,
+ strategy_aware_typing: bool = False,
+ playwright_input_defaults: PlaywrightInputDefaults | None = None,
) -> None:
self._code_block = code_block
self._page = page
@@ -117,6 +120,8 @@ class CodeBlockActionRecording:
on_action=self._recorded_action_sink,
on_pending_action=self._page_call_still_pending,
credential_release_guard=credential_release_guard,
+ strategy_aware_typing=strategy_aware_typing,
+ playwright_input_defaults=playwright_input_defaults,
)
def set_redaction_parameters(self, parameters: dict[str, object]) -> None:
diff --git a/skyvern/webeye/actions/handler_utils.py b/skyvern/webeye/actions/handler_utils.py
index d73e65bbf..7b4990c1b 100644
--- a/skyvern/webeye/actions/handler_utils.py
+++ b/skyvern/webeye/actions/handler_utils.py
@@ -3,6 +3,7 @@ from typing import Any, Literal
import structlog
from playwright.async_api import Locator, Page
+from playwright.async_api import TimeoutError as PlaywrightTimeoutError
from skyvern.config import settings
from skyvern.constants import TEXT_PRESS_MAX_LENGTH
@@ -14,6 +15,17 @@ from skyvern.webeye.actions.actions import Action, KeypressAction
LOG = structlog.get_logger()
+_NATIVE_VALUE_SET_INPUT_TYPES = frozenset({"range", "date", "datetime-local", "month", "time", "week"})
+
+
+async def _uses_native_value_set_fill(locator: Locator) -> bool:
+ try:
+ input_type = await locator.evaluate("el => el.tagName === 'INPUT' ? el.type : null")
+ except Exception:
+ LOG.debug("Failed to inspect input type before strategy-aware fill", exc_info=True)
+ return False
+ return input_type in _NATIVE_VALUE_SET_INPUT_TYPES
+
async def download_file(
file_url: str,
@@ -49,15 +61,131 @@ async def download_file(
return []
-async def input_sequentially(locator: Locator, text: str, timeout: float = settings.BROWSER_ACTION_TIMEOUT_MS) -> None:
+async def strategy_aware_input(
+ locator: Locator,
+ text: str,
+ *,
+ clear: bool | None,
+ timeout: float | None = settings.BROWSER_ACTION_TIMEOUT_MS,
+ use_caller_timeout: bool = True,
+ force: bool | None = None,
+ delay: float | None = None,
+ no_wait_after: bool | None = None,
+ dispatch_change_and_blur: bool = False,
+ allow_batched_playwright: bool = True,
+) -> None:
length = len(text)
- if length > TEXT_PRESS_MAX_LENGTH:
- # if the text is longer than TEXT_PRESS_MAX_LENGTH characters, we will locator.fill in initial texts until the last TEXT_PRESS_MAX_LENGTH characters
- # and then type the last TEXT_PRESS_MAX_LENGTH characters with locator.press_sequentially
- await locator.fill(text[: length - TEXT_PRESS_MAX_LENGTH], timeout=timeout)
- text = text[length - TEXT_PRESS_MAX_LENGTH :]
+ prefix = text[: length - TEXT_PRESS_MAX_LENGTH] if length > TEXT_PRESS_MAX_LENGTH else None
+ strategy_text = text[length - TEXT_PRESS_MAX_LENGTH :] if prefix is not None and clear is not False else text
+
+ async def dispatch_commit_events() -> None:
+ if not dispatch_change_and_blur:
+ return
+ # Playwright typing already emits input events. Preserve the deterministic replace
+ # contract for JS-gated forms by adding the commit events that typing does not emit.
+ for event_name in ("change", "blur"):
+ try:
+ await locator.dispatch_event(event_name, timeout=timeout)
+ except Exception:
+ # These events were historically best-effort; a dispatch failure must not
+ # turn a successful text replacement into a failed action.
+ LOG.debug("Failed to dispatch post-input event", event_name=event_name, exc_info=True)
+
+ async def perform_input() -> None:
+ if clear is True and await _uses_native_value_set_fill(locator):
+ native_fill_options: dict[str, float | bool | None] = {"timeout": timeout}
+ if force is not None:
+ native_fill_options["force"] = force
+ if no_wait_after is not None:
+ native_fill_options["no_wait_after"] = no_wait_after
+ await locator.fill(text, **native_fill_options)
+ await dispatch_commit_events()
+ return
+
+ if clear is True and force is True:
+ force_fill_options: dict[str, float | bool | None] = {"timeout": timeout, "force": True}
+ if no_wait_after is not None:
+ force_fill_options["no_wait_after"] = no_wait_after
+ await locator.fill(text, **force_fill_options)
+ await dispatch_commit_events()
+ return
- await EventStrategyFactory.type_text(locator.page, locator, text)
+ # None preserves input_sequentially's legacy contract: short values append, while long values seed a prefix.
+ if clear is True and prefix is None:
+ if use_caller_timeout:
+ if force is None and no_wait_after is None:
+ await EventStrategyFactory.clear_field(locator.page, locator, char_count=0, timeout=timeout)
+ else:
+ await EventStrategyFactory.clear_field(
+ locator.page,
+ locator,
+ char_count=0,
+ timeout=timeout,
+ force=force,
+ no_wait_after=no_wait_after,
+ )
+ else:
+ await EventStrategyFactory.clear_field(locator.page, locator, char_count=0)
+
+ if prefix is not None and clear is not False:
+ # Keep large replacements fast, then send the tail through the active strategy.
+ fill_options: dict[str, float | bool | None] = {"timeout": timeout}
+ if force is not None:
+ fill_options["force"] = force
+ if no_wait_after is not None:
+ fill_options["no_wait_after"] = no_wait_after
+ await locator.fill(prefix, **fill_options)
+
+ if use_caller_timeout:
+ if delay is None and no_wait_after is None:
+ await EventStrategyFactory.type_text(
+ locator.page,
+ locator,
+ strategy_text,
+ timeout=timeout,
+ allow_batched_playwright=allow_batched_playwright,
+ )
+ else:
+ await EventStrategyFactory.type_text(
+ locator.page,
+ locator,
+ strategy_text,
+ timeout=timeout,
+ delay=delay,
+ no_wait_after=no_wait_after,
+ allow_batched_playwright=allow_batched_playwright,
+ )
+ else:
+ # Keep input_sequentially's pre-existing strategy timeout behavior byte-for-byte.
+ await EventStrategyFactory.type_text(locator.page, locator, strategy_text)
+
+ await dispatch_commit_events()
+
+ if not use_caller_timeout:
+ await perform_input()
+ return
+
+ # One authored Playwright operation receives one total deadline. Playwright defines zero as
+ # disabling timeout enforcement, which asyncio.timeout(None) preserves.
+ timeout_seconds = None if timeout is None or timeout == 0 else timeout / 1000
+ try:
+ async with asyncio.timeout(timeout_seconds):
+ await perform_input()
+ except TimeoutError as exc:
+ # Keep the intercepted operation indistinguishable from authored Playwright fill/type calls
+ # to callers such as skyvern_type and code blocks that catch Playwright's TimeoutError.
+ raise PlaywrightTimeoutError(f"Timeout {timeout}ms exceeded.") from exc
+
+
+async def input_sequentially(locator: Locator, text: str, timeout: float = settings.BROWSER_ACTION_TIMEOUT_MS) -> None:
+ await strategy_aware_input(
+ locator,
+ text,
+ clear=None,
+ timeout=timeout,
+ use_caller_timeout=False,
+ allow_batched_playwright=False,
+ )
ENTER_KEY_ALIASES = ("enter", "return")
diff --git a/skyvern/webeye/browser_factory.py b/skyvern/webeye/browser_factory.py
index 6f5a6deb9..5c351db98 100644
--- a/skyvern/webeye/browser_factory.py
+++ b/skyvern/webeye/browser_factory.py
@@ -70,6 +70,7 @@ from skyvern.webeye.cdp_connection import (
)
from skyvern.webeye.cdp_download_interceptor import CDPDownloadInterceptor, bind_download_interceptor_to_context
from skyvern.webeye.dialog_handler import set_dialog_handler
+from skyvern.webeye.playwright_input import register_playwright_input_context
from skyvern.webeye.session_cookies import restore_banked_cookies, restore_session_cookies
LOG = structlog.get_logger()
@@ -809,6 +810,10 @@ class BrowserContextFactory:
headers=scoped_headers,
route_handlers_allowed=route_handlers_allowed,
)
+ register_playwright_input_context(
+ browser_context,
+ strict_selectors=cast(bool, kwargs.get("strict_selectors", False)),
+ )
proxy_location: ProxyLocationInput = kwargs.get("proxy_location")
if isinstance(proxy_location, ProxyLocation):
diff --git a/skyvern/webeye/playwright_input.py b/skyvern/webeye/playwright_input.py
new file mode 100644
index 000000000..348ca266a
--- /dev/null
+++ b/skyvern/webeye/playwright_input.py
@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import weakref
+from dataclasses import dataclass
+
+from playwright.async_api import BrowserContext, Page
+
+PLAYWRIGHT_DEFAULT_TIMEOUT_MS = 30_000
+
+
+@dataclass
+class _PlaywrightContextInputDefaults:
+ timeout_ms: float
+ strict_selectors: bool
+
+
+class PlaywrightInputDefaults:
+ """Public runtime state needed to adapt Page.fill/type through Locator."""
+
+ def __init__(
+ self,
+ timeout_ms: float = PLAYWRIGHT_DEFAULT_TIMEOUT_MS,
+ strict_selectors: bool = False,
+ *,
+ context_defaults: _PlaywrightContextInputDefaults | None = None,
+ ) -> None:
+ self._context_defaults = context_defaults or _PlaywrightContextInputDefaults(
+ timeout_ms=timeout_ms,
+ strict_selectors=strict_selectors,
+ )
+ self._page_timeout_ms: float | None = None
+
+ @property
+ def timeout_ms(self) -> float:
+ return self._context_defaults.timeout_ms if self._page_timeout_ms is None else self._page_timeout_ms
+
+ @property
+ def strict_selectors(self) -> bool:
+ return self._context_defaults.strict_selectors
+
+ @property
+ def context_timeout_ms(self) -> float:
+ return self._context_defaults.timeout_ms
+
+ @property
+ def page_timeout_ms(self) -> float | None:
+ return self._page_timeout_ms
+
+ def set_page_timeout(self, timeout_ms: float) -> None:
+ self._page_timeout_ms = timeout_ms
+
+ def restore_page_timeout(self, timeout_ms: float | None) -> None:
+ self._page_timeout_ms = timeout_ms
+
+ def set_context_timeout(self, timeout_ms: float) -> None:
+ self._context_defaults.timeout_ms = timeout_ms
+
+
+_CONTEXT_DEFAULTS: dict[
+ int,
+ tuple[weakref.ReferenceType[BrowserContext], _PlaywrightContextInputDefaults],
+] = {}
+_PAGE_DEFAULTS: dict[int, tuple[weakref.ReferenceType[Page], PlaywrightInputDefaults]] = {}
+
+
+def _drop_context(context_id: int) -> None:
+ _CONTEXT_DEFAULTS.pop(context_id, None)
+
+
+def _drop_page(page_id: int) -> None:
+ _PAGE_DEFAULTS.pop(page_id, None)
+
+
+def register_playwright_input_context(
+ context: BrowserContext,
+ *,
+ timeout_ms: float = PLAYWRIGHT_DEFAULT_TIMEOUT_MS,
+ strict_selectors: bool = False,
+) -> None:
+ """Register the options used to create a live BrowserContext without private Playwright state."""
+ context_id = id(context)
+ existing = _CONTEXT_DEFAULTS.get(context_id)
+ if existing is not None and existing[0]() is context:
+ return
+ defaults = _PlaywrightContextInputDefaults(timeout_ms=timeout_ms, strict_selectors=strict_selectors)
+ try:
+ reference = weakref.ref(context, lambda _reference: _drop_context(context_id))
+ except TypeError:
+ return
+ _CONTEXT_DEFAULTS[context_id] = (reference, defaults)
+
+
+def playwright_input_defaults_for_page(page: Page) -> PlaywrightInputDefaults:
+ """Return mutable Page/Context defaults shared by every recorder for this live page."""
+ page_id = id(page)
+ existing_page = _PAGE_DEFAULTS.get(page_id)
+ if existing_page is not None and existing_page[0]() is page:
+ return existing_page[1]
+
+ context = page.context
+ context_id = id(context)
+ existing_context = _CONTEXT_DEFAULTS.get(context_id)
+ if existing_context is not None and existing_context[0]() is context:
+ context_defaults = existing_context[1]
+ else:
+ context_defaults = _PlaywrightContextInputDefaults(
+ timeout_ms=PLAYWRIGHT_DEFAULT_TIMEOUT_MS,
+ strict_selectors=False,
+ )
+ try:
+ context_reference = weakref.ref(context, lambda _reference: _drop_context(context_id))
+ except TypeError:
+ context_reference = None
+ if context_reference is not None:
+ _CONTEXT_DEFAULTS[context_id] = (context_reference, context_defaults)
+
+ defaults = PlaywrightInputDefaults(context_defaults=context_defaults)
+ try:
+ page_reference = weakref.ref(page, lambda _reference: _drop_page(page_id))
+ except TypeError:
+ return defaults
+ _PAGE_DEFAULTS[page_id] = (page_reference, defaults)
+ return defaults
diff --git a/tests/unit/test_browser_context_factory_marker.py b/tests/unit/test_browser_context_factory_marker.py
index 97c4aa93d..fb873221f 100644
--- a/tests/unit/test_browser_context_factory_marker.py
+++ b/tests/unit/test_browser_context_factory_marker.py
@@ -13,8 +13,13 @@ from typing import Any
from unittest.mock import AsyncMock, MagicMock
import pytest
+from playwright.async_api import BrowserContext, Locator, Page
+from skyvern.forge.sdk.workflow.models.code_block_recorder import RecordingPage
from skyvern.webeye import browser_factory as factory_module
+from skyvern.webeye.browser_artifacts import BrowserArtifacts
+from skyvern.webeye.browser_factory import BrowserContextFactory
+from skyvern.webeye.playwright_input import playwright_input_defaults_for_page
@pytest.mark.asyncio
@@ -73,8 +78,6 @@ async def test_cdp_connect_creator_trusts_configured_browser_address(monkeypatch
@pytest.mark.asyncio
async def test_ordinary_local_creator_leaves_marker_false(monkeypatch: pytest.MonkeyPatch) -> None:
"""The factory does not auto-stamp; a local creator's marker stays False."""
- from skyvern.webeye.browser_artifacts import BrowserArtifacts
- from skyvern.webeye.browser_factory import BrowserContextFactory
async def _local_creator(playwright: Any, **kwargs: Any) -> tuple[Any, BrowserArtifacts, None]:
return object(), BrowserArtifacts(), None
@@ -128,10 +131,67 @@ def _factory_harness(monkeypatch: pytest.MonkeyPatch) -> None:
@pytest.mark.asyncio
-async def test_factory_warns_when_requested_profile_not_applied(monkeypatch: pytest.MonkeyPatch) -> None:
- from skyvern.webeye.browser_artifacts import BrowserArtifacts
- from skyvern.webeye.browser_factory import BrowserContextFactory
+async def test_factory_registers_authoritative_playwright_input_defaults(monkeypatch: pytest.MonkeyPatch) -> None:
+ context = MagicMock()
+
+ async def _creator(playwright: Any, **kwargs: Any) -> tuple[Any, BrowserArtifacts, None]:
+ return context, BrowserArtifacts(), None
+
+ _factory_harness(monkeypatch)
+ register_defaults = MagicMock()
+ monkeypatch.setattr(factory_module, "register_playwright_input_context", register_defaults)
+ BrowserContextFactory.register_type("test-input-defaults", _creator)
+ monkeypatch.setattr(factory_module.settings, "BROWSER_TYPE", "test-input-defaults")
+
+ await BrowserContextFactory.create_browser_context(playwright=object())
+
+ register_defaults.assert_called_once_with(context, strict_selectors=False)
+
+async def test_factory_preserves_context_strictness_for_recorder_omitted_strict(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ context = MagicMock(spec=BrowserContext)
+ raw_page = MagicMock(spec=Page)
+ raw_page.context = context
+ strict_locator = MagicMock(spec=Locator)
+ strict_locator.page = raw_page
+ strict_locator.first = MagicMock(spec=Locator)
+ raw_page.locator.return_value = strict_locator
+
+ async def _creator(playwright: Any, **kwargs: Any) -> tuple[Any, BrowserArtifacts, None]:
+ assert kwargs["strict_selectors"] is True
+ return context, BrowserArtifacts(), None
+
+ _factory_harness(monkeypatch)
+ strategy_aware_input = AsyncMock()
+ monkeypatch.setattr(
+ "skyvern.forge.sdk.workflow.models.code_block_recorder.strategy_aware_input",
+ strategy_aware_input,
+ )
+ BrowserContextFactory.register_type("test-strict-input-defaults", _creator)
+ monkeypatch.setattr(factory_module.settings, "BROWSER_TYPE", "test-strict-input-defaults")
+
+ await BrowserContextFactory.create_browser_context(playwright=object(), strict_selectors=True)
+ recording_page = RecordingPage(
+ raw_page,
+ strategy_aware_typing=True,
+ playwright_input_defaults=playwright_input_defaults_for_page(raw_page),
+ )
+
+ await recording_page.fill("#multiple", "value")
+
+ strategy_aware_input.assert_awaited_once_with(
+ strict_locator,
+ "value",
+ clear=True,
+ timeout=30_000,
+ )
+
+
+async def test_factory_warns_when_requested_profile_not_applied(monkeypatch: pytest.MonkeyPatch) -> None:
async def _profile_blind_creator(playwright: Any, **kwargs: Any) -> tuple[Any, BrowserArtifacts, None]:
# Mirrors remote/vendor creators: accepts browser_profile_id but never applies it.
return object(), BrowserArtifacts(), None
@@ -152,9 +212,6 @@ async def test_factory_warns_when_requested_profile_not_applied(monkeypatch: pyt
@pytest.mark.asyncio
async def test_factory_stays_quiet_when_requested_profile_applied(monkeypatch: pytest.MonkeyPatch) -> None:
- from skyvern.webeye.browser_artifacts import BrowserArtifacts
- from skyvern.webeye.browser_factory import BrowserContextFactory
-
async def _profile_applying_creator(playwright: Any, **kwargs: Any) -> tuple[Any, BrowserArtifacts, None]:
return object(), BrowserArtifacts(applied_browser_profile_id=str(kwargs.get("browser_profile_id"))), None
@@ -177,7 +234,6 @@ async def test_headless_chromium_stamps_applied_browser_profile_id(
monkeypatch: pytest.MonkeyPatch, tmp_path: Any
) -> None:
from skyvern.forge import app
- from skyvern.webeye.browser_factory import BrowserContextFactory
monkeypatch.setattr(app.STORAGE, "retrieve_browser_profile", AsyncMock(return_value=str(tmp_path / "profile")))
monkeypatch.setattr(BrowserContextFactory, "update_chromium_browser_preferences", MagicMock())
@@ -217,7 +273,6 @@ async def test_bootstrap_error_propagates_unwrapped_but_other_errors_are_wrapped
is still wrapped in ``UnknownErrorWhileCreatingBrowserContext`` as before."""
from skyvern.exceptions import UnknownErrorWhileCreatingBrowserContext
from skyvern.webeye.browser_engine import BrowserEngineBootstrapError
- from skyvern.webeye.browser_factory import BrowserContextFactory
async def _bootstrap_failing_creator(playwright: Any, **kwargs: Any) -> tuple[Any, Any, None]:
raise BrowserEngineBootstrapError("rustwright launch failed")
diff --git a/tests/unit/test_browser_effect_sink_enumeration.py b/tests/unit/test_browser_effect_sink_enumeration.py
index 74ee475e0..541082e32 100644
--- a/tests/unit/test_browser_effect_sink_enumeration.py
+++ b/tests/unit/test_browser_effect_sink_enumeration.py
@@ -45,7 +45,9 @@ _DISCOVERED_BROWSER_API_CALLS = {
"wheel": 5,
}
),
- "skyvern/webeye/actions/handler_utils.py": Counter({"down": 3, "fill": 1, "press": 1, "up": 3}),
+ "skyvern/webeye/actions/handler_utils.py": Counter(
+ {"dispatch_event": 1, "down": 3, "evaluate": 1, "fill": 3, "press": 1, "up": 3}
+ ),
"skyvern/webeye/dialog_handler.py": Counter({"accept": 3, "dismiss": 1}),
"skyvern/webeye/dom_inspection.py": Counter({"evaluate": 5}),
"skyvern/webeye/utils/dom.py": Counter(
@@ -64,7 +66,7 @@ _DISCOVERED_BROWSER_API_CALLS = {
}
),
"skyvern/forge/sdk/event/default.py": Counter(
- {"clear": 1, "click": 2, "move": 2, "scroll_into_view_if_needed": 1, "type": 2, "wheel": 1}
+ {"clear": 1, "click": 2, "move": 2, "scroll_into_view_if_needed": 1, "type": 3, "wheel": 1}
),
"skyvern/forge/sdk/event/factory.py": Counter({"click": 1, "wheel": 1}),
"skyvern/webeye/real_browser_state.py": Counter({"close": 5, "evaluate": 1, "goto": 1, "new_page": 3, "reload": 2}),
@@ -74,6 +76,7 @@ _EVALUATE_CALLERS = {
# Read-only DOM fingerprint sample for the v3 settle-before-complete check, and the per-document
# nonce the v3 loop reads to tell whether a failed batched call navigated the page.
"skyvern/forge/agent.py": Counter({"_page_fingerprint": 1, "_page_probe": 1}),
+ "skyvern/webeye/actions/handler_utils.py": Counter({"_uses_native_value_set_fill": 1}),
"skyvern/webeye/actions/handler.py": Counter(
{
"_blob_iframe_src_titles": 1,
@@ -214,21 +217,21 @@ def test_discovered_browser_api_lower_bound_is_stable() -> None:
}
assert observed == _DISCOVERED_BROWSER_API_CALLS
- assert sum(sum(methods.values()) for methods in observed.values()) == 157
+ assert sum(sum(methods.values()) for methods in observed.values()) == 162
handler_candidates = _candidate_signatures("skyvern/webeye/actions/handler.py", _CANDIDATE_METHODS)
classified_non_browser = Counter(
{signature: count for signature, count in handler_candidates.items() if signature in _NON_BROWSER_CANDIDATES}
)
assert classified_non_browser == _NON_BROWSER_CANDIDATES
assert sum(_NON_BROWSER_CANDIDATES.values()) == 5
- assert sum(sum(methods.values()) for methods in observed.values()) - sum(_NON_BROWSER_CANDIDATES.values()) == 152
+ assert sum(sum(methods.values()) for methods in observed.values()) - sum(_NON_BROWSER_CANDIDATES.values()) == 157
def test_every_raw_evaluate_call_is_classified() -> None:
observed = {path: callers for path in _owned_source_paths() if (callers := _callers_for_method(path, "evaluate"))}
assert observed == _EVALUATE_CALLERS
- assert sum(sum(callers.values()) for callers in observed.values()) == 26
+ assert sum(sum(callers.values()) for callers in observed.values()) == 27
def test_every_cdp_dispatch_is_classified_by_exact_command() -> None:
diff --git a/tests/unit/test_code_block_heal_engine_classification.py b/tests/unit/test_code_block_heal_engine_classification.py
index f586534d1..50b7d05be 100644
--- a/tests/unit/test_code_block_heal_engine_classification.py
+++ b/tests/unit/test_code_block_heal_engine_classification.py
@@ -99,6 +99,7 @@ async def test_live_legacy_path_uses_run_pinned_engine_as_authority(monkeypatch:
)
context = SimpleNamespace(
organization_id="o_test",
+ workflow=None,
get_value=MagicMock(),
mask_secrets_in_data=lambda value: value,
)
diff --git a/tests/unit/test_code_block_sandbox.py b/tests/unit/test_code_block_sandbox.py
index 783cdb8eb..8acd3933b 100644
--- a/tests/unit/test_code_block_sandbox.py
+++ b/tests/unit/test_code_block_sandbox.py
@@ -858,6 +858,7 @@ async def wrapper({default_args}):
workflow_run_id = "wrid_test"
browser_session_id = None
workflow_run_outputs: list[object] = []
+ workflow = None
def get_block_metadata(self, label: str | None) -> dict[str, object]:
return {}
@@ -940,6 +941,7 @@ async def wrapper({default_args}):
workflow_run_id = "wrid_test"
browser_session_id = "pbs_test"
workflow_run_outputs: list[object] = []
+ workflow = None
def get_block_metadata(self, label: str | None) -> dict[str, object]:
return {}
diff --git a/tests/unit/test_copilot_build_test_outcome.py b/tests/unit/test_copilot_build_test_outcome.py
index 966010102..d8ab5a575 100644
--- a/tests/unit/test_copilot_build_test_outcome.py
+++ b/tests/unit/test_copilot_build_test_outcome.py
@@ -4369,6 +4369,7 @@ async def _execute_code_block(monkeypatch: pytest.MonkeyPatch, code: str) -> dic
workflow_run_id = "wr_executor_witness"
browser_session_id = None
workflow_run_outputs: list[object] = []
+ workflow = None
def get_block_metadata(self, label: str | None) -> dict[str, object]:
return {}
diff --git a/tests/unit/test_mcp_browser_tools.py b/tests/unit/test_mcp_browser_tools.py
index b78d4b947..c1744f1da 100644
--- a/tests/unit/test_mcp_browser_tools.py
+++ b/tests/unit/test_mcp_browser_tools.py
@@ -28,6 +28,8 @@ from skyvern.cli.mcp_tools import browser as mcp_browser
from skyvern.cli.mcp_tools import cdp_input as mcp_cdp_input
from skyvern.cli.mcp_tools import mcp
from skyvern.client.errors import InternalServerError, UnprocessableEntityError
+from skyvern.config import settings
+from skyvern.constants import TEXT_PRESS_MAX_LENGTH
from skyvern.forge.sdk.forge_log import codeblock_parameter_log_redaction
from tests.unit._mcp_browser_fakes import (
make_mock_page,
@@ -1231,16 +1233,295 @@ async def test_skyvern_type_selector_is_resilient_by_default(monkeypatch: pytest
@pytest.mark.asyncio
-async def test_skyvern_type_selector_mode_direct_is_deterministic(monkeypatch: pytest.MonkeyPatch) -> None:
- fill = AsyncMock(return_value="Noor")
- _action_page(monkeypatch, fill=fill)
+async def test_skyvern_type_direct_uses_event_strategy_deterministically(monkeypatch: pytest.MonkeyPatch) -> None:
+ locator = MagicMock()
+ locator.first = locator
+ locator.fill = AsyncMock()
+ locator.dispatch_event = AsyncMock()
+ raw_page = MagicMock()
+ locator.page = raw_page
+ raw_page.locator = MagicMock(return_value=locator)
+ raw_page.url = "https://example.test/form"
+ raw_page.evaluate = AsyncMock(return_value=False)
+ page = make_skyvern_page(raw_page)
+ page.locator_scope = raw_page
+ context = BrowserContext(mode="cloud_session", session_id="pbs_test")
+ monkeypatch.setattr(mcp_browser, "get_page", AsyncMock(return_value=(page, context)))
+ clear_field = AsyncMock()
+ type_text = AsyncMock()
+ monkeypatch.setattr("skyvern.webeye.actions.handler_utils.EventStrategyFactory.clear_field", clear_field)
+ monkeypatch.setattr("skyvern.webeye.actions.handler_utils.EventStrategyFactory.type_text", type_text)
+
+ result = await mcp_browser.skyvern_type(
+ selector="#first_name",
+ text="Noor",
+ selector_mode="direct",
+ )
- result = await mcp_browser.skyvern_type(selector="#first_name", text="Noor", selector_mode="direct")
+ assert result["ok"] is True, result.get("error")
+ raw_page.locator.assert_called_once_with("#first_name")
+ clear_field.assert_awaited_once_with(
+ raw_page,
+ locator,
+ char_count=0,
+ timeout=settings.BROWSER_ACTION_TIMEOUT_MS,
+ )
+ type_text.assert_awaited_once_with(
+ raw_page,
+ locator,
+ "Noor",
+ timeout=settings.BROWSER_ACTION_TIMEOUT_MS,
+ allow_batched_playwright=True,
+ )
+ assert [call.args[0] for call in locator.dispatch_event.await_args_list] == ["change", "blur"]
+ locator.fill.assert_not_awaited()
- assert result["ok"] is True
- assert fill.await_args.kwargs["mode"] == "direct"
- assert "prompt" not in fill.await_args.kwargs and "ai" not in fill.await_args.kwargs
- assert "_skip_element_prep" not in fill.await_args.kwargs
+
+async def test_skyvern_type_direct_event_strategy_handles_aggregate_playwright_timeout(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ locator = MagicMock()
+ locator.first = locator
+ locator.fill = AsyncMock()
+ raw_page = MagicMock()
+ locator.page = raw_page
+ raw_page.locator = MagicMock(return_value=locator)
+ raw_page.url = "https://example.test/form"
+ raw_page.evaluate = AsyncMock(return_value=False)
+ page = make_skyvern_page(raw_page)
+ page.locator_scope = raw_page
+ context = BrowserContext(mode="cloud_session", session_id="pbs_test")
+ monkeypatch.setattr(mcp_browser, "get_page", AsyncMock(return_value=(page, context)))
+ monkeypatch.setattr(
+ "skyvern.webeye.actions.handler_utils.EventStrategyFactory.clear_field",
+ AsyncMock(side_effect=TimeoutError),
+ )
+
+ result = await mcp_browser.skyvern_type(
+ selector="#first_name",
+ text="Noor",
+ selector_mode="direct",
+ timeout=1234,
+ )
+
+ assert result["ok"] is False
+ assert result["error"]["code"] == mcp_browser.ErrorCode.ACTION_FAILED
+ assert result["error"]["details"]["actionability_timeout_ms"] == 1234
+
+
+async def test_skyvern_type_missing_selector_preflight_uses_aggregate_direct_timeout(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ preflight_cancelled = asyncio.Event()
+
+ async def wait_for_missing_selector(*_args: object, **_kwargs: object) -> bool:
+ try:
+ await asyncio.Future()
+ finally:
+ preflight_cancelled.set()
+ return False
+
+ raw_page = MagicMock()
+ raw_page.url = "https://example.test/form"
+ active_frame = MagicMock()
+ matches = MagicMock()
+ matches.count = AsyncMock(return_value=0)
+ first_match = MagicMock()
+ first_match.evaluate = AsyncMock(side_effect=wait_for_missing_selector)
+ matches.first = first_match
+ active_frame.locator.return_value = matches
+ page = SimpleNamespace(page=raw_page, locator_scope=active_frame, _locator_scope=active_frame)
+ context = BrowserContext(mode="cloud_session", session_id="pbs_test")
+ monkeypatch.setattr(mcp_browser, "get_page", AsyncMock(return_value=(page, context)))
+ strategy_aware_input = AsyncMock()
+ monkeypatch.setattr(mcp_browser, "strategy_aware_input", strategy_aware_input)
+
+ loop = asyncio.get_running_loop()
+ started_at = loop.time()
+ result = await asyncio.wait_for(
+ mcp_browser.skyvern_type(
+ selector="#missing",
+ text="Noor",
+ selector_mode="direct",
+ timeout=1000,
+ ),
+ timeout=1.5,
+ )
+
+ assert loop.time() - started_at < 1.5
+ assert preflight_cancelled.is_set()
+ assert result["ok"] is False
+ assert result["error"]["code"] == mcp_browser.ErrorCode.SELECTOR_NOT_FOUND
+ assert result["error"]["details"]["actionability_timeout_ms"] == 1000
+ strategy_aware_input.assert_not_awaited()
+
+
+async def test_skyvern_type_direct_append_uses_strategy_without_replacing(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ locator = MagicMock()
+ locator.first = locator
+ locator.fill = AsyncMock()
+ raw_page = MagicMock()
+ locator.page = raw_page
+ raw_page.locator = MagicMock(return_value=locator)
+ raw_page.url = "https://example.test/form"
+ raw_page.evaluate = AsyncMock(return_value=False)
+ page = make_skyvern_page(raw_page)
+ page.locator_scope = raw_page
+ context = BrowserContext(mode="cloud_session", session_id="pbs_test")
+ monkeypatch.setattr(mcp_browser, "get_page", AsyncMock(return_value=(page, context)))
+ clear_field = AsyncMock()
+ type_text = AsyncMock()
+ monkeypatch.setattr("skyvern.webeye.actions.handler_utils.EventStrategyFactory.clear_field", clear_field)
+ monkeypatch.setattr("skyvern.webeye.actions.handler_utils.EventStrategyFactory.type_text", type_text)
+
+ result = await mcp_browser.skyvern_type(
+ selector="#notes",
+ text="more",
+ selector_mode="direct",
+ clear=False,
+ delay=17,
+ )
+
+ assert result["ok"] is True, result
+ clear_field.assert_not_awaited()
+ locator.fill.assert_not_awaited()
+ type_text.assert_awaited_once_with(
+ raw_page,
+ locator,
+ "more",
+ timeout=settings.BROWSER_ACTION_TIMEOUT_MS,
+ delay=17,
+ no_wait_after=None,
+ allow_batched_playwright=True,
+ )
+
+
+async def test_skyvern_type_direct_long_replacement_keeps_atomic_prefix_and_strategy_tail(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ text = "x" * (TEXT_PRESS_MAX_LENGTH + 4)
+ locator = MagicMock()
+ locator.first = locator
+ locator.fill = AsyncMock()
+ raw_page = MagicMock()
+ locator.page = raw_page
+ raw_page.locator = MagicMock(return_value=locator)
+ raw_page.url = "https://example.test/form"
+ raw_page.evaluate = AsyncMock(return_value=False)
+ page = make_skyvern_page(raw_page)
+ page.locator_scope = raw_page
+ context = BrowserContext(mode="cloud_session", session_id="pbs_test")
+ monkeypatch.setattr(mcp_browser, "get_page", AsyncMock(return_value=(page, context)))
+ clear_field = AsyncMock()
+ type_text = AsyncMock()
+ monkeypatch.setattr("skyvern.webeye.actions.handler_utils.EventStrategyFactory.clear_field", clear_field)
+ monkeypatch.setattr("skyvern.webeye.actions.handler_utils.EventStrategyFactory.type_text", type_text)
+
+ result = await mcp_browser.skyvern_type(
+ selector="#notes",
+ text=text,
+ selector_mode="direct",
+ )
+
+ assert result["ok"] is True, result
+ clear_field.assert_not_awaited()
+ locator.fill.assert_awaited_once_with(text[:-TEXT_PRESS_MAX_LENGTH], timeout=5000)
+ type_text.assert_awaited_once_with(
+ raw_page,
+ locator,
+ text[-TEXT_PRESS_MAX_LENGTH:],
+ timeout=settings.BROWSER_ACTION_TIMEOUT_MS,
+ allow_batched_playwright=True,
+ )
+
+
+async def test_skyvern_type_direct_event_strategy_uses_active_iframe_and_first_match(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ raw_page = MagicMock()
+ raw_page.url = "https://example.test/form"
+ raw_page.evaluate = AsyncMock(return_value=False)
+ active_frame = MagicMock()
+ matches = MagicMock()
+ first_match = MagicMock()
+ first_match.page = raw_page
+ matches.first = first_match
+ active_frame.locator.return_value = matches
+ page = make_skyvern_page(raw_page)
+ page.locator_scope = active_frame
+ context = BrowserContext(mode="cloud_session", session_id="pbs_test")
+ monkeypatch.setattr(mcp_browser, "get_page", AsyncMock(return_value=(page, context)))
+ clear_field = AsyncMock()
+ type_text = AsyncMock()
+ monkeypatch.setattr("skyvern.webeye.actions.handler_utils.EventStrategyFactory.clear_field", clear_field)
+ monkeypatch.setattr("skyvern.webeye.actions.handler_utils.EventStrategyFactory.type_text", type_text)
+
+ result = await mcp_browser.skyvern_type(
+ selector=".shared-name",
+ text="Noor",
+ selector_mode="direct",
+ )
+
+ assert result["ok"] is True, result
+ active_frame.locator.assert_called_once_with(".shared-name")
+ raw_page.locator.assert_not_called()
+ clear_field.assert_awaited_once_with(
+ raw_page,
+ first_match,
+ char_count=0,
+ timeout=settings.BROWSER_ACTION_TIMEOUT_MS,
+ )
+ type_text.assert_awaited_once_with(
+ raw_page,
+ first_match,
+ "Noor",
+ timeout=settings.BROWSER_ACTION_TIMEOUT_MS,
+ allow_batched_playwright=True,
+ )
+
+
[email protected]("clear", [pytest.param(True, id="replace"), pytest.param(False, id="append")])
+async def test_skyvern_type_direct_event_strategy_refuses_active_iframe_password_first_match(
+ monkeypatch: pytest.MonkeyPatch,
+ clear: bool,
+) -> None:
+ raw_page = MagicMock()
+ raw_page.url = "https://example.test/form"
+ raw_page.evaluate = AsyncMock()
+ active_frame = MagicMock()
+ matches = MagicMock()
+ first_match = MagicMock()
+ first_match.evaluate = AsyncMock(return_value=True)
+ matches.first = first_match
+ active_frame.locator.return_value = matches
+ page = make_skyvern_page(raw_page)
+ page.locator_scope = active_frame
+ context = BrowserContext(mode="cloud_session", session_id="pbs_test")
+ monkeypatch.setattr(mcp_browser, "get_page", AsyncMock(return_value=(page, context)))
+ strategy_aware_input = AsyncMock()
+ monkeypatch.setattr(mcp_browser, "strategy_aware_input", strategy_aware_input)
+
+ result = await mcp_browser.skyvern_type(
+ selector=".shared-field",
+ text="opaque-value",
+ selector_mode="direct",
+ clear=clear,
+ )
+
+ assert result["ok"] is False
+ assert "password" in result["error"]["message"].lower()
+ active_frame.locator.assert_called_once_with(".shared-field")
+ first_match.evaluate.assert_awaited_once()
+ raw_page.evaluate.assert_not_awaited()
+ strategy_aware_input.assert_not_awaited()
@pytest.mark.asyncio
diff --git a/tests/unit/test_mcp_trajectory.py b/tests/unit/test_mcp_trajectory.py
index 1d3d14ff1..ffc1b0990 100644
--- a/tests/unit/test_mcp_trajectory.py
+++ b/tests/unit/test_mcp_trajectory.py
@@ -83,9 +83,11 @@ def _patch_browser_page(
locator = SimpleNamespace(press=AsyncMock(), select_option=AsyncMock(), evaluate=AsyncMock(return_value=False))
locator.first = locator
raw_page = SimpleNamespace(locator=MagicMock(return_value=locator))
+ locator.page = raw_page
page = SimpleNamespace(
url=source_url,
page=raw_page,
+ locator_scope=raw_page,
click=AsyncMock(return_value="#resolved-submit"),
evaluate=AsyncMock(return_value=False),
fill=AsyncMock(),
@@ -97,6 +99,7 @@ def _patch_browser_page(
context = BrowserContext(mode=mode, session_id=session_id)
set_current_session(SessionState(context=context, api_key_hash=api_key_hash))
monkeypatch.setattr(mcp_browser, "get_page", AsyncMock(return_value=(page, context)))
+ monkeypatch.setattr(mcp_browser, "strategy_aware_input", AsyncMock(return_value=None))
monkeypatch.setattr(mcp_browser, "select_native_option_if_targeted", AsyncMock(return_value=None))
monkeypatch.setenv("SKYVERN_DISABLE_CUSTOM_SELECT", "1")
return page
diff --git a/tests/unit/test_tel_input_bare_digits.py b/tests/unit/test_tel_input_bare_digits.py
index 463800368..4f8c7faa9 100644
--- a/tests/unit/test_tel_input_bare_digits.py
+++ b/tests/unit/test_tel_input_bare_digits.py
@@ -1,11 +1,16 @@
from __future__ import annotations
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
from datetime import UTC, datetime
from types import SimpleNamespace
-from unittest.mock import AsyncMock, MagicMock
+from unittest.mock import AsyncMock, MagicMock, call
import pytest
+from playwright.async_api import TimeoutError as PlaywrightTimeoutError
+from skyvern.constants import TEXT_INPUT_DELAY
+from skyvern.forge.sdk.event.default import DefaultInputStrategy
from skyvern.webeye.actions import handler_utils
from skyvern.webeye.actions.handler import (
_is_tel_digit_fix_enabled,
@@ -172,6 +177,357 @@ async def test_input_sequentially_fill_splits_separator_formatted_value(monkeypa
assert typed == [") 555-0199"]
+async def test_strategy_aware_input_clears_short_replacement_through_active_strategy(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ locator = MagicMock()
+ locator.fill = AsyncMock()
+ deadline_active = False
+
+ async def clear_field(*_args: object, **_kwargs: object) -> None:
+ assert deadline_active
+
+ async def type_text(*_args: object, **_kwargs: object) -> None:
+ assert deadline_active
+
+ clear_field_mock = AsyncMock(side_effect=clear_field)
+ type_text_mock = AsyncMock(side_effect=type_text)
+ monkeypatch.setattr(handler_utils.EventStrategyFactory, "clear_field", clear_field_mock)
+ monkeypatch.setattr(handler_utils.EventStrategyFactory, "type_text", type_text_mock)
+ timeout_calls: list[float | None] = []
+
+ @asynccontextmanager
+ async def record_timeout(delay: float | None) -> AsyncIterator[None]:
+ nonlocal deadline_active
+ timeout_calls.append(delay)
+ deadline_active = True
+ try:
+ yield
+ finally:
+ deadline_active = False
+
+ monkeypatch.setattr(handler_utils.asyncio, "timeout", record_timeout)
+
+ await handler_utils.strategy_aware_input(locator, "Noor", clear=True, timeout=4321)
+
+ clear_field_mock.assert_awaited_once_with(locator.page, locator, char_count=0, timeout=4321)
+ type_text_mock.assert_awaited_once_with(
+ locator.page,
+ locator,
+ "Noor",
+ timeout=4321,
+ allow_batched_playwright=True,
+ )
+ locator.fill.assert_not_awaited()
+ assert timeout_calls == [4.321]
+
+
+async def test_strategy_aware_input_dispatches_best_effort_commit_events_after_typing(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ operations: list[str] = []
+
+ async def clear_field(*_args: object, **_kwargs: object) -> None:
+ operations.append("clear")
+
+ async def type_text(*_args: object, **_kwargs: object) -> None:
+ operations.append("type")
+
+ async def dispatch_event(event_name: str, **_kwargs: object) -> None:
+ operations.append(event_name)
+ if event_name == "change":
+ raise RuntimeError("dispatch failed")
+
+ locator = MagicMock()
+ locator.fill = AsyncMock()
+ locator.dispatch_event = AsyncMock(side_effect=dispatch_event)
+ monkeypatch.setattr(handler_utils.EventStrategyFactory, "clear_field", AsyncMock(side_effect=clear_field))
+ monkeypatch.setattr(handler_utils.EventStrategyFactory, "type_text", AsyncMock(side_effect=type_text))
+
+ await handler_utils.strategy_aware_input(
+ locator,
+ "Noor",
+ clear=True,
+ timeout=4321,
+ dispatch_change_and_blur=True,
+ )
+
+ assert operations == ["clear", "type", "change", "blur"]
+ assert locator.dispatch_event.await_args_list[0].kwargs == {"timeout": 4321}
+ assert locator.dispatch_event.await_args_list[1].kwargs == {"timeout": 4321}
+
+
+async def test_strategy_aware_input_preserves_explicit_null_timeout(monkeypatch: pytest.MonkeyPatch) -> None:
+ locator = MagicMock()
+ locator.fill = AsyncMock()
+ clear_field = AsyncMock()
+ type_text = AsyncMock()
+ monkeypatch.setattr(handler_utils.EventStrategyFactory, "clear_field", clear_field)
+ monkeypatch.setattr(handler_utils.EventStrategyFactory, "type_text", type_text)
+ timeout_calls: list[float | None] = []
+
+ @asynccontextmanager
+ async def record_timeout(delay: float | None) -> AsyncIterator[None]:
+ timeout_calls.append(delay)
+ yield
+
+ monkeypatch.setattr(handler_utils.asyncio, "timeout", record_timeout)
+
+ await handler_utils.strategy_aware_input(locator, "Noor", clear=True, timeout=None)
+
+ assert timeout_calls == [None]
+ clear_field.assert_awaited_once_with(locator.page, locator, char_count=0, timeout=None)
+ type_text.assert_awaited_once_with(
+ locator.page,
+ locator,
+ "Noor",
+ timeout=None,
+ allow_batched_playwright=True,
+ )
+
+
+async def test_strategy_aware_input_preserves_zero_as_no_timeout(monkeypatch: pytest.MonkeyPatch) -> None:
+ locator = MagicMock()
+ locator.fill = AsyncMock()
+ clear_field = AsyncMock()
+ type_text = AsyncMock()
+ monkeypatch.setattr(handler_utils.EventStrategyFactory, "clear_field", clear_field)
+ monkeypatch.setattr(handler_utils.EventStrategyFactory, "type_text", type_text)
+ timeout_calls: list[float | None] = []
+
+ @asynccontextmanager
+ async def record_timeout(delay: float | None) -> AsyncIterator[None]:
+ timeout_calls.append(delay)
+ yield
+
+ monkeypatch.setattr(handler_utils.asyncio, "timeout", record_timeout)
+
+ await handler_utils.strategy_aware_input(locator, "Noor", clear=True, timeout=0)
+
+ assert timeout_calls == [None]
+ clear_field.assert_awaited_once_with(locator.page, locator, char_count=0, timeout=0)
+ type_text.assert_awaited_once_with(
+ locator.page,
+ locator,
+ "Noor",
+ timeout=0,
+ allow_batched_playwright=True,
+ )
+
+
+async def test_strategy_aware_force_fill_preserves_atomic_playwright_semantics(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ locator = MagicMock()
+ locator.fill = AsyncMock()
+ clear_field = AsyncMock()
+ type_text = AsyncMock()
+ monkeypatch.setattr(handler_utils.EventStrategyFactory, "clear_field", clear_field)
+ monkeypatch.setattr(handler_utils.EventStrategyFactory, "type_text", type_text)
+
+ await handler_utils.strategy_aware_input(
+ locator,
+ "Noor",
+ clear=True,
+ timeout=4321,
+ force=True,
+ no_wait_after=True,
+ )
+
+ locator.fill.assert_awaited_once_with("Noor", timeout=4321, force=True, no_wait_after=True)
+ clear_field.assert_not_awaited()
+ type_text.assert_not_awaited()
+
+
+ ("input_type", "value"),
+ [
+ pytest.param("range", "42", id="range"),
+ pytest.param("date", "2026-08-30", id="date"),
+ pytest.param("datetime-local", "2026-08-30T12:34", id="datetime-local"),
+ pytest.param("month", "2026-08", id="month"),
+ pytest.param("time", "12:34", id="time"),
+ pytest.param("week", "2026-W35", id="week"),
+ ],
+)
+async def test_strategy_aware_fill_preserves_native_value_set_input_semantics(
+ monkeypatch: pytest.MonkeyPatch,
+ input_type: str,
+ value: str,
+) -> None:
+ locator = MagicMock()
+ locator.evaluate = AsyncMock(return_value=input_type)
+ locator.fill = AsyncMock()
+ locator.dispatch_event = AsyncMock()
+ clear_field = AsyncMock()
+ type_text = AsyncMock()
+ monkeypatch.setattr(handler_utils.EventStrategyFactory, "clear_field", clear_field)
+ monkeypatch.setattr(handler_utils.EventStrategyFactory, "type_text", type_text)
+
+ await handler_utils.strategy_aware_input(
+ locator,
+ value,
+ clear=True,
+ timeout=4321,
+ force=False,
+ no_wait_after=True,
+ dispatch_change_and_blur=True,
+ )
+
+ locator.fill.assert_awaited_once_with(value, timeout=4321, force=False, no_wait_after=True)
+ clear_field.assert_not_awaited()
+ type_text.assert_not_awaited()
+ assert [call.args[0] for call in locator.dispatch_event.await_args_list] == ["change", "blur"]
+
+
+async def test_default_input_strategy_forwards_timeout_to_every_locator_operation() -> None:
+ page = MagicMock()
+ locator = MagicMock()
+ locator.type = AsyncMock()
+ locator.clear = AsyncMock()
+ strategy = DefaultInputStrategy()
+
+ await strategy.clear_field(page, locator, char_count=0, timeout=0)
+ await strategy.type_text(page, locator, "Noor", timeout=0)
+
+ locator.clear.assert_awaited_once_with(timeout=0)
+ assert locator.type.await_args_list == [call(char, delay=TEXT_INPUT_DELAY, timeout=0) for char in "Noor"]
+
+
+async def test_default_input_strategy_batches_when_copilot_surface_allows_it() -> None:
+ page = MagicMock()
+ locator = MagicMock()
+ locator.type = AsyncMock()
+ strategy = DefaultInputStrategy()
+
+ await strategy.type_text(
+ page,
+ locator,
+ "Noor",
+ timeout=4321,
+ allow_batched_playwright=True,
+ )
+
+ locator.type.assert_awaited_once_with("Noor", delay=TEXT_INPUT_DELAY, timeout=4321)
+
+
+async def test_default_input_strategy_preserves_supported_playwright_input_options() -> None:
+ page = MagicMock()
+ locator = MagicMock()
+ locator.type = AsyncMock()
+ locator.clear = AsyncMock()
+ strategy = DefaultInputStrategy()
+
+ await strategy.clear_field(page, locator, char_count=0, timeout=1234, force=True, no_wait_after=True)
+ await strategy.type_text(page, locator, "No", timeout=2345, delay=17, no_wait_after=True)
+
+ locator.clear.assert_awaited_once_with(timeout=1234, force=True, no_wait_after=True)
+ assert locator.type.await_args_list == [
+ call("N", delay=17, timeout=2345, no_wait_after=True),
+ call("o", delay=17, timeout=2345, no_wait_after=True),
+ ]
+
+
+async def test_strategy_aware_input_raises_playwright_timeout_for_aggregate_deadline(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ locator = MagicMock()
+ locator.fill = AsyncMock()
+ monkeypatch.setattr(handler_utils.EventStrategyFactory, "clear_field", AsyncMock(side_effect=TimeoutError))
+
+ with pytest.raises(PlaywrightTimeoutError, match="4321ms"):
+ await handler_utils.strategy_aware_input(locator, "Noor", clear=True, timeout=4321)
+
+
+async def test_strategy_aware_input_keeps_long_prefix_and_tail_under_one_deadline(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ deadline_active = False
+
+ async def fill(*_args: object, **_kwargs: object) -> None:
+ assert deadline_active
+
+ async def type_text(*_args: object, **_kwargs: object) -> None:
+ assert deadline_active
+
+ locator = MagicMock()
+ locator.fill = AsyncMock(side_effect=fill)
+ type_text_mock = AsyncMock(side_effect=type_text)
+ monkeypatch.setattr(handler_utils.EventStrategyFactory, "type_text", type_text_mock)
+ timeout_calls: list[float | None] = []
+
+ @asynccontextmanager
+ async def record_timeout(delay: float | None) -> AsyncIterator[None]:
+ nonlocal deadline_active
+ timeout_calls.append(delay)
+ deadline_active = True
+ try:
+ yield
+ finally:
+ deadline_active = False
+
+ monkeypatch.setattr(handler_utils.asyncio, "timeout", record_timeout)
+ text = "x" * (handler_utils.TEXT_PRESS_MAX_LENGTH + 1)
+
+ await handler_utils.strategy_aware_input(locator, text, clear=True, timeout=4321)
+
+ locator.fill.assert_awaited_once_with("x", timeout=4321)
+ type_text_mock.assert_awaited_once_with(
+ locator.page,
+ locator,
+ text[-handler_utils.TEXT_PRESS_MAX_LENGTH :],
+ timeout=4321,
+ allow_batched_playwright=True,
+ )
+ assert timeout_calls == [4.321]
+
+
+async def test_input_sequentially_keeps_legacy_strategy_timeout_behavior(monkeypatch: pytest.MonkeyPatch) -> None:
+ locator = MagicMock()
+ locator.fill = AsyncMock()
+ type_text = AsyncMock()
+ monkeypatch.setattr(handler_utils.EventStrategyFactory, "type_text", type_text)
+ timeout_scope = MagicMock(side_effect=AssertionError("legacy input must not gain an aggregate deadline"))
+ monkeypatch.setattr(handler_utils.asyncio, "timeout", timeout_scope)
+
+ await handler_utils.input_sequentially(locator, "Noor", timeout=4321)
+
+ timeout_scope.assert_not_called()
+ type_text.assert_awaited_once_with(locator.page, locator, "Noor")
+
+
+async def test_strategy_aware_input_appends_without_atomic_fill(monkeypatch: pytest.MonkeyPatch) -> None:
+ locator = MagicMock()
+ locator.fill = AsyncMock()
+ type_text = AsyncMock()
+ monkeypatch.setattr(handler_utils.EventStrategyFactory, "type_text", type_text)
+ text = "x" * (handler_utils.TEXT_PRESS_MAX_LENGTH + 1)
+
+ await handler_utils.strategy_aware_input(locator, text, clear=False, timeout=4321)
+
+ locator.fill.assert_not_awaited()
+ type_text.assert_awaited_once_with(
+ locator.page,
+ locator,
+ text,
+ timeout=4321,
+ allow_batched_playwright=True,
+ )
+
+
@pytest.mark.asyncio
async def test_is_tel_digit_fix_enabled_uses_org_keyed_rollout(monkeypatch: pytest.MonkeyPatch) -> None:
now = datetime.now(UTC)
diff --git a/tests/unit/workflow/test_code_block_recorder.py b/tests/unit/workflow/test_code_block_recorder.py
index bdd7a358c..f678eb77a 100644
--- a/tests/unit/workflow/test_code_block_recorder.py
+++ b/tests/unit/workflow/test_code_block_recorder.py
@@ -10,11 +10,14 @@ from contextlib import asynccontextmanager
from datetime import datetime, timedelta, timezone
from types import SimpleNamespace
from typing import Any
-from unittest.mock import AsyncMock
+from unittest.mock import AsyncMock, MagicMock, call
import pytest
+from playwright.async_api import BrowserContext, Locator, Page
+from playwright.async_api import TimeoutError as PlaywrightTimeoutError
from sqlalchemy import select
+from skyvern.constants import TEXT_PRESS_MAX_LENGTH
from skyvern.core.script_generations.skyvern_page import SkyvernPage
from skyvern.forge import app
from skyvern.forge.agent import ForgeAgent
@@ -35,6 +38,7 @@ from skyvern.forge.sdk.workflow.models.code_block_recorder import (
RECORDED_FAILURE_CAPTURE_MAX_CHARS,
RECORDED_FAILURE_RESPONSE_MAX_CHARS,
PendingAction,
+ PlaywrightInputDefaults,
RecordingKeyboard,
RecordingLocator,
RecordingPage,
@@ -53,6 +57,11 @@ from skyvern.schemas.workflows import BlockResult, BlockStatus
from skyvern.webeye.actions.action_types import ActionType
from skyvern.webeye.actions.actions import Action, ActionStatus, ClickAction, GotoUrlAction, InputTextAction
from skyvern.webeye.browser_artifacts import BrowserArtifacts
+from skyvern.webeye.playwright_input import (
+ PLAYWRIGHT_DEFAULT_TIMEOUT_MS,
+ playwright_input_defaults_for_page,
+ register_playwright_input_context,
+)
class FakeFrame:
@@ -66,6 +75,7 @@ class FakeElementHandle:
def __init__(self, url): # noqa: ANN001
self._url = url
self.filled: list[str] = []
+ self.typed: list[str] = []
async def owner_frame(self): # noqa: ANN201
return FakeFrame(self._url)
@@ -73,12 +83,24 @@ class FakeElementHandle:
async def fill(self, value, **kwargs): # noqa: ANN001, ANN003, ANN201
self.filled.append(value)
+ async def type(self, text, **kwargs): # noqa: ANN001, ANN003, ANN201
+ self.typed.append(text)
+
-class FakeLocator:
+class FakeLocator(Locator):
def __init__(self) -> None:
self.calls: list[str] = []
self.frame_url = "https://dash.example.com/account/login"
self.element_handle_calls = 0
+ self._page: Any = None
+
+ @property
+ def page(self) -> Any:
+ return self._page
+
+ @page.setter
+ def page(self, value: Any) -> None:
+ self._page = value
def locator(self, selector): # noqa: ANN001, ANN201
return self
@@ -103,8 +125,8 @@ class FakeLocator:
async def fill(self, value, **kwargs): # noqa: ANN001, ANN003, ANN201
self.calls.append(f"fill:{value}")
- async def type(self, value, **kwargs): # noqa: ANN001, ANN003, ANN201
- self.calls.append(f"type:{value}")
+ async def type(self, text, **kwargs): # noqa: ANN001, ANN003, ANN201
+ self.calls.append(f"type:{text}")
async def press_sequentially(self, text, **kwargs): # noqa: ANN001, ANN003, ANN201
self.calls.append(f"press_sequentially:{text}")
@@ -133,9 +155,15 @@ class FakeKeyboard:
class FakePage:
def __init__(self) -> None:
self.inner = FakeLocator()
+ self.inner.page = self
self.keyboard = FakeKeyboard()
self.url = "about:blank"
self.autocompleted: list[str] = []
+ self.context = SimpleNamespace()
+ self.default_timeout = PLAYWRIGHT_DEFAULT_TIMEOUT_MS
+
+ def set_default_timeout(self, timeout: float) -> None:
+ self.default_timeout = timeout
async def goto(self, url, **kwargs): # noqa: ANN001, ANN003, ANN201
return None
@@ -152,6 +180,9 @@ class FakePage:
async def fill(self, selector, value, **kwargs): # noqa: ANN001, ANN003, ANN201
return None
+ async def type(self, selector, text, **kwargs):
+ return None
+
def get_by_role(self, role, **kwargs): # noqa: ANN001, ANN003, ANN201
return self.inner
@@ -494,6 +525,414 @@ async def test_direct_page_actions_are_recorded_with_redaction() -> None:
assert all("[email protected]" not in (a.description or "") for a in recorded)
+async def test_copilot_recording_page_routes_fill_and_type_through_shared_strategy(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ strategy_aware_input = AsyncMock()
+ monkeypatch.setattr(
+ "skyvern.forge.sdk.workflow.models.code_block_recorder.strategy_aware_input",
+ strategy_aware_input,
+ )
+ raw_page = FakePage()
+ page = RecordingPage(raw_page, strategy_aware_typing=True)
+
+ await page.locator("#replace").fill("new", timeout=1234)
+ await page.locator("#append").type(" tail", timeout=2345)
+ await page.fill("#page-replace", "page new", timeout=3456)
+ await page.type("#page-append", " page tail", timeout=4567)
+
+ assert strategy_aware_input.await_args_list == [
+ call(raw_page.inner, "new", clear=True, timeout=1234),
+ call(raw_page.inner, " tail", clear=False, timeout=2345),
+ call(raw_page.inner, "page new", clear=True, timeout=3456),
+ call(raw_page.inner, " page tail", clear=False, timeout=4567),
+ ]
+ assert [action.action_type for action in page.recorded_actions()] == [ActionType.INPUT_TEXT] * 4
+
+
+ ("surface", "method", "timeout_form", "default_owner"),
+ [
+ pytest.param(
+ surface,
+ method,
+ timeout_form,
+ default_owner,
+ id=f"{surface}-{method}-{timeout_form}-{default_owner}-custom-default",
+ )
+ for surface in ("locator", "page")
+ for method in ("fill", "type")
+ for timeout_form in ("omitted", "none")
+ for default_owner in ("context", "page")
+ ],
+)
+async def test_copilot_recording_uses_effective_playwright_timeout_when_omitted_or_none(
+ monkeypatch: pytest.MonkeyPatch,
+ surface: str,
+ method: str,
+ timeout_form: str,
+ default_owner: str,
+) -> None:
+ strategy_aware_input = AsyncMock()
+ monkeypatch.setattr(
+ "skyvern.forge.sdk.workflow.models.code_block_recorder.strategy_aware_input",
+ strategy_aware_input,
+ )
+ raw_page = FakePage()
+ context_default = 7654
+ page_default = 8765 if default_owner == "page" else None
+ page = RecordingPage(
+ raw_page,
+ strategy_aware_typing=True,
+ playwright_input_defaults=PlaywrightInputDefaults(timeout_ms=page_default or context_default),
+ )
+ target = page.locator("#field") if surface == "locator" else page
+
+ kwargs = {} if timeout_form == "omitted" else {"timeout": None}
+ if surface == "locator":
+ await getattr(target, method)("value", **kwargs)
+ else:
+ await getattr(target, method)("#field", "value", **kwargs)
+
+ strategy_aware_input.assert_awaited_once_with(
+ raw_page.inner,
+ "value",
+ clear=method == "fill",
+ timeout=page_default or context_default,
+ )
+
+
+ ("surface", "method"),
+ [
+ pytest.param("locator", "fill", id="locator-fill-zero-timeout"),
+ pytest.param("locator", "type", id="locator-type-zero-timeout"),
+ pytest.param("page", "fill", id="page-fill-zero-timeout"),
+ pytest.param("page", "type", id="page-type-zero-timeout"),
+ ],
+)
+async def test_copilot_recording_preserves_zero_timeout(
+ monkeypatch: pytest.MonkeyPatch,
+ surface: str,
+ method: str,
+) -> None:
+ strategy_aware_input = AsyncMock()
+ monkeypatch.setattr(
+ "skyvern.forge.sdk.workflow.models.code_block_recorder.strategy_aware_input",
+ strategy_aware_input,
+ )
+ raw_page = FakePage()
+ page = RecordingPage(raw_page, strategy_aware_typing=True)
+ target = page.locator("#field") if surface == "locator" else page
+
+ if surface == "locator":
+ await getattr(target, method)("value", timeout=0)
+ else:
+ await getattr(target, method)("#field", "value", timeout=0)
+
+ strategy_aware_input.assert_awaited_once_with(
+ raw_page.inner,
+ "value",
+ clear=method == "fill",
+ timeout=0,
+ )
+
+
+async def test_copilot_recording_authored_playwright_timeout_catch_still_matches(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ raw_page = FakePage()
+ page = RecordingPage(raw_page, strategy_aware_typing=True)
+ monkeypatch.setattr(
+ "skyvern.webeye.actions.handler_utils.EventStrategyFactory.clear_field",
+ AsyncMock(side_effect=TimeoutError),
+ )
+
+ caught = False
+ try:
+ await page.locator("#field").fill("value", timeout=1234)
+ except PlaywrightTimeoutError:
+ caught = True
+
+ assert caught is True
+
+
+async def test_copilot_recording_page_preserves_page_selector_strictness(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ strategy_aware_input = AsyncMock()
+ monkeypatch.setattr(
+ "skyvern.forge.sdk.workflow.models.code_block_recorder.strategy_aware_input",
+ strategy_aware_input,
+ )
+ raw_page = MagicMock()
+ strict_locator = MagicMock(spec=Locator)
+ first_locator = MagicMock(spec=Locator)
+ strict_locator.page = raw_page
+ first_locator.page = raw_page
+ strict_locator.first = first_locator
+ raw_page.locator.return_value = strict_locator
+ page = RecordingPage(
+ raw_page,
+ strategy_aware_typing=True,
+ playwright_input_defaults=PlaywrightInputDefaults(timeout_ms=8765, strict_selectors=False),
+ )
+
+ await page.fill("#default", "default", timeout=None)
+ await page.fill("#multi", "multi", strict=False, timeout=1234)
+ await page.fill(selector="#strict", value="strict", strict=True, timeout=2345)
+
+ assert strategy_aware_input.await_args_list == [
+ call(first_locator, "default", clear=True, timeout=8765),
+ call(first_locator, "multi", clear=True, timeout=1234),
+ call(strict_locator, "strict", clear=True, timeout=2345),
+ ]
+
+
+def test_playwright_input_defaults_source_registered_runtime_context() -> None:
+ context = MagicMock(spec=BrowserContext)
+ page = MagicMock(spec=Page)
+ page.context = context
+ register_playwright_input_context(context, timeout_ms=6543, strict_selectors=True)
+
+ defaults = playwright_input_defaults_for_page(page)
+
+ assert defaults.timeout_ms == 6543
+ assert defaults.strict_selectors is True
+
+
[email protected]("method", ["fill", "type"])
[email protected]("strict_form", ["omitted", "none"])
[email protected]("context_strict", [False, True])
+async def test_copilot_recording_page_omitted_or_none_strict_uses_context_default_through_strategy(
+ monkeypatch: pytest.MonkeyPatch,
+ method: str,
+ strict_form: str,
+ context_strict: bool,
+) -> None:
+ strategy_aware_input = AsyncMock()
+ monkeypatch.setattr(
+ "skyvern.forge.sdk.workflow.models.code_block_recorder.strategy_aware_input",
+ strategy_aware_input,
+ )
+ raw_page = MagicMock()
+ strict_locator = MagicMock(spec=Locator)
+ first_locator = MagicMock(spec=Locator)
+ strict_locator.page = raw_page
+ first_locator.page = raw_page
+ strict_locator.first = first_locator
+ raw_page.locator.return_value = strict_locator
+ page = RecordingPage(
+ raw_page,
+ strategy_aware_typing=True,
+ playwright_input_defaults=PlaywrightInputDefaults(timeout_ms=4321, strict_selectors=context_strict),
+ )
+
+ kwargs = {} if strict_form == "omitted" else {"strict": None}
+ await getattr(page, method)("#multiple", "value", **kwargs)
+
+ strategy_aware_input.assert_awaited_once_with(
+ strict_locator if context_strict else first_locator,
+ "value",
+ clear=method == "fill",
+ timeout=4321,
+ )
+
+
+async def test_copilot_recording_element_handle_fill_and_type_keep_raw_playwright_behavior(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ strategy_aware_input = AsyncMock()
+ monkeypatch.setattr(
+ "skyvern.forge.sdk.workflow.models.code_block_recorder.strategy_aware_input",
+ strategy_aware_input,
+ )
+ handle = FakeElementHandle("https://example.com/form")
+ recorder = _Recorder(None, None, strategy_aware_typing=True)
+ wrapped = RecordingLocator(handle, recorder, "#field")
+
+ await wrapped.fill("replacement", timeout=1234)
+ await wrapped.type(" appended", timeout=2345)
+
+ strategy_aware_input.assert_not_awaited()
+ assert handle.filled == ["replacement"]
+ assert handle.typed == [" appended"]
+
+
+async def test_copilot_recording_routes_supported_playwright_input_options_through_strategy(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ strategy_aware_input = AsyncMock()
+ monkeypatch.setattr(
+ "skyvern.forge.sdk.workflow.models.code_block_recorder.strategy_aware_input",
+ strategy_aware_input,
+ )
+ raw_page = MagicMock()
+ raw_page.fill = AsyncMock()
+ raw_page.type = AsyncMock()
+ raw_locator = MagicMock(spec=Locator)
+ raw_locator.page = raw_page
+ raw_locator.first = raw_locator
+ raw_locator.fill = AsyncMock()
+ raw_locator.type = AsyncMock()
+ raw_page.locator.return_value = raw_locator
+ page = RecordingPage(raw_page, strategy_aware_typing=True)
+
+ await page.locator("#forced").fill("replace", force=True, timeout=None)
+ await page.locator("#delayed").type("append", delay=17, no_wait_after=True, timeout=1234)
+ await page.fill("#page-forced", "replace", force=True, strict=False, timeout=None)
+ await page.type("#page-delayed", "append", delay=23, no_wait_after=True, strict=True, timeout=2345)
+
+ assert strategy_aware_input.await_args_list == [
+ call(
+ raw_locator,
+ "replace",
+ clear=True,
+ timeout=PLAYWRIGHT_DEFAULT_TIMEOUT_MS,
+ force=True,
+ delay=None,
+ no_wait_after=None,
+ ),
+ call(
+ raw_locator,
+ "append",
+ clear=False,
+ timeout=1234,
+ force=None,
+ delay=17,
+ no_wait_after=True,
+ ),
+ call(
+ raw_locator,
+ "replace",
+ clear=True,
+ timeout=PLAYWRIGHT_DEFAULT_TIMEOUT_MS,
+ force=True,
+ delay=None,
+ no_wait_after=None,
+ ),
+ call(
+ raw_locator,
+ "append",
+ clear=False,
+ timeout=2345,
+ force=None,
+ delay=23,
+ no_wait_after=True,
+ ),
+ ]
+ raw_locator.fill.assert_not_awaited()
+ raw_locator.type.assert_not_awaited()
+ raw_page.fill.assert_not_awaited()
+ raw_page.type.assert_not_awaited()
+
+
+async def test_recording_page_tracks_runtime_default_timeout_for_strategy_input(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ strategy_aware_input = AsyncMock()
+ monkeypatch.setattr(
+ "skyvern.forge.sdk.workflow.models.code_block_recorder.strategy_aware_input",
+ strategy_aware_input,
+ )
+ raw_page = MagicMock(spec=Page)
+ raw_page.set_default_timeout = MagicMock()
+ locator = MagicMock(spec=Locator)
+ locator.page = raw_page
+ locator.first = locator
+ raw_page.locator.return_value = locator
+ page = RecordingPage(raw_page, strategy_aware_typing=True)
+
+ page.set_default_timeout(9876)
+ await page.fill("#name", "Noor")
+
+ raw_page.set_default_timeout.assert_called_once_with(9876)
+ strategy_aware_input.assert_awaited_once_with(locator, "Noor", clear=True, timeout=9876)
+
+
+async def test_recording_context_tracks_runtime_default_timeout_for_strategy_input(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ strategy_aware_input = AsyncMock()
+ monkeypatch.setattr(
+ "skyvern.forge.sdk.workflow.models.code_block_recorder.strategy_aware_input",
+ strategy_aware_input,
+ )
+ raw_page = MagicMock(spec=Page)
+ raw_context = MagicMock()
+ raw_context.set_default_timeout = MagicMock()
+ raw_page.context = raw_context
+ locator = MagicMock(spec=Locator)
+ locator.page = raw_page
+ locator.first = locator
+ raw_page.locator.return_value = locator
+ page = RecordingPage(raw_page, strategy_aware_typing=True)
+
+ page.context.set_default_timeout(7654)
+ await page.fill("#name", "Noor")
+
+ raw_context.set_default_timeout.assert_called_once_with(7654)
+ strategy_aware_input.assert_awaited_once_with(locator, "Noor", clear=True, timeout=7654)
+
+
+ ("surface", "method", "malformed_call"),
+ [
+ ("locator", "fill", "duplicate"),
+ ("locator", "fill", "extra_positional"),
+ ("locator", "type", "duplicate"),
+ ("locator", "type", "extra_positional"),
+ ("page", "fill", "duplicate"),
+ ("page", "fill", "extra_positional"),
+ ("page", "type", "duplicate"),
+ ("page", "type", "extra_positional"),
+ ],
+)
+async def test_copilot_recording_rejects_malformed_playwright_input_before_strategy_side_effect(
+ monkeypatch: pytest.MonkeyPatch,
+ surface: str,
+ method: str,
+ malformed_call: str,
+) -> None:
+ strategy_aware_input = AsyncMock()
+ monkeypatch.setattr(
+ "skyvern.forge.sdk.workflow.models.code_block_recorder.strategy_aware_input",
+ strategy_aware_input,
+ )
+ raw_page = FakePage()
+ guard = CredentialReleaseGuard()
+ enforce_credential_release = AsyncMock()
+ monkeypatch.setattr(guard, "enforce", enforce_credential_release)
+ page = RecordingPage(raw_page, credential_release_guard=guard, strategy_aware_typing=True)
+ target = page.locator("#field") if surface == "locator" else page
+
+ with pytest.raises(TypeError):
+ if surface == "locator":
+ if malformed_call == "duplicate":
+ await getattr(target, method)("first", **{"value" if method == "fill" else "text": "second"})
+ else:
+ await getattr(target, method)("first", 1000)
+ elif malformed_call == "duplicate":
+ await getattr(target, method)("#field", "first", selector="#other")
+ else:
+ await getattr(target, method)("#field", "first", 1000)
+
+ strategy_aware_input.assert_not_awaited()
+ enforce_credential_release.assert_not_awaited()
+ assert raw_page.inner.calls == []
+
+
@pytest.mark.asyncio
async def test_filter_locator_chain_click_is_recorded() -> None:
page = RecordingPage(FakePage())
@@ -622,6 +1061,72 @@ async def test_input_values_are_elided_from_descriptions() -> None:
assert recorded[1].description == "locator.type #user"
+async def test_copilot_authored_fill_and_type_share_strategy_aware_typing(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ fake = FakePage()
+ page = RecordingPage(fake, strategy_aware_typing=True)
+ clear_field = AsyncMock()
+ type_text = AsyncMock()
+ monkeypatch.setattr(
+ "skyvern.webeye.actions.handler_utils.EventStrategyFactory.clear_field",
+ clear_field,
+ )
+ monkeypatch.setattr(
+ "skyvern.webeye.actions.handler_utils.EventStrategyFactory.type_text",
+ type_text,
+ )
+
+ await page.locator("#replace").fill("new")
+ await page.locator("#append").type("more", timeout=1234)
+
+ assert clear_field.await_args_list == [call(fake, fake.inner, char_count=0, timeout=PLAYWRIGHT_DEFAULT_TIMEOUT_MS)]
+ assert type_text.await_args_list == [
+ call(
+ fake,
+ fake.inner,
+ "new",
+ timeout=PLAYWRIGHT_DEFAULT_TIMEOUT_MS,
+ allow_batched_playwright=True,
+ ),
+ call(fake, fake.inner, "more", timeout=1234, allow_batched_playwright=True),
+ ]
+ assert fake.inner.calls == []
+ assert [action.action_type for action in page.recorded_actions()] == [
+ ActionType.INPUT_TEXT,
+ ActionType.INPUT_TEXT,
+ ]
+
+
+async def test_copilot_authored_page_fill_keeps_one_action_and_long_value_split(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ text = "a" * (TEXT_PRESS_MAX_LENGTH + 3)
+ fake = FakePage()
+ page = RecordingPage(fake, strategy_aware_typing=True)
+ type_text = AsyncMock()
+ monkeypatch.setattr(
+ "skyvern.webeye.actions.handler_utils.EventStrategyFactory.type_text",
+ type_text,
+ )
+
+ await page.fill("#replace", text, strict=False, timeout=2468)
+
+ assert fake.inner.calls == [f"fill:{text[:-TEXT_PRESS_MAX_LENGTH]}"]
+ type_text.assert_awaited_once_with(
+ fake,
+ fake.inner,
+ text[-TEXT_PRESS_MAX_LENGTH:],
+ timeout=2468,
+ allow_batched_playwright=True,
+ )
+ [action] = page.recorded_actions()
+ assert action.action_type == ActionType.INPUT_TEXT
+ assert action.element_id == "#replace"
+
+
def _make_code_block(code: str, goal: str | None = None) -> CodeBlock:
now = datetime.now(timezone.utc)
output_parameter = OutputParameter(
@@ -774,6 +1279,52 @@ async def test_goal_code_block_creates_task_and_links_block(monkeypatch: pytest.
assert linked == ["tsk_code"]
+async def test_copilot_lineage_tracks_runtime_timeout_during_code_block_execution(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ page = FakePage()
+ context = FakeWorkflowRunContext()
+ _patch_execute_environment(monkeypatch, page, context)
+ copilot_authored = AsyncMock(return_value=True)
+ clear_field = AsyncMock()
+ type_text = AsyncMock()
+ monkeypatch.setattr(CodeBlock, "_workflow_is_copilot_authored", copilot_authored)
+ monkeypatch.setattr("skyvern.webeye.actions.handler_utils.EventStrategyFactory.clear_field", clear_field)
+ monkeypatch.setattr("skyvern.webeye.actions.handler_utils.EventStrategyFactory.type_text", type_text)
+ setter_block = _make_code_block("page.set_default_timeout(8765)")
+ input_block = _make_code_block("await page.locator('#name').fill('Noor')")
+
+ setter_result = await setter_block.execute(
+ workflow_run_id="wr_test",
+ workflow_run_block_id="wrb_test",
+ organization_id="o_test",
+ )
+ input_result = await input_block.execute(
+ workflow_run_id="wr_test",
+ workflow_run_block_id="wrb_test_2",
+ organization_id="o_test",
+ )
+
+ assert setter_result.success is True
+ assert input_result.success is True
+ assert copilot_authored.await_args_list == [call(context), call(context)]
+ clear_field.assert_awaited_once_with(
+ page,
+ page.inner,
+ char_count=0,
+ timeout=8765,
+ )
+ type_text.assert_awaited_once_with(
+ page,
+ page.inner,
+ "Noor",
+ timeout=8765,
+ allow_batched_playwright=True,
+ )
+ assert page.default_timeout == 8765
+
+
@pytest.mark.asyncio
async def test_create_task_and_step_from_code_block_maps_goal_to_task(monkeypatch: pytest.MonkeyPatch) -> None:
"""The container task carries the code block goal as its navigation goal so the agent can resume it."""