Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
Recover phone numbers rewritten by country-aware fields (#7474)
Marc Kelechavad6c3f6caa310
diff --git a/skyvern/webeye/actions/handler.py b/skyvern/webeye/actions/handler.pyindex d4b0f94fe..22e5ab4ee 100644--- a/skyvern/webeye/actions/handler.py+++ b/skyvern/webeye/actions/handler.py@@ -1046,23 +1046,21 @@ def _phone_digits(value: str | None) -> str:return re.sub(r"\D", "", value or "")-def _nanp_readback_national_digits(digits: str) -> str | None:- if len(digits) == 10:- return digits- if len(digits) in {11, 12} and digits[:-10] == "1" * (len(digits) - 10):- return digits[-10:]- return None---def _phone_readback_digits_match(expected_digits: str, actual_digits: str) -> bool:+def _phone_readback_digits_match(+ expected_digits: str,+ actual_digits: str,+ *,+ allow_nanp_country_prefix: bool = False,+) -> bool:if actual_digits == expected_digits:return True- if len(expected_digits) == 10 and actual_digits == f"1{expected_digits}":- return True+ if not allow_nanp_country_prefix:+ return False+ return len(expected_digits) == 10 and actual_digits == f"1{expected_digits}"+- expected_nanp_digits = _nanp_readback_national_digits(expected_digits)- actual_nanp_digits = _nanp_readback_national_digits(actual_digits)- return expected_nanp_digits is not None and expected_nanp_digits == actual_nanp_digits+def _has_explicit_nanp_country_code(value: str | None) -> bool:+ return re.match(r"\+1|1[ \-.(]", (value or "").strip()) is not Nonedef _nanp_national_digits(value: str | None) -> str | None:@@ -1073,7 +1071,7 @@ def _nanp_national_digits(value: str | None) -> str | None:digits = _phone_digits(text)# A leading 1 counts as a country code only when written as one (+1, or 1 set off by a# separator); bare 11-digit strings can be non-NANP numbers whose first digit is 1.- if re.fullmatch(r"1[0-9]{10}", digits) and re.match(r"\+1|1[ \-.(]", text):+ if re.fullmatch(r"1[0-9]{10}", digits) and _has_explicit_nanp_country_code(text):national_digits = digits[-10:]elif re.fullmatch(r"\([0-9]{3}\) [0-9]{3}-[0-9]{4}|[0-9]{3}-[0-9]{3}-[0-9]{4}|"@@ -1102,6 +1100,31 @@ def _tel_pattern_allows_bare_digits(pattern: str | None, bare_digits: str) -> boreturn True+def _nanp_e164_fallback(value: str, *, pattern: str | None, maxlength: str | None) -> str | None:+ """Return a canonical E.164 retry only with explicit +1 evidence and permissive field constraints."""+ national_digits = _nanp_national_digits(value)+ if national_digits is None or not _has_explicit_nanp_country_code(value):+ return None+ e164_value = f"+1{national_digits}"+ if pattern:+ try:+ if re.fullmatch(pattern, e164_value) is None:+ return None+ except re.error:+ # Unlike the required bare-digit first attempt, this optional +1 rewrite fails closed when+ # the browser's pattern cannot be interpreted safely by Python.+ return None++ if maxlength:+ try:+ max_chars = int(maxlength)+ except ValueError:+ return None+ if max_chars < 0 or len(e164_value) > max_chars:+ return None+ return e164_value++def _plan_tel_text(*, is_tel: bool, is_secret: bool, value: str, pattern: str | None) -> tuple[str, bool, bool]:# Decide how to fill a tel field. Returns (text_to_type, used_bare_nanp, run_format_check).# Bare national digits avoid the fill()-split behavior that can drop a digit in self-formatting fields.@@ -1229,12 +1252,22 @@ async def _is_collapse_autocomplete_fanout_enabled(task: Task) -> bool:)-async def verify_phone_input_digits(*, tag_name: str, locator: Locator, expected_value: str) -> None:+async def verify_phone_input_digits(+ *,+ tag_name: str,+ locator: Locator,+ expected_value: str,+ allow_nanp_country_prefix: bool = False,+) -> None:# Compare normalized digits only — never the raw value, which may be a secret.actual_value = await get_input_value(tag_name=tag_name, locator=locator)expected_digits = _phone_digits(expected_value)actual_digits = _phone_digits(actual_value)- if not _phone_readback_digits_match(expected_digits, actual_digits):+ if not _phone_readback_digits_match(+ expected_digits,+ actual_digits,+ allow_nanp_country_prefix=allow_nanp_country_prefix,+ ):raise PhoneNumberInputMismatch(expected_digit_count=len(expected_digits),actual_digit_count=len(actual_digits),@@ -1246,14 +1279,65 @@ async def verify_phone_input_digits(*, tag_name: str, locator: Locator, expected)-async def _verify_tel_input_after_fill(*, skyvern_element: SkyvernElement, tag_name: str, expected_value: str) -> None:+async def _verify_tel_input_after_fill(+ *,+ skyvern_element: SkyvernElement,+ tag_name: str,+ expected_value: str,+ allow_nanp_country_prefix: bool,+) -> None:await verify_phone_input_digits(tag_name=tag_name,locator=skyvern_element.get_locator(),expected_value=expected_value,+ allow_nanp_country_prefix=allow_nanp_country_prefix,)+async def _fill_nanp_tel_with_readback(+ *,+ skyvern_element: SkyvernElement,+ tag_name: str,+ national_digits: str,+ e164_fallback: str | None,+) -> PhoneNumberInputMismatch | None:+ """Fill affirmative NANP digits and verify every attempt.+ Retry atomically with national digits before constraint-safe E.164 for the least invasive recovery.+ """+ attempts = [("sequential_national", national_digits), ("atomic_national", national_digits)]+ if e164_fallback is not None:+ attempts.append(("atomic_e164", e164_fallback))++ for attempt_index, (strategy, value) in enumerate(attempts):+ if strategy == "sequential_national":+ await skyvern_element.input_sequentially(text=value)+ else:+ await skyvern_element.input_clear()+ await skyvern_element.input_fill(text=value)++ try:+ await _verify_tel_input_after_fill(+ skyvern_element=skyvern_element,+ tag_name=tag_name,+ expected_value=national_digits,+ allow_nanp_country_prefix=e164_fallback is not None,+ )+ except PhoneNumberInputMismatch as mismatch:+ if attempt_index == len(attempts) - 1:+ return mismatch+ LOG.info(+ "Phone input read-back mismatch; trying next fill strategy",+ element_id=skyvern_element.get_id(),+ failed_strategy=strategy,+ next_strategy=attempts[attempt_index + 1][0],+ expected_digit_count=mismatch.expected_digit_count,+ actual_digit_count=mismatch.actual_digit_count,+ )+ else:+ return None+ return None++async def _log_tel_fallback_fill_digit_counts(*, skyvern_element: SkyvernElement, tag_name: str, expected_value: str, task_id: str | None, step_id: str | None) -> None:@@ -3303,11 +3387,16 @@ async def handle_input_text_action(used_bare_nanp = Falserun_phone_format_check = Falselog_tel_fallback_readback = False+ tel_pattern: str | None = None+ tel_maxlength: str | None = None+ tel_e164_fallback: str | None = Noneif is_tel and not is_card_number_input and await _is_tel_digit_fix_enabled(task):# SKY-11315 fix, behind FIX_TEL_INPUT_DIGIT_DROP. Flag-off keeps the original behavior below# byte-for-byte. Affirmative-NANP tel is typed as bare national digits (skipping the format-check# LLM) unless the field's pattern requires a mask; secrets are eligible (local strip, no LLM).tel_pattern = await skyvern_element.get_attr("pattern")+ tel_maxlength = await skyvern_element.get_attr("maxlength")+ tel_e164_fallback = _nanp_e164_fallback(text, pattern=tel_pattern, maxlength=tel_maxlength)text, used_bare_nanp, run_phone_format_check = _plan_tel_text(is_tel=True, is_secret=is_secret_value, value=text, pattern=tel_pattern)@@ -3488,7 +3577,8 @@ async def handle_input_text_action(auto_complete_hacky_flag = Falsereturn [result]- # Only the bare-digit NANP fill is read back to verify; other tel shapes are left unverified.+ # Only the bare-digit NANP path uses the verified fallback ladder; other tel shapes remain+ # observational to preserve flag-off behavior.verify_tel_input_after_fill = used_bare_nanp# SKY-11720: an auto-formatting card-number field (a space every 4 digits) restores its caret@@ -3512,36 +3602,24 @@ async def handle_input_text_action()if card_failure is not None:return [card_failure]+ elif verify_tel_input_after_fill:+ phone_mismatch = await _fill_nanp_tel_with_readback(+ skyvern_element=skyvern_element,+ tag_name=tag_name,+ national_digits=text,+ e164_fallback=tel_e164_fallback,+ )+ if phone_mismatch is not None:+ LOG.warning(+ "Phone input read-back mismatch after retry",+ element_id=skyvern_element.get_id(),+ expected_digit_count=phone_mismatch.expected_digit_count,+ actual_digit_count=phone_mismatch.actual_digit_count,+ )+ return [ActionFailure(phone_mismatch)]else:await skyvern_element.input_sequentially(text=text)- if verify_tel_input_after_fill:- # Read the typed digits back; on mismatch, clear and retype once. A second mismatch- # fails the action here rather than letting it surface as a silent wrong fill.- try:- await _verify_tel_input_after_fill(- skyvern_element=skyvern_element,- tag_name=tag_name,- expected_value=text,- )- except PhoneNumberInputMismatch:- await skyvern_element.input_clear()- await skyvern_element.input_sequentially(text=text)- try:- await _verify_tel_input_after_fill(- skyvern_element=skyvern_element,- tag_name=tag_name,- expected_value=text,- )- except PhoneNumberInputMismatch as mismatch:- LOG.warning(- "Phone input read-back mismatch after retry",- action=action,- element_id=skyvern_element.get_id(),- expected_digit_count=mismatch.expected_digit_count,- actual_digit_count=mismatch.actual_digit_count,- )- return [ActionFailure(mismatch)]- elif log_tel_fallback_readback:+ if log_tel_fallback_readback:await _log_tel_fallback_fill_digit_counts(skyvern_element=skyvern_element,tag_name=tag_name,diff --git a/tests/unit/test_input_text_phone_readback.py b/tests/unit/test_input_text_phone_readback.pyindex f65868854..0dcd3b982 100644--- a/tests/unit/test_input_text_phone_readback.py+++ b/tests/unit/test_input_text_phone_readback.py@@ -5,16 +5,32 @@ from unittest.mock import AsyncMock, MagicMockimport pytestfrom skyvern.exceptions import PhoneNumberInputMismatch-from skyvern.webeye.actions.handler import _log_tel_fallback_fill_digit_counts, verify_phone_input_digits+from skyvern.webeye.actions.handler import (+ _fill_nanp_tel_with_readback,+ _log_tel_fallback_fill_digit_counts,+ verify_phone_input_digits,+)++NANP_DIGITS = "2245550199"+NANP_E164 = f"+1{NANP_DIGITS}"def _make_element(locator: MagicMock) -> MagicMock:element = MagicMock()element.get_locator.return_value = locatorelement.get_id.return_value = "element-id"+ element.input_sequentially = AsyncMock()+ element.input_clear = AsyncMock()+ element.input_fill = AsyncMock()return element+def _make_fill_element(readbacks: list[str]) -> MagicMock:+ locator = MagicMock()+ locator.input_value = AsyncMock(side_effect=readbacks)+ return _make_element(locator)++@pytest.mark.asyncioasync def test_phone_readback_accepts_matching_ten_digits() -> None:locator = MagicMock()@@ -23,13 +39,40 @@ async def test_phone_readback_accepts_matching_ten_digits() -> None:await verify_phone_input_digits(tag_name="input", locator=locator, expected_value="224-555-0199")[email protected]("actual_value", ["+1 (224) 555-0199", "+11 (224) 555-0199"])@pytest.mark.asyncio-async def test_phone_readback_accepts_country_code_readback(actual_value: str) -> None:+async def test_phone_readback_accepts_single_country_code_with_source_evidence() -> None:locator = MagicMock()- locator.input_value = AsyncMock(return_value=actual_value)+ locator.input_value = AsyncMock(return_value="+1 (224) 555-0199")- await verify_phone_input_digits(tag_name="input", locator=locator, expected_value="2245550199")+ await verify_phone_input_digits(+ tag_name="input",+ locator=locator,+ expected_value="2245550199",+ allow_nanp_country_prefix=True,+ )+++async def test_phone_readback_rejects_duplicated_country_code() -> None:+ locator = MagicMock()+ locator.input_value = AsyncMock(return_value="+11 (224) 555-0199")++ with pytest.raises(PhoneNumberInputMismatch):+ await verify_phone_input_digits(+ tag_name="input",+ locator=locator,+ expected_value="2245550199",+ allow_nanp_country_prefix=True,+ )+++async def test_phone_readback_rejects_country_code_without_source_evidence() -> None:+ locator = MagicMock()+ locator.input_value = AsyncMock(return_value="+1 (987) 555-0199")++ with pytest.raises(PhoneNumberInputMismatch):+ await verify_phone_input_digits(tag_name="input", locator=locator, expected_value="9875550199")@pytest.mark.asyncio@@ -44,6 +87,55 @@ async def test_phone_readback_digit_drop_raises() -> None:assert exc.value.actual_digit_count == 9+async def test_nanp_fill_clean_first_attempt_skips_fallbacks() -> None:+ element = _make_fill_element(["(224) 555-0199"])++ mismatch = await _fill_nanp_tel_with_readback(+ skyvern_element=element,+ tag_name="input",+ national_digits=NANP_DIGITS,+ e164_fallback=NANP_E164,+ )++ assert mismatch is None+ element.input_sequentially.assert_awaited_once_with(text=NANP_DIGITS)+ element.input_clear.assert_not_awaited()+ element.input_fill.assert_not_awaited()+++async def test_nanp_fill_recovers_same_length_substitution_with_atomic_national() -> None:+ element = _make_fill_element(["2245550198", "2245550199"])++ mismatch = await _fill_nanp_tel_with_readback(+ skyvern_element=element,+ tag_name="input",+ national_digits=NANP_DIGITS,+ e164_fallback=NANP_E164,+ )++ assert mismatch is None+ element.input_clear.assert_awaited_once()+ element.input_fill.assert_awaited_once_with(text=NANP_DIGITS)+++async def test_nanp_fill_returns_final_mismatch_when_all_safe_attempts_fail() -> None:+ element = _make_fill_element(["+44 22 4555 0199", "+44 22 4555 0199", "+44 22 4555 0199"])++ mismatch = await _fill_nanp_tel_with_readback(+ skyvern_element=element,+ tag_name="input",+ national_digits=NANP_DIGITS,+ e164_fallback=NANP_E164,+ )++ assert mismatch is not None+ assert mismatch.expected_digit_count == 10+ assert mismatch.actual_digit_count == 12++@pytest.mark.asyncioasync def test_tel_fallback_digit_count_log_never_raises_on_mismatch() -> None:# A 10 -> 9 digit drop on the LLM-fallback fill is observed and logged, never raised.diff --git a/tests/unit/test_input_text_tel_card_routing.py b/tests/unit/test_input_text_tel_card_routing.pyindex 5050cd677..e18b72054 100644--- a/tests/unit/test_input_text_tel_card_routing.py+++ b/tests/unit/test_input_text_tel_card_routing.py@@ -5,10 +5,11 @@ from unittest.mock import AsyncMock, MagicMock, patchimport pytest+from skyvern.exceptions import PhoneNumberInputMismatchfrom skyvern.forge.sdk.models import StepStatusfrom skyvern.webeye.actions.actions import InputTextActionfrom skyvern.webeye.actions.handler import handle_input_text_action-from skyvern.webeye.actions.responses import ActionSuccess+from skyvern.webeye.actions.responses import ActionFailure, ActionSuccessfrom tests.unit.helpers import make_organization, make_step, make_task_NOW = datetime.now(UTC)@@ -46,7 +47,13 @@ def _mock_input(attrs: dict[str, str | None]) -> MagicMock:return el-async def _run_input_text(el: MagicMock, text: str) -> tuple[list, AsyncMock, AsyncMock, AsyncMock]:+async def _run_input_text(+ el: MagicMock,+ text: str,+ *,+ tel_fix_enabled: bool = True,+ tel_verify_side_effect: list[Exception | None] | None = None,+) -> tuple[list, AsyncMock, AsyncMock, AsyncMock, MagicMock]:dom_instance = MagicMock()dom_instance.get_skyvern_element_by_id = AsyncMock(return_value=el)@@ -62,8 +69,9 @@ async def _run_input_text(el: MagicMock, text: str) -> tuple[list, AsyncMock, Asscraped_page.id_to_element_dict = {"AADC": {"tagName": "input"}}card_readback = AsyncMock(return_value=None)- tel_verify = AsyncMock()+ tel_verify = AsyncMock(side_effect=tel_verify_side_effect)phone_format = AsyncMock(return_value=text)+ warning_log = MagicMock()with (patch("skyvern.webeye.actions.handler.DomUtil", return_value=dom_instance),@@ -72,10 +80,11 @@ async def _run_input_text(el: MagicMock, text: str) -> tuple[list, AsyncMock, Aspatch("skyvern.webeye.actions.handler.get_input_value", new=AsyncMock(return_value="")),patch("skyvern.webeye.actions.handler.get_actual_value_of_parameter_if_secret_with_task", return_value=text),patch("skyvern.webeye.actions.handler._get_input_or_select_context", new=AsyncMock(return_value=None)),- patch("skyvern.webeye.actions.handler._is_tel_digit_fix_enabled", new=AsyncMock(return_value=True)),+ patch("skyvern.webeye.actions.handler._is_tel_digit_fix_enabled", new=AsyncMock(return_value=tel_fix_enabled)),patch("skyvern.webeye.actions.handler.check_phone_number_format", new=phone_format),patch("skyvern.webeye.actions.handler._fill_card_number_with_readback", new=card_readback),patch("skyvern.webeye.actions.handler._verify_tel_input_after_fill", new=tel_verify),+ patch("skyvern.webeye.actions.handler.LOG.warning", new=warning_log),):results = await handle_input_text_action(action=InputTextAction(element_id="AADC", text=text, reasoning="fill field"),@@ -85,7 +94,7 @@ async def _run_input_text(el: MagicMock, text: str) -> tuple[list, AsyncMock, Asstep=_STEP,)- return results, card_readback, tel_verify, phone_format+ return results, card_readback, tel_verify, phone_format, warning_log@pytest.mark.asyncio@@ -99,7 +108,7 @@ async def _run_input_text(el: MagicMock, text: str) -> tuple[list, AsyncMock, Asasync def test_tel_card_number_field_uses_card_readback_not_phone_format(attrs: dict[str, str | None]) -> None:el = _mock_input(attrs)- results, card_readback, tel_verify, phone_format = await _run_input_text(el, VISA_16)+ results, card_readback, tel_verify, phone_format, _ = await _run_input_text(el, VISA_16)assert len(results) == 1 and isinstance(results[0], ActionSuccess)card_readback.assert_awaited_once_with(@@ -117,10 +126,85 @@ async def test_tel_card_number_field_uses_card_readback_not_phone_format(attrs:async def test_ten_digit_tel_phone_uses_tel_readback_not_card_readback() -> None:el = _mock_input({"type": "tel", "autocomplete": None, "name": "phone"})- results, card_readback, tel_verify, phone_format = await _run_input_text(el, "224-555-0199")+ results, card_readback, tel_verify, phone_format, _ = await _run_input_text(el, "224-555-0199")assert len(results) == 1 and isinstance(results[0], ActionSuccess)el.input_sequentially.assert_awaited_once_with(text="2245550199")- tel_verify.assert_awaited_once_with(skyvern_element=el, tag_name="input", expected_value="2245550199")+ tel_verify.assert_awaited_once_with(+ skyvern_element=el,+ tag_name="input",+ expected_value="2245550199",+ allow_nanp_country_prefix=False,+ )card_readback.assert_not_awaited()phone_format.assert_not_awaited()+++async def test_tel_flag_off_preserves_legacy_format_and_sequential_fill() -> None:+ el = _mock_input({"type": "tel", "autocomplete": None, "name": "phone"})++ results, _, tel_verify, phone_format, _ = await _run_input_text(+ el,+ "224-555-0199",+ tel_fix_enabled=False,+ )++ assert len(results) == 1 and isinstance(results[0], ActionSuccess)+ phone_format.assert_awaited_once()+ el.input_sequentially.assert_awaited_once_with(text="224-555-0199")+ tel_verify.assert_not_awaited()+ el.input_clear.assert_not_awaited()+ el.input_fill.assert_not_awaited()+++async def test_separator_only_tel_never_forces_nanp_country_code() -> None:+ el = _mock_input({"type": "tel", "autocomplete": None, "name": "phone"})+ mismatches = [+ PhoneNumberInputMismatch(expected_digit_count=10, actual_digit_count=12),+ PhoneNumberInputMismatch(expected_digit_count=10, actual_digit_count=12),+ ]++ results, _, tel_verify, _, warning_log = await _run_input_text(+ el,+ "224-555-0199",+ tel_verify_side_effect=mismatches,+ )++ assert len(results) == 1 and isinstance(results[0], ActionFailure)+ assert tel_verify.await_count == 2+ assert all(call.kwargs["allow_nanp_country_prefix"] is False for call in tel_verify.await_args_list)+ el.input_clear.assert_awaited_once()+ el.input_fill.assert_awaited_once_with(text="2245550199")+ warning_log.assert_called_once_with(+ "Phone input read-back mismatch after retry",+ element_id="AADC",+ expected_digit_count=10,+ actual_digit_count=12,+ )+++async def test_explicit_nanp_tel_keeps_constraint_safe_e164_fallback() -> None:+ el = _mock_input({"type": "tel", "autocomplete": None, "name": "phone"})+ mismatches_then_success = [+ PhoneNumberInputMismatch(expected_digit_count=10, actual_digit_count=12),+ PhoneNumberInputMismatch(expected_digit_count=10, actual_digit_count=12),+ None,+ ]++ results, _, tel_verify, _, _ = await _run_input_text(+ el,+ "+1 (224) 555-0199",+ tel_verify_side_effect=mismatches_then_success,+ )++ assert len(results) == 1 and isinstance(results[0], ActionSuccess)+ assert tel_verify.await_count == 3+ assert all(call.kwargs["allow_nanp_country_prefix"] is True for call in tel_verify.await_args_list)+ assert el.input_clear.await_count == 2+ assert [await_call.kwargs["text"] for await_call in el.input_fill.await_args_list] == [+ "2245550199",+ "+12245550199",+ ]diff --git a/tests/unit/test_tel_input_bare_digits.py b/tests/unit/test_tel_input_bare_digits.pyindex b70f8b80e..463800368 100644--- a/tests/unit/test_tel_input_bare_digits.py+++ b/tests/unit/test_tel_input_bare_digits.py@@ -7,7 +7,12 @@ from unittest.mock import AsyncMock, MagicMockimport pytestfrom skyvern.webeye.actions import handler_utils-from skyvern.webeye.actions.handler import _is_tel_digit_fix_enabled, _nanp_national_digits, _plan_tel_text+from skyvern.webeye.actions.handler import (+ _is_tel_digit_fix_enabled,+ _nanp_e164_fallback,+ _nanp_national_digits,+ _plan_tel_text,+)from tests.unit.helpers import make_organization, make_task@@ -44,6 +49,26 @@ def test_nanp_national_digits(value: str, expected: str | None) -> None:assert _nanp_national_digits(value) == expected+ "source_value,pattern,maxlength,expected",+ [+ ("+1 (224) 555-0199", None, None, "+12245550199"),+ ("1-224-555-0199", r"\+1\d{10}", "12", "+12245550199"),+ ("(224) 555-0199", None, None, None),+ ("224-555-0199", None, None, None),+ ("+1 (224) 555-0199", r"\d{10}", None, None),+ ("+1 (224) 555-0199", "[", None, None),+ ("+1 (224) 555-0199", None, "10", None),+ ("+1 (224) 555-0199", None, "-1", None),+ ("+1 (224) 555-0199", None, "not-a-number", None),+ ],+)+def test_nanp_e164_fallback_respects_live_field_constraints(+ source_value: str, pattern: str | None, maxlength: str | None, expected: str | None+) -> None:+ assert _nanp_e164_fallback(source_value, pattern=pattern, maxlength=maxlength) == expected++def test_plan_tel_text_strips_secret_resolved_formatted_nanp() -> None:# A secret with an affirmative NANP country code is typed as national digits and is never sent to# the format-check LLM.