Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
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.pyindex 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_contextfrom skyvern.schemas.action_log import ActionLogOutcome, project_action_eventfrom skyvern.schemas.run_blocks import CredentialTypefrom skyvern.utils.url_validators import validate_fetch_url+from skyvern.webeye.actions.handler_utils import strategy_aware_inputfrom ._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_firstdeterministic = 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 Nonewith 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.pyindex 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.pyindex 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.pyindex 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)+ returnfor 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.pyindex 22d1a5d0c..96e8f9045 100644--- a/skyvern/forge/sdk/event/factory.py+++ b/skyvern/forge/sdk/event/factory.py@@ -4,6 +4,7 @@ import structlogfrom opentelemetry import metricsfrom playwright.async_api import Locator, Page+from skyvern.config import settingsfrom skyvern.forge.sdk.event.base import CursorEventStrategy, InputEventStrategy, ScrollEventStrategyfrom skyvern.forge.sdk.event.default import DefaultCursorStrategy, DefaultInputStrategy, DefaultScrollStrategyfrom 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.pyindex 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_likefrom skyvern.webeye.browser_state import BrowserState, get_browser_state_diagnosticfrom skyvern.webeye.cdp_download_interceptor import normalize_download_filename, settle_browser_downloads_for_contextfrom skyvern.webeye.navigation import default_navigation_settle, navigate_with_retry, redact_url_secrets+from skyvern.webeye.playwright_input import playwright_input_defaults_for_pagefrom skyvern.webeye.real_browser_state import RealBrowserStatefrom skyvern.webeye.utils.captcha_solver import CaptchaChallengeUnsolvedError, solve_challenge_ladderfrom 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 Trueexcept 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 Nonerecorder = 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.pyindex 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 asyncioimport inspectimport sysimport time+from collections.abc import Awaitable, Callablefrom dataclasses import dataclassfrom os import PathLike, fspathfrom types import FrameType-from typing import Any, Awaitable, Callable+from typing import Any, Literal, castimport pydanticimport structlog+from playwright.async_api import BrowserContext, Locator, Pagefrom skyvern.forge.sdk.db.datetime_utils import naive_utc_nowfrom skyvern.forge.sdk.db.id import generate_action_idfrom skyvern.forge.sdk.workflow.models.credential_release import CredentialReleaseGuardfrom skyvern.webeye.actions.action_types import ActionTypefrom skyvern.webeye.actions.actions import Action, ActionStatus, SelectOption+from skyvern.webeye.actions.handler_utils import strategy_aware_input+from skyvern.webeye.playwright_input import PlaywrightInputDefaultsLOG = 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 - 2CODE_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 = Noneself._on_action = on_actionself._on_pending_action = on_pending_actionself.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_timeoutif 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.pyindex 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 TaskStatusfrom 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_blockself._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.pyindex 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, Literalimport structlogfrom playwright.async_api import Locator, Page+from playwright.async_api import TimeoutError as PlaywrightTimeoutErrorfrom skyvern.config import settingsfrom skyvern.constants import TEXT_PRESS_MAX_LENGTH@@ -14,6 +15,17 @@ from skyvern.webeye.actions.actions import Action, KeypressActionLOG = 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.pyindex 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_contextfrom skyvern.webeye.dialog_handler import set_dialog_handler+from skyvern.webeye.playwright_input import register_playwright_input_contextfrom skyvern.webeye.session_cookies import restore_banked_cookies, restore_session_cookiesLOG = 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.pynew file mode 100644index 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 defaultsdiff --git a/tests/unit/test_browser_context_factory_marker.py b/tests/unit/test_browser_context_factory_marker.pyindex 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 Anyfrom unittest.mock import AsyncMock, MagicMockimport pytest+from playwright.async_api import BrowserContext, Locator, Page+from skyvern.forge.sdk.workflow.models.code_block_recorder import RecordingPagefrom 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.asyncioasync 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 BrowserContextFactoryasync 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.asyncioasync 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 BrowserContextFactorymonkeypatch.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_wrappedis still wrapped in ``UnknownErrorWhileCreatingBrowserContext`` as before."""from skyvern.exceptions import UnknownErrorWhileCreatingBrowserContextfrom skyvern.webeye.browser_engine import BrowserEngineBootstrapError- from skyvern.webeye.browser_factory import BrowserContextFactoryasync 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.pyindex 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()) == 162handler_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_CANDIDATESassert 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()) == 157def 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()) == 27def 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.pyindex 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.pyindex 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 = Noneworkflow_run_outputs: list[object] = []+ workflow = Nonedef 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 = Nonedef 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.pyindex 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) -> dicworkflow_run_id = "wr_executor_witness"browser_session_id = Noneworkflow_run_outputs: list[object] = []+ workflow = Nonedef 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.pyindex 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_browserfrom skyvern.cli.mcp_tools import cdp_input as mcp_cdp_inputfrom skyvern.cli.mcp_tools import mcpfrom skyvern.client.errors import InternalServerError, UnprocessableEntityError+from skyvern.config import settings+from skyvern.constants import TEXT_PRESS_MAX_LENGTHfrom skyvern.forge.sdk.forge_log import codeblock_parameter_log_redactionfrom 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.asynciodiff --git a/tests/unit/test_mcp_trajectory.py b/tests/unit/test_mcp_trajectory.pyindex 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 = locatorraw_page = SimpleNamespace(locator=MagicMock(return_value=locator))+ locator.page = raw_pagepage = 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 pagediff --git a/tests/unit/test_tel_input_bare_digits.py b/tests/unit/test_tel_input_bare_digits.pyindex 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 asynccontextmanagerfrom datetime import UTC, datetimefrom types import SimpleNamespace-from unittest.mock import AsyncMock, MagicMock+from unittest.mock import AsyncMock, MagicMock, callimport pytest+from playwright.async_api import TimeoutError as PlaywrightTimeoutError+from skyvern.constants import TEXT_INPUT_DELAY+from skyvern.forge.sdk.event.default import DefaultInputStrategyfrom skyvern.webeye.actions import handler_utilsfrom skyvern.webeye.actions.handler import (_is_tel_digit_fix_enabled,@@ -172,6 +177,357 @@ async def test_input_sequentially_fill_splits_separator_formatted_value(monkeypaassert 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.asyncioasync 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.pyindex 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 asynccontextmanagerfrom datetime import datetime, timedelta, timezonefrom types import SimpleNamespacefrom typing import Any-from unittest.mock import AsyncMock+from unittest.mock import AsyncMock, MagicMock, callimport pytest+from playwright.async_api import BrowserContext, Locator, Page+from playwright.async_api import TimeoutError as PlaywrightTimeoutErrorfrom sqlalchemy import select+from skyvern.constants import TEXT_PRESS_MAX_LENGTHfrom skyvern.core.script_generations.skyvern_page import SkyvernPagefrom skyvern.forge import appfrom 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, BlockStatusfrom skyvern.webeye.actions.action_types import ActionTypefrom skyvern.webeye.actions.actions import Action, ActionStatus, ClickAction, GotoUrlAction, InputTextActionfrom 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: ANN001self._url = urlself.filled: list[str] = []+ self.typed: list[str] = []async def owner_frame(self): # noqa: ANN201return FakeFrame(self._url)@@ -73,12 +83,24 @@ class FakeElementHandle:async def fill(self, value, **kwargs): # noqa: ANN001, ANN003, ANN201self.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 = valuedef locator(self, selector): # noqa: ANN001, ANN201return self@@ -103,8 +125,8 @@ class FakeLocator:async def fill(self, value, **kwargs): # noqa: ANN001, ANN003, ANN201self.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, ANN201self.calls.append(f"press_sequentially:{text}")@@ -133,9 +155,15 @@ class FakeKeyboard:class FakePage:def __init__(self) -> None:self.inner = FakeLocator()+ self.inner.page = selfself.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 = timeoutasync def goto(self, url, **kwargs): # noqa: ANN001, ANN003, ANN201return None@@ -152,6 +180,9 @@ class FakePage:async def fill(self, selector, value, **kwargs): # noqa: ANN001, ANN003, ANN201return None+ async def type(self, selector, text, **kwargs):+ return None+def get_by_role(self, role, **kwargs): # noqa: ANN001, ANN003, ANN201return 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.asyncioasync 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.asyncioasync 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."""