两种工具参数都填对了，为什么 oneOf 反而拒绝？

"""Real jsonschema branch validation for a fictional read-only lookup tool."""
from copy import deepcopy
from importlib.metadata import version
from itertools import product
import json
from pathlib import Path

from jsonschema import Draft202012Validator
from jsonschema.exceptions import ValidationError

EXPECTED_VERSION = "4.26.0"
DIALECT = "https://json-schema.org/draft/2020-12/schema"
checks = 0


def check(condition, message):
    global checks
    if not condition:
        raise AssertionError(message)
    checks += 1


def branch(field):
    return {"properties": {field: {"type": "string", "minLength": 1}}, "required": [field]}


def lookup_schema(combinator, branches):
    return {"$schema": DIALECT, "type": "object", "properties": {"document_id": {}, "query": {}},
            "additionalProperties": False, combinator: branches}


def validator(schema):
    Draft202012Validator.check_schema(schema)
    return Draft202012Validator(schema)


def main():
    installed = version("jsonschema")
    check(installed == EXPECTED_VERSION, "install requirements.txt first")
    branches = [branch("document_id"), branch("query")]
    per_branch = [validator(item) for item in branches]
    any_validator = validator(lookup_schema("anyOf", branches))
    one_validator = validator(lookup_schema("oneOf", branches))
    report = []
    cases = [
        ("only_id", {"document_id": "D7"}, 1, True, True),
        ("only_query", {"query": "cache"}, 1, True, True),
        ("both", {"document_id": "D7", "query": "cache"}, 2, True, False),
        ("neither", {}, 0, False, False),
        ("bad_id_type", {"document_id": 7}, 0, False, False),
        ("empty_query", {"query": ""}, 0, False, False),
        ("mixed_types", {"document_id": "D7", "query": 7}, 1, True, True),
    ]
    print("jsonschema=" + installed)
    for name, payload, want_matches, want_any, want_one in cases:
        before = deepcopy(payload)
        matches = sum(item.is_valid(payload) for item in per_branch)
        any_ok = any_validator.is_valid(payload)
        one_ok = one_validator.is_valid(payload)
        check(matches == want_matches, name + " matching branches")
        check(any_ok is want_any, name + " anyOf")
        check(one_ok is want_one, name + " oneOf")
        check(payload == before, name + " unchanged")
        print(f"{name}: matches={matches}; anyOf={any_ok}; oneOf={one_ok}")
        report.append(dict(case=name, payload=payload, matches=matches, anyOf=any_ok, oneOf=one_ok))

    # Independent finite oracle: a branch requires its own nonempty string.
    missing = object()
    values = [missing, "", "ok", 7]
    enumerated = 0
    for left, right in product(values, repeat=2):
        payload = {}
        if left is not missing:
            payload["document_id"] = left
        if right is not missing:
            payload["query"] = right
        count = int(type(left) is str and len(left) > 0) + int(type(right) is str and len(right) > 0)
        check(any_validator.is_valid(payload) == (count >= 1), "finite anyOf oracle")
        check(one_validator.is_valid(payload) == (count == 1), "finite oneOf oracle")
        enumerated += 1

    no_required = [{"properties": deepcopy(item["properties"])} for item in branches]
    check(validator(lookup_schema("anyOf", no_required)).is_valid({}), "empty matches both")
    check(not validator(lookup_schema("oneOf", no_required)).is_valid({}), "two matches rejected")
    print("missing_required_empty: matches=2; anyOf=True; oneOf=False")
    check(not validator({"oneOf": [True, True, True]}).is_valid({}), "three matches also rejected")
    print("three_matching_branches: oneOf=False")

    tagged_branches = [
        {"properties": {"mode": {"const": "id"}, "document_id": {"type": "string", "minLength": 1}},
         "required": ["mode", "document_id"], "additionalProperties": False},
        {"properties": {"mode": {"const": "text"}, "query": {"type": "string", "minLength": 1}},
         "required": ["mode", "query"], "additionalProperties": False},
    ]
    tagged = validator({"$schema": DIALECT, "type": "object", "oneOf": tagged_branches})
    tagged_cases = [
        ({"mode": "id", "document_id": "D7"}, True),
        ({"mode": "text", "query": "cache"}, True),
        ({"document_id": "D7"}, False),
        ({"mode": "id", "document_id": "D7", "query": "cache"}, False),
        ({"mode": "other", "query": "cache"}, False),
        ({"mode": "id", "document_id": 7}, False),
    ]
    for payload, expected in tagged_cases:
        check(tagged.is_valid(payload) is expected, "tagged contract")
    check(not tagged.is_valid(None), "explicit root type rejects null")
    print("tagged_modes: accepted=2; rejected=4; null=rejected")

    error_paths = {}
    for label, payload in [("zero_matches", {}), ("two_matches", {"document_id": "D7", "query": "cache"})]:
        try:
            one_validator.validate(payload)
        except ValidationError as error:
            check(error.validator == "oneOf", label + " keyword")
            check(list(error.absolute_path) == [], label + " root instance path")
            check(list(error.absolute_schema_path) == ["oneOf"], label + " schema path")
            error_paths[label] = {"instance": [], "schema": ["oneOf"], "context_count": len(error.context)}
        else:
            raise AssertionError("invalid oneOf payload accepted")
    check(error_paths["zero_matches"]["context_count"] == 2, "required errors retained")
    check(error_paths["two_matches"]["context_count"] == 0, "no failing subbranch to retain")
    print("error_context: zero_matches=2; two_matches=0")
    print(f"finite_field_combinations={enumerated}; PASS checks={checks}")
    Path("report.json").write_text(json.dumps({
        "jsonschema": installed, "scope": "fixed read-only lookup schemas; no lookup executed",
        "cases": report, "error_paths": error_paths, "finite_combinations": enumerated, "checks": checks,
    }, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")


if __name__ == "__main__":
    main()