π The fast, Pythonic way to build MCP servers and clients.
Preserve invalid defaults for omitted JSON Schema fields (#6133)
totoyang6af8a0dc47cc
diff --git a/fastmcp_slim/fastmcp/utilities/json_schema_type.py b/fastmcp_slim/fastmcp/utilities/json_schema_type.pyindex 70b1088b6..664af2dd9 100644--- a/fastmcp_slim/fastmcp/utilities/json_schema_type.py+++ b/fastmcp_slim/fastmcp/utilities/json_schema_type.py@@ -67,6 +67,7 @@ from copy import deepcopyfrom dataclasses import MISSING, dataclass, field, fields, is_dataclass, make_dataclassfrom datetime import date, datetime, time, timedeltafrom functools import lru_cache+from types import MappingProxyTypefrom typing import (Annotated,Any,@@ -244,9 +245,9 @@ class _Conversion:building: set[tuple[str, str]] = field(default_factory=set)classes: dict[tuple[str, str], type] = field(default_factory=dict)recursive_refs: dict[str, tuple[str, str]] = field(default_factory=dict)- # Model fields whose default failed its probe, possibly only because a- # recursive reference was still unresolved; rechecked after resolution.- unchecked_defaults: list[tuple[type[BaseModel], str]] = field(default_factory=list)+ # Model and dataclass fields whose default failed its probe, possibly only+ # because a recursive reference was still unresolved; rechecked at the end.+ unchecked_defaults: list[tuple[type, str]] = field(default_factory=list)depth: int = 0steps: int = 0@@ -399,7 +400,7 @@ def _convert_normalized(schema: dict[str, Any], name: str | None) -> type:def _resolve_recursive_types(conversion: _Conversion) -> None:"""Bind recursive fields after every class in the conversion has been built."""- if not conversion.recursive_refs:+ if not conversion.recursive_refs and not conversion.unchecked_defaults:returnnamespace = {name: conversion.classes[key] for name, key in conversion.recursive_refs.items()@@ -410,7 +411,7 @@ def _resolve_recursive_types(conversion: _Conversion) -> None:if cls.__name__ == conversion.root_class_name:namespace[conversion.root_class_name] = clsfor cls in conversion.classes.values():- if is_dataclass(cls):+ if conversion.recursive_refs and is_dataclass(cls):hints = get_type_hints(cls,localns={cls.__name__: cls, **namespace},@@ -420,25 +421,43 @@ def _resolve_recursive_types(conversion: _Conversion) -> None:for dataclass_field in fields(cls):dataclass_field.type = hints[dataclass_field.name]for cls in conversion.classes.values():- if issubclass(cls, BaseModel):+ if conversion.recursive_refs and issubclass(cls, BaseModel):cls.model_rebuild(force=True, _types_namespace={cls.__name__: cls, **namespace})rechecked: set[type[BaseModel]] = set()- for model, field_name in conversion.unchecked_defaults:- field_info = model.model_fields[field_name]- if _default_is_valid(field_info.annotation, field_info.default):- field_info.validate_default = True- rechecked.add(model)+ for cls, field_name in conversion.unchecked_defaults:+ if issubclass(cls, BaseModel):+ field_info = cls.model_fields[field_name]+ # `annotation` alone drops constraints such as `minimum`+ annotation = field_info.rebuild_annotation()+ if _default_is_valid(annotation, field_info.default):+ field_info.validate_default = True+ rechecked.add(cls)+ continue+ dataclass_field = cls.__dataclass_fields__[field_name] # type: ignore[attr-defined] # ty:ignore[unresolved-attribute]+ factory = dataclass_field.default_factory+ default = factory() if callable(factory) else dataclass_field.default+ # A `"#"` reference in a nested dataclass stays a forward reference+ # to the root, so the probe needs the namespace.+ if _default_is_valid(dataclass_field.type, default, namespace):+ dataclass_field.metadata = MappingProxyType(+ {**dataclass_field.metadata, "validate_default": True}+ )for model in rechecked:model.model_rebuild(force=True, _types_namespace={model.__name__: model, **namespace})-def _default_is_valid(field_type: Any, default: Any) -> bool:+def _default_is_valid(+ field_type: Any, default: Any, namespace: dict[str, Any] | None = None+) -> bool:try:- TypeAdapter(field_type).validate_python(default)+ adapter = TypeAdapter(field_type)+ if namespace:+ adapter.rebuild(_types_namespace=namespace)+ adapter.validate_python(default)except Exception:# Invalid, or not checkable yet because a recursive reference is unresolvedreturn False@@ -1344,6 +1363,7 @@ def _build_dataclass(required = schema.get("required", [])fields: list[tuple[Any, ...]] = []+ unchecked: list[str] = []used_field_names: set[str] = set()for prop_name, prop_schema in properties.items():field_name = _sanitize_name(prop_name)@@ -1372,9 +1392,14 @@ def _build_dataclass(is_required = prop_name in required# Include alias in field metadata- meta = {"alias": prop_name}+ meta: dict[str, Any] = {"alias": prop_name}if default_val is not MISSING:+ # Only valid defaults are validated (and hydrated); invalid ones+ # are kept as-is, matching the model path.+ meta["validate_default"] = _default_is_valid(field_type, default_val)+ if not meta["validate_default"]:+ unchecked.append(field_name)if isinstance(default_val, dict | list):field_def = field(default_factory=lambda d=default_val: deepcopy(d), metadata=meta@@ -1399,10 +1424,13 @@ def _build_dataclass(@classmethoddef _apply_defaults(cls, data: Mapping[str, Any]):if isinstance(data, dict):- return _merge_defaults(data, original_schema)+ # Omitted fields fall back to the field defaults, which validate+ # only when valid; object defaults are still merged here.+ return _merge_defaults(data, original_schema, apply_property_defaults=False)return datacls._apply_defaults = _apply_defaults # type: ignore[attr-defined] # ty:ignore[unresolved-attribute]+ _conversion.get().unchecked_defaults.extend((cls, f) for f in unchecked)return cls@@ -1410,6 +1438,8 @@ def _merge_defaults(data: Mapping[str, Any],schema: Mapping[str, Any],parent_default: Mapping[str, Any] | None = None,+ *,+ apply_property_defaults: bool = True,) -> dict[str, Any]:"""Merge defaults with provided data at all levels."""# If we have no data@@ -1447,7 +1477,7 @@ def _merge_defaults(continue# If property is missing, apply defaults in priority order- if prop_name not in result:+ if apply_property_defaults and prop_name not in result:if parent_default and prop_name in parent_default:result[prop_name] = parent_default[prop_name]elif "default" in prop_schema:@@ -1467,7 +1497,10 @@ def _merge_defaults(nested_default = prop_schema["default"]result[prop_name] = _merge_defaults(- result[prop_name], prop_schema, nested_default+ result[prop_name],+ prop_schema,+ nested_default,+ apply_property_defaults=apply_property_defaults,)return resultdiff --git a/tests/utilities/json_schema_type/test_advanced.py b/tests/utilities/json_schema_type/test_advanced.pyindex d7554ee5b..27dbd302b 100644--- a/tests/utilities/json_schema_type/test_advanced.py+++ b/tests/utilities/json_schema_type/test_advanced.py@@ -6,6 +6,8 @@ from typing import Any, Union, castimport pytestfrom pydantic import BaseModel, TypeAdapter, ValidationError+from fastmcp import Client, FastMCP+from fastmcp.tools import ToolResultfrom fastmcp.utilities.json_schema_type import (_hash_schema,_merge_defaults,@@ -26,6 +28,142 @@ def unwrap_optional(field: Field) -> Any:class TestDefaultValues:"""Test suite for default value handling."""+ @pytest.mark.parametrize("additional_properties", [None, True, False])+ def test_invalid_defaults_only_apply_to_omitted_fields(+ self, additional_properties: bool | None+ ) -> None:+ schema: dict[str, Any] = {+ "type": "object",+ "properties": {+ "name": {"type": "string", "default": None},+ "count": {"type": "integer", "minimum": 1, "default": 0},+ },+ }+ if additional_properties is not None:+ schema["additionalProperties"] = additional_properties+ validator: TypeAdapter[Any] = TypeAdapter(json_schema_to_type(schema))++ result = validator.validate_python({})+ assert result.name is None+ assert result.count == 0+ assert validator.validate_python({"name": "Alice", "count": 2}).name == "Alice"+ with pytest.raises(ValidationError):+ validator.validate_python({"name": None})+ with pytest.raises(ValidationError):+ validator.validate_python({"count": 0})++ def test_nested_omitted_field_preserves_invalid_default(self) -> None:+ schema = {+ "type": "object",+ "properties": {+ "user": {+ "type": "object",+ "properties": {"name": {"type": "string", "default": None}},+ }+ },+ }+ validator: TypeAdapter[Any] = TypeAdapter(json_schema_to_type(schema))++ assert validator.validate_python({"user": {}}).user.name is None+ with pytest.raises(ValidationError):+ validator.validate_python({"user": {"name": None}})++ @pytest.mark.parametrize("many", [False, True])+ def test_recursive_defaults_are_hydrated(self, many: bool) -> None:+ child = {"name": "child", "child": [] if many else None}+ schema = {+ "type": "object",+ "properties": {+ "name": {"type": "string"},+ "child": {+ **(+ {"type": "array", "items": {"$ref": "#"}}+ if many+ else {"anyOf": [{"$ref": "#"}, {"type": "null"}]}+ ),+ "default": [child] if many else child,+ },+ },+ }+ node_type = json_schema_to_type(schema)+ validator: TypeAdapter[Any] = TypeAdapter(node_type)++ result = validator.validate_python({})+ default_child = result.child[0] if many else result.child+ assert isinstance(default_child, node_type)+ assert default_child.name == "child"+ assert default_child.child == ([] if many else None)+ other = validator.validate_python({})+ assert default_child is not (other.child[0] if many else other.child)++ override = {"name": "override", "child": [] if many else None}+ result = validator.validate_python({"child": [override] if many else override})+ explicit_child = result.child[0] if many else result.child+ assert isinstance(explicit_child, node_type)+ assert explicit_child.name == "override"+ invalid = {"name": 1, "child": [] if many else None}+ with pytest.raises(ValidationError):+ validator.validate_python({"child": [invalid] if many else invalid})++ @pytest.mark.parametrize("default", ["invalid", {"name": 1, "child": None}])+ def test_invalid_recursive_defaults_are_preserved(self, default: Any) -> None:+ schema = {+ "type": "object",+ "properties": {+ "name": {"type": "string"},+ "child": {+ "anyOf": [{"$ref": "#"}, {"type": "null"}],+ "default": default,+ },+ },+ }+ validator: TypeAdapter[Any] = TypeAdapter(json_schema_to_type(schema))++ assert validator.validate_python({}).child == default+ with pytest.raises(ValidationError):+ validator.validate_python({"child": default})++ def test_constrained_invalid_default_in_recursive_model_is_preserved(+ self,+ ) -> None:+ node = {+ "type": "object",+ "additionalProperties": True,+ "properties": {"child": {"$ref": "#/$defs/Node"}},+ }+ schema = {+ "type": "object",+ "additionalProperties": True,+ "properties": {+ "count": {"type": "integer", "minimum": 1, "default": 0},+ "child": {"$ref": "#/$defs/Node"},+ },+ "$defs": {"Node": node},+ }+ validator: TypeAdapter[Any] = TypeAdapter(json_schema_to_type(schema))++ assert validator.validate_python({}).count == 0+ with pytest.raises(ValidationError):+ validator.validate_python({"count": 0})++ async def test_tool_result_preserves_invalid_schema_default(self) -> None:+ server = FastMCP("Defaults")++ @server.tool(+ output_schema={+ "type": "object",+ "properties": {"name": {"type": "string", "default": None}},+ }+ )+ def lookup() -> ToolResult:+ return ToolResult(structured_content={})++ async with Client(server) as client:+ result = await client.call_tool("lookup", {})++ assert result.data is not None+ assert result.data.name is None+@pytest.fixturedef simple_defaults(self):return json_schema_to_type(