工具参数复用了基础规则，新增字段为什么总被拒绝？

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

from jsonschema import Draft202012Validator

EXPECTED_VERSION = '4.26.0'
DIALECT = 'https://json-schema.org/draft/2020-12/schema'
checks = []


def check(name, condition):
    if not condition:
        raise AssertionError(name)
    checks.append(name)


def schemas():
    base_open = {'type': 'object', 'properties': {'document_id': {'type': 'string', 'minLength': 1}},
                 'required': ['document_id']}
    base_closed = {**deepcopy(base_open), 'additionalProperties': False}
    extension = {'$schema': DIALECT, 'type': 'object',
                 'properties': {'language': {'enum': ['zh', 'en']}}, 'required': ['language']}
    result = {}
    result['closed_base'] = {**deepcopy(extension), 'allOf': [deepcopy(base_closed)]}
    result['outer_only'] = {**deepcopy(extension), 'allOf': [deepcopy(base_open)],
                            'additionalProperties': False}
    result['redeclared'] = {**deepcopy(extension), 'allOf': [deepcopy(base_open)],
                           'properties': {**deepcopy(extension['properties']), 'document_id': {}},
                           'additionalProperties': False}
    result['unevaluated'] = {**deepcopy(extension), 'allOf': [deepcopy(base_open)],
                            'unevaluatedProperties': False}
    result['closed_plus_unevaluated'] = {**deepcopy(result['closed_base']), 'unevaluatedProperties': False}
    result['open_everywhere'] = {**deepcopy(extension), 'allOf': [deepcopy(base_open)]}
    return result


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


def error_records(validator, payload):
    records = [{'keyword': str(error.validator), 'instancePath': list(error.absolute_path),
                'schemaPath': list(error.absolute_schema_path)} for error in validator.iter_errors(payload)]
    return sorted(records, key=lambda row: json.dumps(row, sort_keys=True))


def main():
    installed = version('jsonschema')
    check('pinned jsonschema version', installed == EXPECTED_VERSION)
    contracts = schemas()
    original_contracts = deepcopy(contracts)
    validators = {name: make_validator(schema) for name, schema in contracts.items()}
    names = list(validators)
    cases = [
        ('valid', {'document_id': 'D7', 'language': 'zh'}, [False, False, True, True, False, True]),
        ('old_id_only', {'document_id': 'D7'}, [False] * 6),
        ('only_language', {'language': 'zh'}, [False] * 6),
        ('bad_id_type', {'document_id': 7, 'language': 'zh'}, [False] * 6),
        ('unknown_language', {'document_id': 'D7', 'language': 'fr'}, [False] * 6),
        ('extra_field', {'document_id': 'D7', 'language': 'zh', 'debug': True}, [False, False, False, False, False, True]),
        ('null', None, [False] * 6),
        ('empty_id', {'document_id': '', 'language': 'zh'}, [False] * 6),
    ]
    print('jsonschema=' + installed)
    print('columns=' + ','.join(names))
    report = []
    for label, payload, expected in cases:
        before = deepcopy(payload)
        results = [validator.is_valid(payload) for validator in validators.values()]
        for name, got, want in zip(names, results, expected):
            check(label + ' / ' + name, got is want)
        check(label + ' input unchanged', payload == before)
        report.append({'case': label, 'payload': payload, 'accepted': dict(zip(names, results)),
                       'errors': {name: error_records(validator, payload) for name, validator in validators.items()}})
        print(label + ': ' + ','.join('T' if valid else 'F' for valid in results))

    valid_payload = {'document_id': 'D7', 'language': 'zh'}
    closed_errors = error_records(validators['closed_base'], valid_payload)
    outer_errors = error_records(validators['outer_only'], valid_payload)
    check('closed base rejects at its own keyword', any(
        e['keyword'] == 'additionalProperties' and e['schemaPath'] == ['allOf', 0, 'additionalProperties']
        for e in closed_errors))
    check('outer-only closure rejects at root', any(
        e['keyword'] == 'additionalProperties' and e['schemaPath'] == ['additionalProperties']
        for e in outer_errors))
    check('outer unevaluated does not override failing inner closure', any(
        e['keyword'] == 'additionalProperties' and e['schemaPath'] == ['allOf', 0, 'additionalProperties']
        for e in error_records(validators['closed_plus_unevaluated'], valid_payload)))

    # Independent truth table over a small, declared input domain.
    missing = object()
    count = 0
    for document_id, language, extra in product([missing, '', 'D7', 7], [missing, 'zh', 'en', 'fr', 7], [False, True]):
        payload = {}
        if document_id is not missing:
            payload['document_id'] = document_id
        if language is not missing:
            payload['language'] = language
        if extra:
            payload['debug'] = True
        fields_valid = type(document_id) is str and bool(document_id) and language in ('zh', 'en')
        expected_closed = bool(fields_valid and not extra)
        check('finite redeclared oracle ' + str(count), validators['redeclared'].is_valid(payload) == expected_closed)
        check('finite unevaluated oracle ' + str(count), validators['unevaluated'].is_valid(payload) == expected_closed)
        check('finite open oracle ' + str(count), validators['open_everywhere'].is_valid(payload) == bool(fields_valid))
        count += 1
    check('schema definitions unchanged', contracts == original_contracts)
    print(f'finite_objects={count}; repaired_contracts_match_oracle=True')
    print('outer_unevaluated_does_not_override_closed_base=True')
    print(f'PASS checks={len(checks)}')
    Path('report.json').write_text(json.dumps({
        'jsonschema': installed, 'scope': 'fixed local schemas for a fictional read-only lookup; no actual lookup',
        'schemas': contracts, 'columns': names, 'cases': report, 'finite_objects': count,
        'checks': len(checks), 'passed': checks,
    }, ensure_ascii=False, indent=2) + '\n', encoding='utf-8')


if __name__ == '__main__':
    main()