Fix the failing test from its log. Public repository OmniNode-ai/omnibase_core, snapshot c48f898b6eb5bc2427a3ee2898591bed69cafc8b.
Return only a unified diff for src/omnibase_core/models/core/model_custom_filters.py; do not change any test, contract, configuration, dependency or other file. The regression was seeded by restoring this product source file to the parent of a recent fix commit. Do not assume access to a workspace. Preserve existing behavior and strong UUID types.
The unchanged test command is: pytest tests/unit/models/core/test_omn17710_custom_filters_completion.py -q --tb=short
Failing test log:
[1m============================= test session starts ==============================[0m
platform darwin -- Python 3.13.12, pytest-9.0.3, pluggy-1.6.0
rootdir: fixture-root
configfile: pytest.ini
plugins: hypothesis-6.151.6, mock-3.15.1, locust-2.43.3, xdist-3.8.0, split-0.11.0, timeout-2.4.0, cov-6.3.0, anyio-4.14.2, pytest_httpserver-1.1.5, asyncio-1.3.0
asyncio: mode=Mode.STRICT, debug=False, asyncio_default_fixture_loop_scope=None, asyncio_default_test_loop_scope=function
collected 24 items

tests/unit/models/core/test_omn17710_custom_filters_completion.py [31mF[0m[31mF[0m[31mF[0m[32m.[0m[32m.[0m[32m.[0m[31m [ 25%]
[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[31mF[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[31m                                                       [100%][0m

=================================== FAILURES ===================================
[31m[1m_ test_complex_and_aggregate_are_complete_in_fresh_import_orders[from omnibase_core.models.core.model_complex_filter import ModelComplexFilter] _[0m
[1m[31mtests/unit/models/core/test_omn17710_custom_filters_completion.py[0m:118: in test_complex_and_aggregate_are_complete_in_fresh_import_orders
    [0m[94massert[39;49;00m result.returncode == [94m0[39;49;00m, result.stderr[90m[39;49;00m
[1m[31mE   AssertionError: Traceback (most recent call last):[0m
[1m[31mE       File "<string>", line 12, in <module>[0m
[1m[31mE         assert ModelCustomFilters.model_json_schema()["additionalProperties"] is False[0m
[1m[31mE                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^[0m
[1m[31mE     KeyError: 'additionalProperties'[0m
[1m[31mE     [0m
[1m[31mE   assert 1 == 0[0m
[1m[31mE    +  where 1 = CompletedProcess(args=['fixture-root', '-c', '\nfrom omnibase_core.model...alse\n           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^\nKeyError: \'additionalProperties\'\n').returncode[0m
[31m[1m_ test_complex_and_aggregate_are_complete_in_fresh_import_orders[from omnibase_core.models.core.model_custom_filters import ModelCustomFilters] _[0m
[1m[31mtests/unit/models/core/test_omn17710_custom_filters_completion.py[0m:118: in test_complex_and_aggregate_are_complete_in_fresh_import_orders
    [0m[94massert[39;49;00m result.returncode == [94m0[39;49;00m, result.stderr[90m[39;49;00m
[1m[31mE   AssertionError: Traceback (most recent call last):[0m
[1m[31mE       File "<string>", line 12, in <module>[0m
[1m[31mE         assert ModelCustomFilters.model_json_schema()["additionalProperties"] is False[0m
[1m[31mE                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^[0m
[1m[31mE     KeyError: 'additionalProperties'[0m
[1m[31mE     [0m
[1m[31mE   assert 1 == 0[0m
[1m[31mE    +  where 1 = CompletedProcess(args=['fixture-root', '-c', '\nfrom omnibase_core.model...alse\n           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^\nKeyError: \'additionalProperties\'\n').returncode[0m
[31m[1m_ test_complex_and_aggregate_are_complete_in_fresh_import_orders[from omnibase_core.models.core.model_filter_criteria import ModelFilterCriteria] _[0m
[1m[31mtests/unit/models/core/test_omn17710_custom_filters_completion.py[0m:118: in test_complex_and_aggregate_are_complete_in_fresh_import_orders
    [0m[94massert[39;49;00m result.returncode == [94m0[39;49;00m, result.stderr[90m[39;49;00m
[1m[31mE   AssertionError: Traceback (most recent call last):[0m
[1m[31mE       File "<string>", line 12, in <module>[0m
[1m[31mE         assert ModelCustomFilters.model_json_schema()["additionalProperties"] is False[0m
[1m[31mE                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^[0m
[1m[31mE     KeyError: 'additionalProperties'[0m
[1m[31mE     [0m
[1m[31mE   assert 1 == 0[0m
[1m[31mE    +  where 1 = CompletedProcess(args=['fixture-root', '-c', '\nfrom omnibase_core.model...alse\n           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^\nKeyError: \'additionalProperties\'\n').returncode[0m
[31m[1m_ test_custom_filters_reject_unknown_fields_at_every_contract_boundary[payload0] _[0m
[1m[31mtests/unit/models/core/test_omn17710_custom_filters_completion.py[0m:208: in test_custom_filters_reject_unknown_fields_at_every_contract_boundary
    [0m[94mwith[39;49;00m pytest.raises(ValidationError) [94mas[39;49;00m exc_info:[90m[39;49;00m
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^[90m[39;49;00m
[1m[31mE   Failed: DID NOT RAISE <class 'pydantic_core._pydantic_core.ValidationError'>[0m
[36m[1m=========================== short test summary info ============================[0m
[31mFAILED[0m tests/unit/models/core/test_omn17710_custom_filters_completion.py::[1mtest_complex_and_aggregate_are_complete_in_fresh_import_orders[from omnibase_core.models.core.model_complex_filter import ModelComplexFilter][0m - AssertionError: Traceback (most recent call last):
[31mFAILED[0m tests/unit/models/core/test_omn17710_custom_filters_completion.py::[1mtest_complex_and_aggregate_are_complete_in_fresh_import_orders[from omnibase_core.models.core.model_custom_filters import ModelCustomFilters][0m - AssertionError: Traceback (most recent call last):
[31mFAILED[0m tests/unit/models/core/test_omn17710_custom_filters_completion.py::[1mtest_complex_and_aggregate_are_complete_in_fresh_import_orders[from omnibase_core.models.core.model_filter_criteria import ModelFilterCriteria][0m - AssertionError: Traceback (most recent call last):
[31mFAILED[0m tests/unit/models/core/test_omn17710_custom_filters_completion.py::[1mtest_custom_filters_reject_unknown_fields_at_every_contract_boundary[payload0][0m - Failed: DID NOT RAISE <class 'pydantic_core._pydantic_core.ValidationError'>
[31m========================= [31m[1m4 failed[0m, [32m20 passed[0m[31m in 4.55s[0m[31m =========================[0m


Current faulty source src/omnibase_core/models/core/model_custom_filters.py:
```python
# SPDX-FileCopyrightText: 2025 OmniNode.ai Inc.
# SPDX-License-Identifier: MIT

"""Collection of custom filters model."""

from __future__ import annotations

from typing import Any, cast

from pydantic import BaseModel, Field

from omnibase_core.enums.enum_core_error_code import EnumCoreErrorCode
from omnibase_core.models.common.model_schema_value import ModelSchemaValue
from omnibase_core.models.errors.model_onex_error import ModelOnexError
from omnibase_core.types.type_serializable_value import SerializedDict

from .model_complex_filter import ModelComplexFilter
from .model_datetime_filter import ModelDateTimeFilter
from .model_list_filter import ModelListFilter
from .model_metadata_filter import ModelMetadataFilter
from .model_numeric_filter import ModelNumericFilter
from .model_status_filter import ModelStatusFilter
from .model_string_filter import ModelStringFilter


class ModelCustomFilters(BaseModel):
    """
    Collection of custom filters.

    Replaces Dict[str, Any] for custom_filters fields with typed filters.
    """

    # union-ok: discriminated_model_union - All filter types share filter_type discriminator field
    filters: dict[
        str,
        ModelStringFilter
        | ModelNumericFilter
        | ModelDateTimeFilter
        | ModelListFilter
        | ModelMetadataFilter
        | ModelStatusFilter
        | ModelComplexFilter,
    ] = Field(default_factory=dict, description="Named custom filters")

    def add_string_filter(self, name: str, pattern: str, **kwargs: Any) -> None:
        """Add a string filter."""
        self.filters[name] = ModelStringFilter(pattern=pattern, **kwargs)

    def add_numeric_filter(self, name: str, **kwargs: Any) -> None:
        """Add a numeric filter."""
        self.filters[name] = ModelNumericFilter(**kwargs)

    def add_datetime_filter(self, name: str, **kwargs: Any) -> None:
        """Add a datetime filter."""
        self.filters[name] = ModelDateTimeFilter(**kwargs)

    def add_list_filter(
        self,
        name: str,
        values: list[object] | list[ModelSchemaValue],
        **kwargs: Any,
    ) -> None:
        """Add a list filter.

        Values are automatically converted to ModelSchemaValue for type safety.
        """
        self.filters[name] = ModelListFilter(
            values=cast(list[ModelSchemaValue], values), **kwargs
        )

    def add_metadata_filter(
        self, name: str, key: str, value: object, **kwargs: Any
    ) -> None:
        """Add a metadata filter."""
        self.filters[name] = ModelMetadataFilter(
            metadata_key=key,
            metadata_value=value,
            **kwargs,
        )

    def add_status_filter(self, name: str, allowed: list[str], **kwargs: Any) -> None:
        """Add a status filter."""
        self.filters[name] = ModelStatusFilter(allowed_statuses=allowed, **kwargs)

    # union-ok: discriminated_model_union - All filter types share filter_type discriminator field
    def get_filter(
        self, name: str
    ) -> (
        ModelStringFilter
        | ModelNumericFilter
        | ModelDateTimeFilter
        | ModelListFilter
        | ModelMetadataFilter
        | ModelStatusFilter
        | ModelComplexFilter
        | None
    ):
        """Get a filter by name."""
        return self.filters.get(name)

    def remove_filter(self, name: str) -> None:
        """Remove a filter by name."""
        self.filters.pop(name, None)

    def to_dict(self) -> SerializedDict:
        """Convert to dictionary (for current standards)."""
        # Custom transformation logic for filters dictionary
        return {name: filter_obj.to_dict() for name, filter_obj in self.filters.items()}

    @classmethod
    def from_dict(cls, data: SerializedDict) -> ModelCustomFilters:
        """Create from dictionary (for migration)."""
        # union-ok: discriminated_model_union - All filter types share filter_type discriminator field
        filters: dict[
            str,
            ModelStringFilter
            | ModelNumericFilter
            | ModelDateTimeFilter
            | ModelListFilter
            | ModelMetadataFilter
            | ModelStatusFilter
            | ModelComplexFilter,
        ] = {}

        for name, filter_data in data.items():
            if isinstance(filter_data, dict) and "filter_type" in filter_data:
                filter_type = filter_data["filter_type"]

                if filter_type == "string":
                    filters[name] = ModelStringFilter.model_validate(filter_data)
                elif filter_type == "numeric":
                    filters[name] = ModelNumericFilter.model_validate(filter_data)
                elif filter_type == "datetime":
                    filters[name] = ModelDateTimeFilter.model_validate(filter_data)
                elif filter_type == "list" or filter_type == "list[Any]":
                    filters[name] = ModelListFilter.model_validate(filter_data)
                elif filter_type == "metadata":
                    filters[name] = ModelMetadataFilter.model_validate(filter_data)
                elif filter_type == "status":
                    filters[name] = ModelStatusFilter.model_validate(filter_data)
                elif filter_type == "complex":
                    filters[name] = ModelComplexFilter.model_validate(filter_data)
                else:
                    raise ModelOnexError(
                        message=f"Unknown filter_type '{filter_type}' for filter '{name}'",
                        error_code=EnumCoreErrorCode.VALIDATION_ERROR,
                    )
            else:
                raise ModelOnexError(
                    message=f"Filter '{name}' must be a dict with 'filter_type' key",
                    error_code=EnumCoreErrorCode.VALIDATION_ERROR,
                )

        return cls(filters=filters)

```
Unchanged test source:
```python
# SPDX-FileCopyrightText: 2025 OmniNode.ai Inc.
# SPDX-License-Identifier: MIT

"""Fresh-completion and composition regressions for OMN-17710."""

from __future__ import annotations

import subprocess
import sys
import textwrap
from pathlib import Path
from typing import cast

import pytest
from pydantic import ValidationError

from omnibase_core.models.core.model_complex_filter import ModelComplexFilter
from omnibase_core.models.core.model_custom_filter_base import ModelCustomFilterBase
from omnibase_core.models.core.model_custom_filters import ModelCustomFilters
from omnibase_core.models.core.model_datetime_filter import ModelDateTimeFilter
from omnibase_core.models.core.model_filter_criteria import ModelFilterCriteria
from omnibase_core.models.core.model_list_filter import ModelListFilter
from omnibase_core.models.core.model_metadata_filter import ModelMetadataFilter
from omnibase_core.models.core.model_numeric_filter import ModelNumericFilter
from omnibase_core.models.core.model_status_filter import ModelStatusFilter
from omnibase_core.models.core.model_string_filter import ModelStringFilter
from omnibase_core.models.errors.model_onex_error import ModelOnexError
from omnibase_core.types.type_serializable_value import SerializedDict

pytestmark = pytest.mark.unit

_REPO_ROOT = Path(__file__).resolve().parents[4]


def _leaf_cases() -> list[tuple[type[ModelCustomFilterBase], dict[str, object]]]:
    return [
        (
            ModelStringFilter,
            {"filter_type": "string", "pattern": "error", "case_sensitive": True},
        ),
        (
            ModelNumericFilter,
            {"filter_type": "numeric", "min_value": 1.0, "max_value": 5.0},
        ),
        (
            ModelDateTimeFilter,
            {"filter_type": "datetime", "after": "2026-09-03T00:00:00Z"},
        ),
        (
            ModelListFilter,
            {"filter_type": "list", "values": ["ready", 2], "match_all": True},
        ),
        (
            ModelMetadataFilter,
            {
                "filter_type": "metadata",
                "metadata_key": "team",
                "metadata_value": "platform",
            },
        ),
        (
            ModelStatusFilter,
            {"filter_type": "status", "allowed_statuses": ["ready"]},
        ),
    ]


def _aggregate_cases() -> list[tuple[type[ModelCustomFilterBase], dict[str, object]]]:
    cases = _leaf_cases()
    cases.append(
        (
            ModelComplexFilter,
            {"filter_type": "complex", "sub_filters": [_leaf_cases()[0][1]]},
        )
    )
    return cases


def _run_fresh_python(source: str) -> subprocess.CompletedProcess[str]:
    return subprocess.run(
        [sys.executable, "-c", textwrap.dedent(source)],
        cwd=_REPO_ROOT,
        check=False,
        capture_output=True,
        text=True,
    )


@pytest.mark.parametrize(
    "first_import",
    [
        "from omnibase_core.models.core.model_complex_filter import ModelComplexFilter",
        "from omnibase_core.models.core.model_custom_filters import ModelCustomFilters",
        "from omnibase_core.models.core.model_filter_criteria import ModelFilterCriteria",
    ],
)
def test_complex_and_aggregate_are_complete_in_fresh_import_orders(
    first_import: str,
) -> None:
    result = _run_fresh_python(
        f"""
        {first_import}
        import omnibase_core.models.core.model_custom_filter as legacy_module
        from omnibase_core.models.core.model_complex_filter import ModelComplexFilter
        from omnibase_core.models.core.model_custom_filters import ModelCustomFilters
        from omnibase_core.models.core.model_filter_criteria import ModelFilterCriteria

        assert not hasattr(legacy_module, "ModelCustomFilters")
        assert ModelComplexFilter.__pydantic_complete__ is True
        assert ModelCustomFilters.__pydantic_complete__ is True
        assert ModelComplexFilter.model_json_schema()["additionalProperties"] is False
        assert ModelCustomFilters.model_json_schema()["additionalProperties"] is False
        assert ModelFilterCriteria.model_json_schema()["title"] == "ModelFilterCriteria"
        assert ModelFilterCriteria.model_fields["custom_filters"].annotation is ModelCustomFilters
        """
    )

    assert result.returncode == 0, result.stderr


@pytest.mark.parametrize(
    ("expected_type", "leaf_payload"),
    _leaf_cases(),
    ids=[case[0].__name__ for case in _leaf_cases()],
)
def test_complex_filter_round_trips_all_six_sub_filter_variants(
    expected_type: type[ModelCustomFilterBase],
    leaf_payload: dict[str, object],
) -> None:
    complex_filter = ModelComplexFilter.model_validate(
        {"filter_type": "complex", "sub_filters": [leaf_payload]}
    )
    restored = ModelComplexFilter.model_validate_json(complex_filter.model_dump_json())

    assert restored == complex_filter
    assert type(restored.sub_filters[0]) is expected_type


@pytest.mark.parametrize(
    ("expected_type", "filter_payload"),
    _aggregate_cases(),
    ids=[case[0].__name__ for case in _aggregate_cases()],
)
def test_custom_filters_round_trip_all_seven_variants(
    expected_type: type[ModelCustomFilterBase],
    filter_payload: dict[str, object],
) -> None:
    filters = ModelCustomFilters.from_dict(
        cast(SerializedDict, {"selected": filter_payload})
    )
    restored = ModelCustomFilters.model_validate_json(filters.model_dump_json())

    assert restored == filters
    assert type(restored.filters["selected"]) is expected_type


def test_filter_criteria_uses_canonical_custom_filters_round_trip() -> None:
    criteria = ModelFilterCriteria.from_dict(
        cast(
            SerializedDict,
            {
                "logic": "OR",
                "custom_filters": {"needle": _leaf_cases()[0][1]},
            },
        )
    )

    assert criteria is not None
    assert isinstance(criteria.custom_filters.filters["needle"], ModelStringFilter)
    assert ModelFilterCriteria.from_dict(criteria.to_dict()) == criteria
    assert (
        ModelFilterCriteria.model_validate_json(criteria.model_dump_json()) == criteria
    )


@pytest.mark.parametrize(
    "payload",
    [
        {"filters": {}, "omn17710_unknown": True},
        {
            "filters": {
                "complex": {
                    "filter_type": "complex",
                    "sub_filters": [],
                    "omn17710_unknown": True,
                }
            }
        },
        {
            "filters": {
                "complex": {
                    "filter_type": "complex",
                    "sub_filters": [
                        {
                            "filter_type": "string",
                            "pattern": "error",
                            "omn17710_unknown": True,
                        }
                    ],
                }
            }
        },
    ],
)
def test_custom_filters_reject_unknown_fields_at_every_contract_boundary(
    payload: dict[str, object],
) -> None:
    with pytest.raises(ValidationError) as exc_info:
        ModelCustomFilters.model_validate(payload)

    assert any(error["type"] == "extra_forbidden" for error in exc_info.value.errors())


@pytest.mark.parametrize(
    "malformed",
    [
        {"unknown": {"filter_type": "not-a-filter"}},
        {"missing": {"pattern": "error"}},
        {"not_a_mapping": "error"},
    ],
)
def test_custom_filter_factory_rejects_unknown_or_unbound_variants(
    malformed: dict[str, object],
) -> None:
    with pytest.raises(ModelOnexError):
        ModelCustomFilters.from_dict(cast(SerializedDict, malformed))


def test_custom_filter_factory_rejects_wrong_variant_shape() -> None:
    with pytest.raises(ValidationError):
        ModelCustomFilters.from_dict(
            cast(
                SerializedDict,
                {"wrong": {"filter_type": "string", "min_value": 1.0}},
            )
        )

```
