Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
fix: remove skyvern/cli from pyupgrade exclude list and fix violations (#5236)
Celal Zamanoğlue909d3e4a171
diff --git a/skyvern-frontend/src/routes/workflows/editor/nodes/ActionNode/ActionNode.tsx b/skyvern-frontend/src/routes/workflows/editor/nodes/ActionNode/ActionNode.tsxindex f83d0518f..c54df6deb 100644--- a/skyvern-frontend/src/routes/workflows/editor/nodes/ActionNode/ActionNode.tsx+++ b/skyvern-frontend/src/routes/workflows/editor/nodes/ActionNode/ActionNode.tsx@@ -190,6 +190,11 @@ function ActionNode({ id, data, type }: NodeProps<ActionNode>) {onParametersChange={(parameterKeys) => {update({ parameterKeys });}}+ onCredentialTotpIdentifier={(totpIdentifier) => {+ if (!data.totpIdentifier?.trim()) {+ update({ totpIdentifier });+ }+ }}/></div><div className="flex items-center justify-between">diff --git a/skyvern-frontend/src/routes/workflows/editor/nodes/FileDownloadNode/FileDownloadNode.tsx b/skyvern-frontend/src/routes/workflows/editor/nodes/FileDownloadNode/FileDownloadNode.tsxindex 63106188b..ee39ba007 100644--- a/skyvern-frontend/src/routes/workflows/editor/nodes/FileDownloadNode/FileDownloadNode.tsx+++ b/skyvern-frontend/src/routes/workflows/editor/nodes/FileDownloadNode/FileDownloadNode.tsx@@ -202,6 +202,11 @@ function FileDownloadNode({ id, data }: NodeProps<FileDownloadNode>) {onParametersChange={(parameterKeys) => {update({ parameterKeys });}}+ onCredentialTotpIdentifier={(totpIdentifier) => {+ if (!data.totpIdentifier?.trim()) {+ update({ totpIdentifier });+ }+ }}/></div><div className="flex items-center justify-between">diff --git a/skyvern-frontend/src/routes/workflows/editor/nodes/LoginNode/LoginBlockCredentialSelector.tsx b/skyvern-frontend/src/routes/workflows/editor/nodes/LoginNode/LoginBlockCredentialSelector.tsxindex f54747589..c7b54f289 100644--- a/skyvern-frontend/src/routes/workflows/editor/nodes/LoginNode/LoginBlockCredentialSelector.tsx+++ b/skyvern-frontend/src/routes/workflows/editor/nodes/LoginNode/LoginBlockCredentialSelector.tsx@@ -36,6 +36,10 @@ type Props = {onUrlAutoFill?: (url: string) => void;/** Current URL value of the login block — skip auto-fill if already set */currentUrl?: string;+ /** Called when a credential with a totp_identifier is selected to auto-fill the 2FA identifier */+ onTotpIdentifierAutoFill?: (totpIdentifier: string) => void;+ /** Current totp_identifier value — skip auto-fill if already set */+ currentTotpIdentifier?: string;};// Function to generate a unique credential parameter key@@ -62,6 +66,8 @@ function LoginBlockCredentialSelector({onChange,onUrlAutoFill,currentUrl,+ onTotpIdentifierAutoFill,+ currentTotpIdentifier,}: Props) {const { setIsOpen, setType } = useCredentialModalState();const nodes = useNodes<AppNode>();@@ -131,6 +137,11 @@ function LoginBlockCredentialSelector({type: "credential" as const,hasBrowserProfile: !!credential.browser_profile_id,browserProfileUrl: credential.tested_url ?? null,+ totpIdentifier:+ credential.credential_type === "password" &&+ "totp_identifier" in credential.credential+ ? credential.credential.totp_identifier ?? null+ : null,}));// Only show non-Skyvern credential parameters (Bitwarden, 1Password, Azure Vault)@@ -250,6 +261,16 @@ function LoginBlockCredentialSelector({) {onUrlAutoFill?.(selectedCredential.browserProfileUrl);}++ // Auto-fill the 2FA identifier from the credential's totp_identifier+ // when the field is empty.+ if (+ selectedCredential &&+ !currentTotpIdentifier?.trim() &&+ selectedCredential.totpIdentifier+ ) {+ onTotpIdentifierAutoFill?.(selectedCredential.totpIdentifier);+ }}}><SelectTriggerdiff --git a/skyvern-frontend/src/routes/workflows/editor/nodes/LoginNode/LoginNode.tsx b/skyvern-frontend/src/routes/workflows/editor/nodes/LoginNode/LoginNode.tsxindex 8f8ed3800..a1caef7bc 100644--- a/skyvern-frontend/src/routes/workflows/editor/nodes/LoginNode/LoginNode.tsx+++ b/skyvern-frontend/src/routes/workflows/editor/nodes/LoginNode/LoginNode.tsx@@ -162,6 +162,12 @@ function LoginNode({ id, data, type }: NodeProps<LoginNode>) {update({ url });}}}+ currentTotpIdentifier={data.totpIdentifier ?? undefined}+ onTotpIdentifierAutoFill={(totpIdentifier) => {+ if (editable) {+ update({ totpIdentifier });+ }+ }}/></div></div>@@ -191,6 +197,11 @@ function LoginNode({ id, data, type }: NodeProps<LoginNode>) {onParametersChange={(parameterKeys) => {update({ parameterKeys });}}+ onCredentialTotpIdentifier={(totpIdentifier) => {+ if (!data.totpIdentifier?.trim()) {+ update({ totpIdentifier });+ }+ }}/></div><div className="space-y-2">diff --git a/skyvern-frontend/src/routes/workflows/editor/nodes/NavigationNode/NavigationNode.tsx b/skyvern-frontend/src/routes/workflows/editor/nodes/NavigationNode/NavigationNode.tsxindex f6d6bdcd5..2fb120fbc 100644--- a/skyvern-frontend/src/routes/workflows/editor/nodes/NavigationNode/NavigationNode.tsx+++ b/skyvern-frontend/src/routes/workflows/editor/nodes/NavigationNode/NavigationNode.tsx@@ -347,6 +347,11 @@ function NavigationNode({ id, data, type }: NodeProps<NavigationNode>) {onParametersChange={(parameterKeys) => {update({ parameterKeys });}}+ onCredentialTotpIdentifier={(totpIdentifier) => {+ if (!data.totpIdentifier?.trim()) {+ update({ totpIdentifier });+ }+ }}/></div><div className="space-y-2">diff --git a/skyvern-frontend/src/routes/workflows/editor/nodes/TaskNode/ParametersMultiSelect.tsx b/skyvern-frontend/src/routes/workflows/editor/nodes/TaskNode/ParametersMultiSelect.tsxindex f94c1b55a..60e86e90b 100644--- a/skyvern-frontend/src/routes/workflows/editor/nodes/TaskNode/ParametersMultiSelect.tsx+++ b/skyvern-frontend/src/routes/workflows/editor/nodes/TaskNode/ParametersMultiSelect.tsx@@ -3,7 +3,7 @@ import { useWorkflowParametersStore } from "@/store/WorkflowParametersStore";import { HelpTooltip } from "@/components/HelpTooltip";import { helpTooltips } from "../../helpContent";import { useCredentialsQuery } from "@/routes/workflows/hooks/useCredentialsQuery";-import { useContext, useMemo } from "react";+import { useCallback, useContext, useMemo } from "react";import CloudContext from "@/store/CloudContext";import { parameterIsSkyvernCredential } from "../../types";@@ -11,12 +11,15 @@ type Props = {availableOutputParameters: Array<string>;parameters: Array<string>;onParametersChange: (parameters: Array<string>) => void;+ /** Called when a credential parameter with a totp_identifier is added */+ onCredentialTotpIdentifier?: (totpIdentifier: string) => void;};function ParametersMultiSelect({availableOutputParameters,parameters,onParametersChange,+ onCredentialTotpIdentifier,}: Props) {const isCloud = useContext(CloudContext);const { parameters: workflowParameters } = useWorkflowParametersStore();@@ -57,6 +60,47 @@ function ParametersMultiSelect({});}, [keys, workflowParameters, isSuccess, credentialIdsInVault]);+ const handleValueChange = useCallback(+ (newParameters: Array<string>) => {+ onParametersChange(newParameters);++ // Check if a credential parameter was newly added+ if (onCredentialTotpIdentifier) {+ const addedKeys = newParameters.filter(+ (key) => !parameters.includes(key),+ );+ for (const key of addedKeys) {+ const param = workflowParameters.find((p) => p.key === key);+ if (+ param &&+ param.parameterType === "credential" &&+ parameterIsSkyvernCredential(param)+ ) {+ const credential = credentials.find(+ (c) => c.credential_id === param.credentialId,+ );+ if (+ credential &&+ credential.credential_type === "password" &&+ "totp_identifier" in credential.credential &&+ credential.credential.totp_identifier+ ) {+ onCredentialTotpIdentifier(credential.credential.totp_identifier);+ break;+ }+ }+ }+ }+ },+ [+ onParametersChange,+ onCredentialTotpIdentifier,+ parameters,+ workflowParameters,+ credentials,+ ],+ );+return (<div className="space-y-2"><header className="flex gap-2">@@ -65,7 +109,7 @@ function ParametersMultiSelect({</header><MultiSelectvalue={parameters}- onValueChange={onParametersChange}+ onValueChange={handleValueChange}options={options}maxCount={50}/>diff --git a/skyvern-frontend/src/routes/workflows/editor/nodes/TaskNode/TaskNode.tsx b/skyvern-frontend/src/routes/workflows/editor/nodes/TaskNode/TaskNode.tsxindex d5f3632ef..b6720f877 100644--- a/skyvern-frontend/src/routes/workflows/editor/nodes/TaskNode/TaskNode.tsx+++ b/skyvern-frontend/src/routes/workflows/editor/nodes/TaskNode/TaskNode.tsx@@ -159,6 +159,11 @@ function TaskNode({ id, data, type }: NodeProps<TaskNode>) {onParametersChange={(parameterKeys) => {update({ parameterKeys });}}+ onCredentialTotpIdentifier={(totpIdentifier) => {+ if (!data.totpIdentifier?.trim()) {+ update({ totpIdentifier });+ }+ }}/></div></div>diff --git a/skyvern/constants.py b/skyvern/constants.pyindex bade3349b..49d5111cf 100644--- a/skyvern/constants.py+++ b/skyvern/constants.py@@ -42,7 +42,9 @@ EXTRACT_ACTION_SCROLL_AMOUNT = 500 # pixels per scroll action from extract-acti# Text input constantsTEXT_INPUT_DELAY = 10 # 10ms between each character input-TEXT_PRESS_MAX_LENGTH = 20+# Number of trailing characters typed keystroke-by-keystroke (the rest use fill()).+# 10 chars yield 9 inter-key intervals, balancing speed with realistic input cadence.+TEXT_PRESS_MAX_LENGTH = 10# Script generation constantsDEFAULT_SCRIPT_RUN_ID = "default"diff --git a/skyvern/core/script_generations/skyvern_page.py b/skyvern/core/script_generations/skyvern_page.pyindex b58ed9cbb..c2bec6c8d 100644--- a/skyvern/core/script_generations/skyvern_page.py+++ b/skyvern/core/script_generations/skyvern_page.py@@ -23,6 +23,7 @@ from skyvern.forge import appfrom skyvern.forge.prompts import prompt_enginefrom skyvern.forge.sdk.api.files import download_file as download_file_from_urlfrom skyvern.forge.sdk.core import skyvern_context+from skyvern.forge.sdk.event.factory import EventStrategyFactoryfrom skyvern.library.ai_locator import AILocatorfrom skyvern.webeye.actions import handler_utilsfrom skyvern.webeye.actions.action_types import ActionType@@ -3269,7 +3270,7 @@ class SkyvernPage(Page):y: int,**kwargs: Any,) -> None:- await self.page.mouse.move(x, y)+ await EventStrategyFactory.move_cursor(self.page, x, y)@action_wrap(ActionType.DRAG)async def drag(diff --git a/skyvern/forge/sdk/event/__init__.py b/skyvern/forge/sdk/event/__init__.pynew file mode 100644index 000000000..e69de29bbdiff --git a/skyvern/forge/sdk/event/base.py b/skyvern/forge/sdk/event/base.pynew file mode 100644index 000000000..a7767ca2d--- /dev/null+++ b/skyvern/forge/sdk/event/base.py@@ -0,0 +1,49 @@+from abc import ABC, abstractmethod++from playwright.async_api import Locator, Page+++class CursorEventStrategy(ABC):+ """Strategy for dispatching cursor events to a page."""++ @abstractmethod+ async def move_to(self, page: Page, x: float, y: float) -> None:+ pass++ def sync_position(self, page: Page, x: float, y: float) -> None:+ """Notify the strategy that the cursor is now at (x, y) without generating movement.++ Override in stateful strategies that track cursor position.+ """++ @abstractmethod+ async def move_to_element(self, page: Page, locator: Locator) -> tuple[float, float]:+ pass++ @abstractmethod+ async def click(self, page: Page, locator: Locator) -> None:+ pass+++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++ @abstractmethod+ async def clear_field(self, page: Page, locator: Locator, char_count: int) -> None:+ pass+++class ScrollEventStrategy(ABC):+ """Strategy for dispatching scroll events to a page."""++ @abstractmethod+ async def scroll_to_element(self, page: Page, locator: Locator) -> None:+ pass++ @abstractmethod+ async def scroll_by(self, page: Page, delta_y: float) -> None:+ passdiff --git a/skyvern/forge/sdk/event/default.py b/skyvern/forge/sdk/event/default.pynew file mode 100644index 000000000..5a3b5f007--- /dev/null+++ b/skyvern/forge/sdk/event/default.py@@ -0,0 +1,62 @@+"""Default event strategies that delegate to standard Playwright calls.++These are used as fallbacks when no custom strategy is registered or when+the feature flag disables custom strategies at runtime.+"""++import structlog+from playwright.async_api import Locator, Page++from skyvern.config import settings+from skyvern.constants import TEXT_INPUT_DELAY+from skyvern.forge.sdk.event.base import CursorEventStrategy, InputEventStrategy, ScrollEventStrategy++LOG = structlog.get_logger(__name__)+++class DefaultCursorStrategy(CursorEventStrategy):+ """Cursor strategy that uses plain Playwright mouse movement."""++ async def move_to(self, page: Page, x: float, y: float) -> None:+ await page.mouse.move(x, y)++ async def move_to_element(self, page: Page, locator: Locator) -> tuple[float, float]:+ try:+ bbox = await locator.bounding_box()+ if bbox is None:+ LOG.debug("move_to_element: element has no bounding box, skipping")+ return 0.0, 0.0+ x = bbox["x"] + bbox["width"] / 2+ y = bbox["y"] + bbox["height"] / 2+ await page.mouse.move(x, y)+ return x, y+ except Exception:+ LOG.debug("move_to_element failed", exc_info=True)+ return 0.0, 0.0++ async def click(self, page: Page, locator: Locator) -> None:+ await locator.click()+++class DefaultInputStrategy(InputEventStrategy):+ """Input strategy that uses plain Playwright typing."""++ async def type_text(self, page: Page, locator: Locator | None, text: str) -> None:+ if locator is not None:+ for char in text:+ await locator.type(char, delay=TEXT_INPUT_DELAY, timeout=settings.BROWSER_ACTION_TIMEOUT_MS)+ 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)+++class DefaultScrollStrategy(ScrollEventStrategy):+ """Scroll strategy that uses plain Playwright wheel events."""++ async def scroll_to_element(self, page: Page, locator: Locator) -> None:+ await locator.scroll_into_view_if_needed()++ async def scroll_by(self, page: Page, delta_y: float) -> None:+ await page.mouse.wheel(0, delta_y)diff --git a/skyvern/forge/sdk/event/factory.py b/skyvern/forge/sdk/event/factory.pynew file mode 100644index 000000000..a61354978--- /dev/null+++ b/skyvern/forge/sdk/event/factory.py@@ -0,0 +1,102 @@+import structlog+from playwright.async_api import Locator, Page++from skyvern.forge.sdk.event.base import CursorEventStrategy, InputEventStrategy, ScrollEventStrategy+from skyvern.forge.sdk.event.default import DefaultCursorStrategy, DefaultInputStrategy, DefaultScrollStrategy++LOG = structlog.get_logger(__name__)++_default_cursor = DefaultCursorStrategy()+_default_input = DefaultInputStrategy()+_default_scroll = DefaultScrollStrategy()+++class EventStrategyFactory:+ __cursor: CursorEventStrategy | None = None+ __input: InputEventStrategy | None = None+ __scroll: ScrollEventStrategy | None = None++ # -- setters ----------------------------------------------------------------++ @staticmethod+ def set_cursor_strategy(strategy: CursorEventStrategy) -> None:+ EventStrategyFactory.__cursor = strategy++ @staticmethod+ def set_input_strategy(strategy: InputEventStrategy) -> None:+ EventStrategyFactory.__input = strategy++ @staticmethod+ def set_scroll_strategy(strategy: ScrollEventStrategy) -> None:+ EventStrategyFactory.__scroll = strategy++ @staticmethod+ def reset() -> None:+ """Clear all custom strategies, reverting to defaults."""+ EventStrategyFactory.__cursor = None+ EventStrategyFactory.__input = None+ EventStrategyFactory.__scroll = None++ # -- getters (always return a non-None strategy) ----------------------------++ @staticmethod+ def get_cursor_strategy() -> CursorEventStrategy:+ return EventStrategyFactory.__cursor or _default_cursor++ @staticmethod+ def get_input_strategy() -> InputEventStrategy:+ return EventStrategyFactory.__input or _default_input++ @staticmethod+ def get_scroll_strategy() -> ScrollEventStrategy:+ return EventStrategyFactory.__scroll or _default_scroll++ # -- cursor convenience methods ---------------------------------------------++ @staticmethod+ async def move_cursor(page: Page, x: float, y: float) -> None:+ """Move cursor using the active strategy."""+ await EventStrategyFactory.get_cursor_strategy().move_to(page, x, y)++ @staticmethod+ async def move_to_element(page: Page, locator: Locator) -> None:+ """Move cursor to element. Failures are logged and swallowed."""+ try:+ await EventStrategyFactory.get_cursor_strategy().move_to_element(page, locator)+ except Exception:+ LOG.debug("Cursor move_to_element failed, proceeding with action", exc_info=True)++ @staticmethod+ def sync_cursor_position(page: Page, x: float, y: float) -> None:+ """Update cursor position without generating movement."""+ EventStrategyFactory.get_cursor_strategy().sync_position(page, x, y)++ # -- input convenience methods ----------------------------------------------++ @staticmethod+ async def type_text(page: Page, locator: Locator | None, text: str) -> None:+ """Type text using the active input strategy."""+ await EventStrategyFactory.get_input_strategy().type_text(page, locator, text)++ @staticmethod+ async def clear_field(page: Page, locator: Locator, char_count: int) -> None:+ """Clear field using the active input strategy."""+ await EventStrategyFactory.get_input_strategy().clear_field(page, locator, char_count)++ # -- scroll convenience methods ---------------------------------------------++ @staticmethod+ async def scroll_by(page: Page, scroll_x: float, scroll_y: float) -> None:+ """Scroll using the active strategy for vertical-only, raw wheel for horizontal."""+ if scroll_x == 0:+ await EventStrategyFactory.get_scroll_strategy().scroll_by(page, scroll_y)+ else:+ await page.mouse.wheel(scroll_x, scroll_y)++ @staticmethod+ async def scroll_to_element(page: Page, locator: Locator) -> None:+ """Scroll to element using the active strategy. Failures are logged and swallowed."""+ try:+ await EventStrategyFactory.get_scroll_strategy().scroll_to_element(page, locator)+ except Exception:+ LOG.debug("scroll_to_element failed, proceeding with action", exc_info=True)diff --git a/skyvern/forge/sdk/routes/credentials.py b/skyvern/forge/sdk/routes/credentials.pyindex 2f0fff61b..42d979428 100644--- a/skyvern/forge/sdk/routes/credentials.py+++ b/skyvern/forge/sdk/routes/credentials.py@@ -313,6 +313,7 @@ async def create_credential(credential_response = PasswordCredentialResponse(username=data.credential.username,totp_type=data.credential.totp_type if hasattr(data.credential, "totp_type") else "none",+ totp_identifier=data.credential.totp_identifier if hasattr(data.credential, "totp_identifier") else None,)return CredentialResponse(credential=credential_response,@@ -1860,6 +1861,7 @@ def _convert_to_response(credential: Credential) -> CredentialResponse:credential_response = PasswordCredentialResponse(username=credential.username or credential.credential_id,totp_type=credential.totp_type,+ totp_identifier=credential.totp_identifier,)return CredentialResponse(credential=credential_response,diff --git a/skyvern/forge/sdk/schemas/credentials.py b/skyvern/forge/sdk/schemas/credentials.pyindex ac1d5479b..1e01dfcf2 100644--- a/skyvern/forge/sdk/schemas/credentials.py+++ b/skyvern/forge/sdk/schemas/credentials.py@@ -35,7 +35,7 @@ class TotpType(StrEnum):class PasswordCredentialResponse(BaseModel):"""Response model for password credentials — non-sensitive fields only.- SECURITY: Must NEVER include password, TOTP secret, or TOTP identifier.+ SECURITY: Must NEVER include password or TOTP secret."""username: str = Field(..., description="The username associated with the credential", examples=["[email protected]"])diff --git a/skyvern/webeye/actions/handler.py b/skyvern/webeye/actions/handler.pyindex acec05983..47f394b28 100644--- a/skyvern/webeye/actions/handler.py+++ b/skyvern/webeye/actions/handler.py@@ -70,6 +70,7 @@ from skyvern.forge.sdk.api.llm.schema_validator import validate_and_fill_extractfrom skyvern.forge.sdk.core import skyvern_contextfrom skyvern.forge.sdk.core.skyvern_context import current as skyvern_currentfrom skyvern.forge.sdk.core.skyvern_context import ensure_context+from skyvern.forge.sdk.event.factory import EventStrategyFactoryfrom skyvern.forge.sdk.models import Stepfrom skyvern.forge.sdk.schemas.tasks import Taskfrom skyvern.forge.sdk.services.bitwarden import BitwardenConstants@@ -730,6 +731,7 @@ async def handle_click_action(if await skyvern_element.navigate_to_a_href(page=page):return [ActionSuccess()]+ await EventStrategyFactory.move_cursor(page, action.x, action.y)if action.repeat == 1:await page.mouse.click(x=action.x, y=action.y, button=action.button)elif action.repeat == 2:@@ -1124,7 +1126,7 @@ async def handle_input_text_action() -> list[ActionResult]:if not action.element_id:# This is a CUA type action- await page.keyboard.type(action.text)+ await EventStrategyFactory.type_text(page, None, action.text)return [ActionSuccess()]dom = DomUtil(scraped_page, page)@@ -1997,6 +1999,7 @@ async def handle_select_option_action(await skyvern_element.scroll_into_view()try:+ await EventStrategyFactory.move_to_element(page, skyvern_element.get_locator())await skyvern_element.get_locator().click(timeout=timeout)except Exception:LOG.info(@@ -2106,6 +2109,7 @@ async def handle_hover_action(try:await skyvern_element.hover_to_reveal()await skyvern_element.get_locator().scroll_into_view_if_needed()+ await EventStrategyFactory.move_to_element(page, skyvern_element.get_locator())await skyvern_element.get_locator().hover(timeout=settings.BROWSER_ACTION_TIMEOUT_MS)if action.hold_seconds and action.hold_seconds > 0:@@ -2274,7 +2278,7 @@ async def handle_scroll_action(viewport = page.viewport_sizecenter_x = viewport["width"] // 2 if viewport else 640center_y = viewport["height"] // 2 if viewport else 360- await page.mouse.move(center_x, center_y)+ await EventStrategyFactory.move_cursor(page, center_x, center_y)wheel_delta = 500 if scroll_direction == "down" else -500# Dynamically compute iterations based on remaining scrollable distance# so we reach the bottom even on very long T&C pages.@@ -2293,6 +2297,11 @@ async def handle_scroll_action(iterations=iterations,wheel_delta=wheel_delta,)+ # Scroll per-iteration with page-reaction pauses between each chunk+ # (e.g. lazy-load, infinite scroll, dynamically enabled buttons).+ # Use raw page.mouse.wheel() here — the chunking + 100ms pauses already+ # provide a natural pattern, and applying the custom event strategy+ # per-iteration would add excessive latency per chunk.for _ in range(iterations):await page.mouse.wheel(0, wheel_delta)await page.wait_for_timeout(100)@@ -2314,13 +2323,13 @@ async def handle_scroll_action("Could not find scrollable container near element, falling back to mouse wheel",element_id=action.element_id,)- await page.mouse.wheel(action.scroll_x, action.scroll_y)+ await EventStrategyFactory.scroll_by(page, action.scroll_x, action.scroll_y)elif action.x and action.y:# Coordinate-based scrolling from CUA/UI-TARS agents- await page.mouse.move(action.x, action.y)- await page.mouse.wheel(action.scroll_x, action.scroll_y)+ await EventStrategyFactory.move_cursor(page, action.x, action.y)+ await EventStrategyFactory.scroll_by(page, action.scroll_x, action.scroll_y)else:- await page.mouse.wheel(action.scroll_x, action.scroll_y)+ await EventStrategyFactory.scroll_by(page, action.scroll_x, action.scroll_y)return [ActionSuccess()]@@ -2344,7 +2353,7 @@ async def handle_move_action(task: Task,step: Step,) -> list[ActionResult]:- await page.mouse.move(action.x, action.y)+ await EventStrategyFactory.move_cursor(page, action.x, action.y)return [ActionSuccess()]@@ -2509,6 +2518,7 @@ async def chain_click("""try:if not await skyvern_element.navigate_to_a_href(page=page):+ await EventStrategyFactory.move_to_element(page, locator)await locator.click(timeout=timeout)LOG.info("Chain click: main element click succeeded", action=action, locator=locator)return [ActionSuccess()]@@ -3497,6 +3507,7 @@ async def select_from_dropdown("Find an alternative option with the same value. Try to select the option.",value=value,)+ await EventStrategyFactory.move_to_element(page, locator)await locator.click(timeout=timeout)single_select_result.action_result = ActionSuccess()return single_select_resultdiff --git a/skyvern/webeye/actions/handler_utils.py b/skyvern/webeye/actions/handler_utils.pyindex 1a01490d1..51dec5193 100644--- a/skyvern/webeye/actions/handler_utils.py+++ b/skyvern/webeye/actions/handler_utils.py@@ -5,8 +5,9 @@ import structlogfrom playwright.async_api import Locator, Pagefrom skyvern.config import settings-from skyvern.constants import TEXT_INPUT_DELAY, TEXT_PRESS_MAX_LENGTH+from skyvern.constants import TEXT_PRESS_MAX_LENGTHfrom skyvern.forge.sdk.api.files import download_file as download_file_api+from skyvern.forge.sdk.event.factory import EventStrategyFactoryLOG = structlog.get_logger()@@ -35,8 +36,7 @@ async def input_sequentially(locator: Locator, text: str, timeout: float = settiawait locator.fill(text[: length - TEXT_PRESS_MAX_LENGTH], timeout=timeout)text = text[length - TEXT_PRESS_MAX_LENGTH :]- for char in text:- await locator.type(char, delay=TEXT_INPUT_DELAY, timeout=timeout)+ await EventStrategyFactory.type_text(locator.page, locator, text)async def keypress(page: Page, keys: list[str], hold: bool = False, duration: float = 0) -> None:@@ -95,18 +95,24 @@ async def drag(page: Page, start_x: int | None = None, start_y: int | None = None, path: list[tuple[int, int]] | None = None) -> None:if start_x and start_y:- await page.mouse.move(start_x, start_y)+ await EventStrategyFactory.move_cursor(page, start_x, start_y)await page.mouse.down()path = path or []+ last_x: float = start_x if start_x is not None else 0.0+ last_y: float = start_y if start_y is not None else 0.0for point in path:- x, y = point[0], point[1]- await page.mouse.move(x, y)+ last_x, last_y = point[0], point[1]+ await EventStrategyFactory.move_cursor(page, last_x, last_y)await page.mouse.up()+ # Sync cursor strategy position to the final drag point so the next+ # move_to() starts from the correct location.+ if start_x is not None or path:+ EventStrategyFactory.sync_cursor_position(page, last_x, last_y)async def left_mouse(page: Page, x: int | None, y: int | None, direction: Literal["down", "up"]) -> None:if x and y:- await page.mouse.move(x, y)+ await EventStrategyFactory.move_cursor(page, x, y)if direction == "down":await page.mouse.down()elif direction == "up":diff --git a/skyvern/webeye/utils/dom.py b/skyvern/webeye/utils/dom.pyindex fc94d882a..74bcaf20a 100644--- a/skyvern/webeye/utils/dom.py+++ b/skyvern/webeye/utils/dom.py@@ -11,7 +11,7 @@ import structlogfrom playwright.async_api import ElementHandle, FloatRect, Frame, FrameLocator, Locator, Page, TimeoutErrorfrom skyvern.config import settings-from skyvern.constants import SKYVERN_ID_ATTR, TEXT_INPUT_DELAY+from skyvern.constants import SKYVERN_ID_ATTRfrom skyvern.exceptions import (ElementIsNotLabel,ElementOutOfCurrentViewport,@@ -26,6 +26,7 @@ from skyvern.exceptions import (SkyvernException,)from skyvern.experimentation.wait_utils import get_or_create_wait_config, get_wait_time, scroll_into_view_wait+from skyvern.forge.sdk.event.factory import EventStrategyFactoryfrom skyvern.webeye.actions import handler_utilsfrom skyvern.webeye.scraper.scraped_page import ScrapedPage, json_to_htmlfrom skyvern.webeye.scraper.scraper import IncrementalScrapePage, trim_element@@ -702,8 +703,8 @@ class SkyvernElement:await self.get_locator().press(key=key, timeout=timeout)async def press_fill(self, text: str, timeout: float = settings.BROWSER_ACTION_TIMEOUT_MS) -> None:- for char in text:- await self.get_locator().type(char, delay=TEXT_INPUT_DELAY, timeout=timeout)+ locator = self.get_locator()+ await EventStrategyFactory.type_text(locator.page, locator, text)async def input(self, text: str, timeout: float = settings.BROWSER_ACTION_TIMEOUT_MS) -> None:if self.get_tag_name().lower() not in COMMON_INPUT_TAGS:@@ -715,7 +716,8 @@ class SkyvernElement:await self.get_locator().fill(text, timeout=timeout)async def input_clear(self, timeout: float = settings.BROWSER_ACTION_TIMEOUT_MS) -> None:- await self.get_locator().clear(timeout=timeout)+ locator = self.get_locator()+ await EventStrategyFactory.clear_field(locator.page, locator, char_count=0)async def check(self,@@ -819,7 +821,7 @@ class SkyvernElement:if dest_x < 0 or dest_y < 0:raise ElementOutOfCurrentViewport(element_id=self.get_id())- await page.mouse.move(dest_x, dest_y)+ await EventStrategyFactory.move_cursor(page, dest_x, dest_y)return dest_x, dest_y@@ -833,6 +835,7 @@ class SkyvernElement:if await self.is_disabled(dynamic=True):raise InteractWithDisabledElement(element_id=self.get_id())+ await EventStrategyFactory.move_to_element(page, self.get_locator())try:await self.get_locator().click(timeout=timeout)returndiff --git a/tests/unit/test_credential_api_response.py b/tests/unit/test_credential_api_response.pynew file mode 100644index 000000000..46eec06f8--- /dev/null+++ b/tests/unit/test_credential_api_response.py@@ -0,0 +1,55 @@+"""Tests for _convert_to_response in credentials routes."""++from datetime import datetime++from skyvern.forge.sdk.routes.credentials import _convert_to_response+from skyvern.forge.sdk.schemas.credentials import (+ Credential,+ CredentialType,+ CredentialVaultType,+ TotpType,+)+++def _make_credential(**overrides: object) -> Credential:+ defaults = {+ "credential_id": "cred_test",+ "organization_id": "org_test",+ "name": "Test Credential",+ "vault_type": CredentialVaultType.BITWARDEN,+ "item_id": "item_test",+ "credential_type": CredentialType.PASSWORD,+ "username": "[email protected]",+ "totp_type": TotpType.AUTHENTICATOR,+ "totp_identifier": None,+ "card_last4": None,+ "card_brand": None,+ "secret_label": None,+ "browser_profile_id": None,+ "tested_url": None,+ "user_context": None,+ "save_browser_session_intent": False,+ "created_at": datetime(2026, 1, 1),+ "modified_at": datetime(2026, 1, 1),+ "deleted_at": None,+ }+ defaults.update(overrides)+ return Credential(**defaults)+++def test_convert_to_response_includes_totp_identifier() -> None:+ credential = _make_credential(totp_identifier="login_otp")+ response = _convert_to_response(credential)+ assert response.credential.totp_identifier == "login_otp"+++def test_convert_to_response_totp_identifier_none_when_not_set() -> None:+ credential = _make_credential(totp_identifier=None)+ response = _convert_to_response(credential)+ assert response.credential.totp_identifier is None+++def test_convert_to_response_includes_totp_type() -> None:+ credential = _make_credential(totp_type=TotpType.EMAIL)+ response = _convert_to_response(credential)+ assert response.credential.totp_type == TotpType.EMAIL