Skip to content

Automate browser based workflows with AI

Recover phone numbers rewritten by country-aware fields (#7474)

Marc Kelechavad6c3f6caa310
diff --git a/skyvern/webeye/actions/handler.py b/skyvern/webeye/actions/handler.py
index 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 None
def _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) -> bo
return 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 = False
run_phone_format_check = False
log_tel_fallback_readback = False
+ tel_pattern: str | None = None
+ tel_maxlength: str | None = None
+ tel_e164_fallback: str | None = None
if 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 = False
return [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.py
index 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, MagicMock
import pytest
from 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 = locator
element.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.asyncio
async 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.asyncio
async 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.py
index 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, patch
import pytest
+from skyvern.exceptions import PhoneNumberInputMismatch
from skyvern.forge.sdk.models import StepStatus
from skyvern.webeye.actions.actions import InputTextAction
from skyvern.webeye.actions.handler import handle_input_text_action
-from skyvern.webeye.actions.responses import ActionSuccess
+from skyvern.webeye.actions.responses import ActionFailure, ActionSuccess
from 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, As
scraped_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, As
patch("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, As
step=_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, As
async 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.py
index 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, MagicMock
import pytest
from 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.