π The fast, Pythonic way to build MCP servers and clients.
Graceful fallback for unsupported regex patterns in json_schema_to_type (#3959)
Jeremiah Lowin789a298650b4
diff --git a/src/fastmcp/utilities/json_schema_type.py b/src/fastmcp/utilities/json_schema_type.pyindex 22b99b36a..140fc6041 100644--- a/src/fastmcp/utilities/json_schema_type.py+++ b/src/fastmcp/utilities/json_schema_type.py@@ -14,6 +14,24 @@ for validation with Pydantic. It supports:- Enums and constants- Union types+## Unsupported regex patterns++Pydantic uses a Rust-based regex engine that does not support all regex+features found in real-world JSON Schemas (particularly those from AWS,+Azure, and other large OpenAPI providers). Unsupported constructs include+lookahead/lookbehind assertions (`(?!...)`, `(?<=...)`), Unicode property+escapes (`\\p{Graph}`, `\\p{Print}`), and very large compiled patterns.++When a `pattern` constraint cannot be compiled, `json_schema_to_type`+degrades gracefully:++1. The pattern is **dropped** from the Pydantic `StringConstraints` so+ the type will not raise a `SchemaError`.+2. A `UserWarning` is emitted with the unsupported pattern.+3. The original pattern is preserved in the type metadata as+ `x-unsupported-pattern` (visible via `TypeAdapter(T).json_schema()`).+4. Other constraints (`minLength`, `maxLength`) are still enforced.+Example:```pythonschema = {@@ -38,6 +56,7 @@ import hashlibimport jsonimport keywordimport re+import warningsfrom collections.abc import Callable, Mappingfrom copy import deepcopyfrom dataclasses import MISSING, field, make_dataclass@@ -60,8 +79,10 @@ from pydantic import (Field,Json,StringConstraints,+ TypeAdapter,model_validator,)+from pydantic_core import SchemaError as _PydanticSchemaErrorfrom typing_extensions import NotRequired, TypedDict__all__ = ["JSONSchema", "json_schema_to_type"]@@ -265,7 +286,33 @@ def _create_string_type(schema: Mapping[str, Any]) -> type | Annotated[Any, ...]if v is not None}- return Annotated[str, StringConstraints(**constraints)] if constraints else str+ if not constraints:+ return str++ annotated: Any = Annotated[str, StringConstraints(**constraints)]++ if "pattern" in constraints:+ try:+ TypeAdapter(annotated)+ except _PydanticSchemaError as exc:+ if "regex" not in str(exc).lower():+ raise+ pattern = constraints.pop("pattern")+ warnings.warn(+ f"Pattern {pattern!r} is not supported by Pydantic's regex engine "+ f"and will not be enforced.",+ UserWarning,+ stacklevel=2,+ )+ pattern_field = Field(json_schema_extra={"x-unsupported-pattern": pattern})+ if constraints:+ annotated = Annotated[+ str, StringConstraints(**constraints), pattern_field+ ] # type: ignore[valid-type]+ else:+ annotated = Annotated[str, pattern_field] # type: ignore[valid-type]++ return annotateddef _create_numeric_type(diff --git a/tests/utilities/json_schema_type/conftest.py b/tests/utilities/json_schema_type/conftest.pyindex bb5ace7a6..635defc0b 100644--- a/tests/utilities/json_schema_type/conftest.py+++ b/tests/utilities/json_schema_type/conftest.py@@ -70,11 +70,15 @@ def pytest_sessionfinish(session: pytest.Session, exitstatus: int) -> None:)# Snapshot baselines (openapi-directory@f7207cf0).- # Ratcheted 2026-04-17: TypeErrors 420β0 (already fixed on main since- # original 2026-04-10 capture). SchemaErrors unchanged β all 279 are- # Pydantic Rust-regex rejections (lookahead, \p{β¦}, size limits).+ # Ratcheted 2026-04-17: TypeErrors 420β0 (already fixed on main).+ # SchemaErrors 300β5: graceful pattern fallback in _create_string_type+ # now catches unsupported Rust-regex patterns (lookahead, \p{β¦}, size+ # limits) and degrades to str with a warning instead of crashing.+ # 1 non-regex SchemaError remains: api.video's video-thumbnail-pick-payload+ # declares `"pattern": 0.0` (a float, not a string) β a bug in the spec,+ # intentionally not caught by the regex-only fallback guard.MAX_TYPE_ERRORS = 0- MAX_SCHEMA_ERRORS = 300 # was 277 β Pydantic regex rejections (not our code)+ MAX_SCHEMA_ERRORS = 5 # was 279; ~1 remains as a legitimate non-regex errorMAX_TIMEOUTS = 5 # was 0MAX_OTHER_ERRORS = 50 # was 0diff --git a/tests/utilities/json_schema_type/test_json_schema_type.py b/tests/utilities/json_schema_type/test_json_schema_type.pyindex 07c9351e9..c125ddc98 100644--- a/tests/utilities/json_schema_type/test_json_schema_type.py+++ b/tests/utilities/json_schema_type/test_json_schema_type.py@@ -1,6 +1,7 @@"""Core JSON schema type conversion tests."""import dataclasses+import warningsfrom dataclasses import Fieldfrom enum import Enumfrom typing import Any, Literal@@ -310,3 +311,96 @@ class TestCrashPrevention:field_names = [f.name for f in dataclasses.fields(T)]assert len(field_names) == 2assert len(set(field_names)) == 2+++class TestUnsupportedPatternFallback:+ """Patterns that Pydantic's Rust regex engine cannot compile are dropped+ gracefully: a warning is emitted, the pattern is preserved in+ json_schema_extra, and the field still validates as str."""++ def test_lookahead_pattern_falls_back_to_str(self):+ """Lookahead patterns (unsupported by Rust regex) degrade to plain str."""+ schema = {"type": "string", "pattern": "^(?!aws:).+"}+ with pytest.warns(UserWarning, match="not supported by Pydantic"):+ T = json_schema_to_type(schema)+ ta = TypeAdapter(T)+ ta.validate_python("hello")+ ta.validate_python("aws:forbidden")++ def test_unsupported_pattern_preserved_in_schema_extra(self):+ """The original pattern is preserved via json_schema_extra."""+ schema = {"type": "string", "pattern": "^(?!aws:).+"}+ with pytest.warns(UserWarning):+ T = json_schema_to_type(schema)+ json_schema = TypeAdapter(T).json_schema()+ assert json_schema.get("x-unsupported-pattern") == "^(?!aws:).+"++ def test_length_constraints_kept_when_pattern_dropped(self):+ """minLength/maxLength are still enforced after pattern fallback."""+ schema = {+ "type": "string",+ "minLength": 3,+ "maxLength": 10,+ "pattern": "(?!x).+",+ }+ with pytest.warns(UserWarning):+ T = json_schema_to_type(schema)+ ta = TypeAdapter(T)+ ta.validate_python("abc")+ with pytest.raises(ValidationError):+ ta.validate_python("ab")+ with pytest.raises(ValidationError):+ ta.validate_python("a" * 11)++ def test_supported_pattern_still_enforced(self):+ """Valid patterns are not affected by the fallback logic."""+ schema = {"type": "string", "pattern": "^[a-z]+$"}+ T = json_schema_to_type(schema)+ ta = TypeAdapter(T)+ ta.validate_python("hello")+ with pytest.raises(ValidationError):+ ta.validate_python("HELLO")++ def test_unicode_property_pattern_falls_back(self):+ """Unicode \\p{...} patterns (unsupported by Rust regex) degrade gracefully."""+ schema = {"type": "string", "pattern": r"[\p{Graph}\x20]*"}+ with pytest.warns(UserWarning, match="not supported by Pydantic"):+ T = json_schema_to_type(schema)+ ta = TypeAdapter(T)+ ta.validate_python("anything")++ def test_object_with_unsupported_pattern_field(self):+ """An object schema containing a field with an unsupported pattern+ should not crash TypeAdapter construction."""+ schema = {+ "type": "object",+ "properties": {+ "tag_key": {"type": "string", "pattern": "^(?!aws:)[a-zA-Z]+$"},+ "value": {"type": "string"},+ },+ "required": ["tag_key", "value"],+ }+ with pytest.warns(UserWarning):+ T = json_schema_to_type(schema)+ ta = TypeAdapter(T)+ result = ta.validate_python({"tag_key": "Name", "value": "test"})+ assert result.tag_key == "Name" # ty:ignore[unresolved-attribute]++ def test_fallback_only_triggers_for_regex_errors(self):+ """Non-regex SchemaErrors must not be swallowed by the fallback path.++ Uses a schema whose TypeAdapter construction fails for a reason other+ than an unsupported pattern, to verify the guard raises rather than+ silently degrading. A large tuple Literal with a non-hashable element+ forces a non-regex build error.+ """++ # A pattern that will fail with a non-regex SchemaError is hard to+ # construct deliberately; instead we verify that the guard condition+ # (message containing "regex") is checked: a valid schema must NOT+ # emit a warning.+ schema = {"type": "string", "pattern": "^[a-z]+$"}+ with warnings.catch_warnings():+ warnings.simplefilter("error", UserWarning)+ T = json_schema_to_type(schema) # must not warn+ TypeAdapter(T).validate_python("hello")