Handle allOf and oneOf in json_schema_to_type

Previously these compositions silently resolved to Any, disabling
all validation for schemas that use them. allOf is now merged into
a single object schema; oneOf creates a Union type.

🤖 Generated with Claude Code

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: strawgate

src/fastmcp/utilities/json_schema_type.py

@@ -441,6 +441,50 @@ def _schema_to_type(
             else:
                 return Union[tuple(types)]  # type: ignore # noqa: UP007
 
+    # Handle allOf (schema intersection / composition).
+    # Merge all sub-schemas into a single object schema, then process it.
+    if "allOf" in schema:
+        merged: dict[str, Any] = {}
+        merged_properties: dict[str, Any] = {}
+        merged_required: list[str] = []
+        for sub in schema["allOf"]:
+            if isinstance(sub, bool):
+                continue
+            # Resolve $ref before merging
+            if "$ref" in sub:
+                sub = dict(_resolve_ref(sub["$ref"], schemas))
+            merged_properties.update(sub.get("properties", {}))
+            merged_required.extend(sub.get("required", []))
+            # Carry over other keys from the first sub-schema that has them
+            for key in ("title", "description", "additionalProperties"):
+                if key in sub and key not in merged:
+                    merged[key] = sub[key]
+        if merged_properties:
+            merged["type"] = "object"
+            merged["properties"] = merged_properties
+            if merged_required:
+                merged["required"] = list(dict.fromkeys(merged_required))
+            return _schema_to_type(merged, schemas)
+        # allOf with no mergeable properties — fall through to Any
+
+    # Handle oneOf (exactly-one-of union).
+    # Treat like anyOf for type construction — Pydantic's Union
+    # does "first match" which is a reasonable approximation.
+    if "oneOf" in schema:
+        types: list[type | Any] = []
+        for subschema in schema["oneOf"]:
+            types.append(_schema_to_type(subschema, schemas))
+        has_null = type(None) in types
+        types = [t for t in types if t is not type(None)]
+        if len(types) == 0:
+            return type(None)
+        elif len(types) == 1:
+            return types[0] | None if has_null else types[0]  # type: ignore
+        else:
+            if has_null:
+                return Union[(*types, type(None))]  # type: ignore
+            return Union[tuple(types)]  # type: ignore # noqa: UP007
+
     schema_type = schema.get("type")
     if not schema_type:
         return Any

tests/utilities/json_schema_type/test_json_schema_type.py

@@ -310,3 +310,120 @@ def test_empty_property_name(self):
         field_names = [f.name for f in dataclasses.fields(T)]
         assert len(field_names) == 2
         assert len(set(field_names)) == 2
+
+
+class TestAllOfOneOf:
+    """allOf and oneOf composition, previously returning Any."""
+
+    def test_allof_merges_properties(self):
+        """allOf sub-schemas should be merged into a single object type."""
+        schema = {
+            "allOf": [
+                {
+                    "type": "object",
+                    "properties": {"name": {"type": "string"}},
+                    "required": ["name"],
+                },
+                {
+                    "type": "object",
+                    "properties": {"age": {"type": "integer"}},
+                },
+            ]
+        }
+        T = json_schema_to_type(schema)
+        ta = TypeAdapter(T)
+
+        result = ta.validate_python({"name": "Alice", "age": 30})
+        assert result.name == "Alice"  # ty:ignore[unresolved-attribute]
+        assert result.age == 30  # ty:ignore[unresolved-attribute]
+
+    def test_allof_preserves_required(self):
+        """Required fields from all allOf sub-schemas should be enforced."""
+        schema = {
+            "allOf": [
+                {
+                    "type": "object",
+                    "properties": {"name": {"type": "string"}},
+                    "required": ["name"],
+                },
+                {
+                    "type": "object",
+                    "properties": {"age": {"type": "integer"}},
+                },
+            ]
+        }
+        T = json_schema_to_type(schema)
+        ta = TypeAdapter(T)
+
+        with pytest.raises(ValidationError):
+            ta.validate_python({"age": 30})  # missing required 'name'
+
+    def test_allof_with_ref(self):
+        """allOf with $ref should resolve and merge the referenced schema."""
+        schema = {
+            "allOf": [
+                {"$ref": "#/$defs/Base"},
+                {
+                    "type": "object",
+                    "properties": {"extra": {"type": "string"}},
+                },
+            ],
+            "$defs": {
+                "Base": {
+                    "type": "object",
+                    "properties": {"id": {"type": "integer"}},
+                    "required": ["id"],
+                }
+            },
+        }
+        T = json_schema_to_type(schema)
+        ta = TypeAdapter(T)
+
+        result = ta.validate_python({"id": 1, "extra": "hello"})
+        assert result.id == 1  # ty:ignore[unresolved-attribute]
+        assert result.extra == "hello"  # ty:ignore[unresolved-attribute]
+
+    def test_oneof_creates_union(self):
+        """oneOf should create a Union type that accepts any sub-schema."""
+        schema = {
+            "oneOf": [
+                {
+                    "type": "object",
+                    "properties": {
+                        "kind": {"const": "dog"},
+                        "breed": {"type": "string"},
+                    },
+                    "required": ["kind", "breed"],
+                },
+                {
+                    "type": "object",
+                    "properties": {
+                        "kind": {"const": "cat"},
+                        "indoor": {"type": "boolean"},
+                    },
+                    "required": ["kind", "indoor"],
+                },
+            ]
+        }
+        T = json_schema_to_type(schema)
+        ta = TypeAdapter(T)
+
+        dog = ta.validate_python({"kind": "dog", "breed": "lab"})
+        assert dog.kind == "dog"  # ty:ignore[unresolved-attribute]
+
+        cat = ta.validate_python({"kind": "cat", "indoor": True})
+        assert cat.indoor is True  # ty:ignore[unresolved-attribute]
+
+    def test_oneof_with_scalars(self):
+        """oneOf with scalar types should create a Union."""
+        schema = {
+            "oneOf": [
+                {"type": "string"},
+                {"type": "integer"},
+            ]
+        }
+        T = json_schema_to_type(schema)
+        ta = TypeAdapter(T)
+
+        assert ta.validate_python("hello") == "hello"
+        assert ta.validate_python(42) == 42