omnibase_infra 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

omnibase_infra/models/dispatch/model_debug_trace_snapshot.py

@@ -0,0 +1,114 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Debug trace snapshot model.
+
+This module defines the serializable trace metadata snapshot that replaces
+live envelope references in the dispatch contract.
+
+Design Rationale:
+    The dispatch boundary is a **serialization boundary**. Anything crossing
+    this boundary must be:
+    - Loggable (observability)
+    - Replayable (debugging)
+    - Transportable (Kafka, distributed dispatch)
+    - Inspectable offline (audit pipelines)
+
+    Live Python object references violate all of these requirements.
+    This snapshot model provides the trace metadata handlers need for
+    debugging without creating dependencies on internal envelope types.
+
+Warning:
+    This model exists solely for debugging and observability.
+    It must **never** be used for business logic.
+
+    The data in this snapshot is:
+    - Non-authoritative (may not reflect the complete envelope state)
+    - Metadata-only (does not include payload content)
+    - Immutable (cannot be used to modify the original envelope)
+
+.. versionadded:: 0.2.8
+    Added as part of OMN-1518 - Strict JSON-safe dispatch contract.
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ModelDebugTraceSnapshot(BaseModel):
+    """Serializable, non-authoritative trace snapshot.
+
+    This model captures trace metadata from the original envelope for
+    debugging and observability purposes. It replaces live envelope
+    references to maintain transport-safe dispatch contracts.
+
+    All fields are optional because:
+    1. Not all envelopes have all metadata fields
+    2. Extraction may fail gracefully without blocking dispatch
+    3. Debug data should never cause handler failures
+
+    Attributes:
+        event_type: The event type identifier (e.g., "UserCreated").
+        correlation_id: Correlation ID for distributed tracing (serialized UUID).
+        trace_id: Trace ID for span correlation (serialized UUID).
+        causation_id: Causation ID linking to parent event (serialized UUID).
+        topic: The Kafka/event topic this message was received on.
+        timestamp: When the event was created (ISO 8601 format).
+        partition_key: The partition key for Kafka routing.
+
+    Example:
+        >>> snapshot = ModelDebugTraceSnapshot(
+        ...     correlation_id="550e8400-e29b-41d4-a716-446655440000",
+        ...     trace_id="660e8400-e29b-41d4-a716-446655440001",
+        ...     topic="dev.user.events.v1",
+        ...     timestamp="2025-01-27T12:00:00Z",
+        ... )
+        >>> snapshot.model_dump()
+        {'event_type': None, 'correlation_id': '550e8400-...', ...}
+
+    Warning:
+        This snapshot is **non-authoritative**. It exists solely for
+        debugging and observability. Do not use it for business logic.
+
+    .. versionadded:: 0.2.8
+    """
+
+    model_config = ConfigDict(
+        frozen=True,
+        extra="forbid",
+    )
+
+    event_type: str | None = Field(
+        default=None,
+        description="Event type identifier (e.g., 'UserCreated').",
+    )
+
+    correlation_id: str | None = Field(
+        default=None,
+        description="Correlation ID for distributed tracing (serialized UUID).",
+    )
+
+    trace_id: str | None = Field(
+        default=None,
+        description="Trace ID for span correlation (serialized UUID).",
+    )
+
+    causation_id: str | None = Field(
+        default=None,
+        description="Causation ID linking to parent event (serialized UUID).",
+    )
+
+    topic: str | None = Field(
+        default=None,
+        description="Event topic this message was received on.",
+    )
+
+    timestamp: str | None = Field(
+        default=None,
+        description="Event creation timestamp (ISO 8601 format).",
+    )
+
+    partition_key: str | None = Field(
+        default=None,
+        description="Partition key for Kafka routing.",
+    )

omnibase_infra/models/dispatch/model_materialized_dispatch.py

@@ -0,0 +1,141 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Materialized dispatch message model.
+
+This module defines the canonical runtime contract for dispatched messages.
+All handlers receive a materialized dict that conforms to this shape.
+
+Design Rationale:
+    The dispatch boundary is a **serialization boundary**. This model enforces
+    that all data crossing the dispatch layer is transport-safe:
+    - JSON-serializable (can be logged, replayed, transported to Kafka)
+    - Deterministic (same input produces same serialized output)
+    - Inspectable (can be examined offline without Python runtime)
+
+    Handlers that need rich Pydantic models should hydrate them locally:
+        ``ModelFoo.model_validate(dispatch["payload"])``
+
+    This separation keeps the runtime decoupled from handler internals and
+    enables distributed dispatch, event replay, and observability tooling.
+
+.. versionadded:: 0.2.6
+    Added as part of OMN-1518 - Declarative operation bindings.
+
+.. versionchanged:: 0.2.8
+    Changed to strict JSON-safe contract:
+    - Removed arbitrary_types_allowed
+    - Changed payload/bindings to JsonType
+    - Renamed __debug_original_envelope to __debug_trace (serialized snapshot)
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from omnibase_core.types import JsonType
+
+
+class ModelMaterializedDispatch(BaseModel):
+    """Canonical dispatch message shape (strictly JSON-safe).
+
+    This is the runtime contract for all handlers. After materialization,
+    every handler receives a dict that conforms to this structure:
+
+    - ``payload``: The event payload as a JSON-safe dict (required)
+    - ``__bindings``: Resolved binding parameters (always present, may be empty)
+    - ``__debug_trace``: Serialized trace metadata snapshot (debug only)
+
+    The double-underscore prefix on ``__bindings`` and ``__debug_trace``
+    signals that these are infrastructure-level fields, not business data.
+
+    Transport Safety:
+        All fields are JSON-serializable. This enables:
+        - Event replay from logs or Kafka
+        - Distributed dispatch across processes
+        - Observability tooling (logging, tracing, dashboards)
+        - Offline inspection and debugging
+
+    Handler Hydration:
+        Handlers that need typed Pydantic models should hydrate locally:
+
+        >>> payload = dispatch["payload"]
+        >>> event = UserCreatedEvent.model_validate(payload)
+
+        This keeps the dispatch boundary clean and transport-safe.
+
+    Warning:
+        ``__debug_trace`` is provided ONLY for debugging and observability.
+        It is a serialized snapshot of trace metadata, NOT the live envelope.
+
+        **DO NOT**:
+        - Use ``__debug_trace`` for business logic
+        - Assume ``__debug_trace`` reflects complete envelope state
+        - Depend on specific fields being present
+
+    Example:
+        >>> materialized = {
+        ...     "payload": {"user_id": "123", "action": "login"},
+        ...     "__bindings": {"user_id": "123", "timestamp": "2025-01-27T12:00:00Z"},
+        ...     "__debug_trace": {
+        ...         "correlation_id": "550e8400-e29b-41d4-a716-446655440000",
+        ...         "topic": "dev.user.events.v1",
+        ...     },
+        ... }
+        >>> validated = ModelMaterializedDispatch.model_validate(materialized)
+        >>> validated.payload
+        {'user_id': '123', 'action': 'login'}
+
+    Attributes:
+        payload: The event payload as a JSON-safe dict. Handlers that need
+            typed models should call ``model_validate()`` on this dict.
+            Primitives are wrapped under ``{"_raw": value}`` to maintain
+            dict structure (this is a last-resort escape hatch).
+        bindings: Resolved binding parameters from contract.yaml operation_bindings.
+            Always present (empty dict if no bindings configured). All values
+            are JSON-safe (UUIDs and datetimes are serialized to strings).
+        debug_trace: Serialized trace metadata snapshot for debugging.
+            Contains correlation_id, trace_id, topic, etc. as strings.
+            This is NOT authoritative data and should NOT be used for
+            business logic. Excluded from repr() to prevent log bloat.
+
+    .. versionadded:: 0.2.6
+
+    .. versionchanged:: 0.2.8
+        Changed to strict JSON-safe contract. See module docstring.
+    """
+
+    model_config = ConfigDict(
+        frozen=True,
+        populate_by_name=True,
+        extra="forbid",
+        # NOTE: arbitrary_types_allowed is intentionally NOT set (defaults to False).
+        # This enforces that all data crossing the dispatch boundary is JSON-safe.
+        # See module docstring for design rationale.
+    )
+
+    payload: JsonType = Field(
+        ...,
+        description=(
+            "Event payload as JSON-safe dict. "
+            "Handlers should hydrate typed models via model_validate()."
+        ),
+    )
+
+    bindings: dict[str, JsonType] = Field(
+        default_factory=dict,
+        alias="__bindings",
+        description=(
+            "Resolved binding parameters. Always present, may be empty dict. "
+            "Values are JSON-safe (UUIDs/datetimes serialized to strings)."
+        ),
+    )
+
+    debug_trace: dict[str, str | None] | None = Field(
+        default=None,
+        alias="__debug_trace",
+        description=(
+            "Serialized trace metadata snapshot for debugging only. "
+            "NOT authoritative. Do NOT use for business logic."
+        ),
+        repr=False,  # Prevent log bloat when stringifying model
+    )

omnibase_infra/models/handlers/model_handler_source_config.py

@@ -26,7 +26,7 @@ See Also:
 
 from __future__ import annotations
 
-from datetime import UTC, datetime, timezone
+from datetime import UTC, datetime
 
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 

omnibase_infra/models/model_node_identity.py

@@ -0,0 +1,126 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Node Identity Model for ONEX Infrastructure.
+
+This module provides a typed Pydantic model for uniquely identifying ONEX nodes
+within the infrastructure. The identity encapsulates the environment, service,
+node name, and version - the four dimensions required to uniquely identify
+a node instance.
+
+The model is immutable (frozen) to ensure identity stability throughout a node's
+lifecycle. Once created, a node identity cannot be modified.
+
+.. versionadded:: 0.2.6
+    Created as part of OMN-1602 typed node identity for introspection.
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field, ValidationInfo, field_validator
+
+
+class ModelNodeIdentity(BaseModel):
+    """Typed identity for ONEX infrastructure nodes.
+
+    This model uniquely identifies a node within the ONEX infrastructure using
+    four dimensions: environment, service, node name, and version. The same
+    node identity can be used with different purposes (e.g., introspection,
+    registration, heartbeat) - purpose is passed separately to operations.
+
+    All fields are required and must be non-empty strings without whitespace-only
+    values. The model is frozen to ensure identity immutability.
+
+    Attributes:
+        env: Environment identifier (e.g., "dev", "staging", "prod").
+            Determines which infrastructure deployment the node belongs to.
+        service: Service name from the node's contract (e.g., "omniintelligence",
+            "omnibridge"). Groups related nodes under a common service boundary.
+        node_name: Node name from the contract (e.g., "claude_hook_event_effect",
+            "registration_orchestrator"). Uniquely identifies the node within
+            its service.
+        version: Version string for the node (e.g., "v1", "v2.0.0").
+            Enables version-aware routing and registration. While any non-empty
+            string is accepted, semver-style prefixed with 'v' is recommended
+            for consistency (e.g., 'v1', 'v1.0.0', 'v2.1.3').
+
+    Example:
+        >>> identity = ModelNodeIdentity(
+        ...     env="dev",
+        ...     service="omniintelligence",
+        ...     node_name="claude_hook_event_effect",
+        ...     version="v1",
+        ... )
+        >>> identity.env
+        'dev'
+        >>> identity.service
+        'omniintelligence'
+
+        The model is immutable - attempting to modify raises an error:
+
+        >>> identity.env = "prod"  # doctest: +SKIP
+        Traceback (most recent call last):
+            ...
+        pydantic_core._pydantic_core.ValidationError: ...
+
+        Empty or whitespace-only values are rejected:
+
+        >>> ModelNodeIdentity(env="", service="svc", node_name="node", version="v1")
+        Traceback (most recent call last):
+            ...
+        pydantic_core._pydantic_core.ValidationError: ...
+
+    Note:
+        The `purpose` field is intentionally NOT included in this model.
+        Purpose (e.g., "introspection", "registration") is passed separately
+        to operations because the same node identity can be used for multiple
+        purposes.
+
+    .. versionadded:: 0.2.6
+        Created as part of OMN-1602.
+    """
+
+    model_config = ConfigDict(
+        frozen=True,
+        extra="forbid",
+        strict=True,
+    )
+
+    env: str = Field(
+        description="Environment identifier (e.g., 'dev', 'staging', 'prod')",
+    )
+    service: str = Field(
+        description="Service name from the node's contract (e.g., 'omniintelligence')",
+    )
+    node_name: str = Field(  # pattern-ok: canonical identifier, not a foreign key reference
+        description="Node name from the contract (e.g., 'claude_hook_event_effect')",
+    )
+    version: str = Field(
+        description="Version string for the node (e.g., 'v1', 'v2.0.0')",
+    )
+
+    @field_validator("env", "service", "node_name", "version", mode="after")
+    @classmethod
+    def _validate_non_empty(cls, v: str, info: ValidationInfo) -> str:
+        """Validate that string fields are non-empty and not whitespace-only.
+
+        Args:
+            v: The string value to validate.
+            info: Pydantic validation context containing field name.
+
+        Returns:
+            The validated string value.
+
+        Raises:
+            ValueError: If the value is empty or contains only whitespace.
+        """
+        field_name = info.field_name
+        if not v:
+            msg = f"'{field_name}' must not be empty"
+            raise ValueError(msg)
+        if not v.strip():
+            msg = f"'{field_name}' must not contain only whitespace"
+            raise ValueError(msg)
+        return v
+
+
+__all__: list[str] = ["ModelNodeIdentity"]

omnibase_infra/models/projection/model_snapshot_topic_config.py

@@ -58,6 +58,7 @@ import yaml
 from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 
 from omnibase_infra.enums import EnumInfraTransportType
+from omnibase_infra.topics import SUFFIX_REGISTRATION_SNAPSHOTS
 
 if TYPE_CHECKING:
     from omnibase_infra.errors.error_infra import ProtocolConfigurationError
@@ -154,7 +155,7 @@ class ModelSnapshotTopicConfig(BaseModel):
 
     # Topic identity
     topic: str = Field(
-        default="onex.registration.snapshots",
+        default=SUFFIX_REGISTRATION_SNAPSHOTS,
         min_length=1,
         max_length=255,
         description="Full Kafka topic name for registration snapshots",
@@ -442,7 +443,7 @@ class ModelSnapshotTopicConfig(BaseModel):
             Default configuration instance with environment overrides
         """
         base_config = cls(
-            topic="onex.registration.snapshots",
+            topic=SUFFIX_REGISTRATION_SNAPSHOTS,
             partition_count=12,
             replication_factor=3,
             cleanup_policy="compact",

omnibase_infra/models/registration/__init__.py

@@ -18,12 +18,18 @@ from omnibase_infra.models.registration.events import (
     ModelNodeRegistrationInitiated,
     ModelNodeRegistrationRejected,
 )
+from omnibase_infra.models.registration.model_event_bus_topic_entry import (
+    ModelEventBusTopicEntry,
+)
 from omnibase_infra.models.registration.model_introspection_metrics import (
     ModelIntrospectionMetrics,
 )
 from omnibase_infra.models.registration.model_node_capabilities import (
     ModelNodeCapabilities,
 )
+from omnibase_infra.models.registration.model_node_event_bus_config import (
+    ModelNodeEventBusConfig,
+)
 from omnibase_infra.models.registration.model_node_heartbeat_event import (
     ModelNodeHeartbeatEvent,
 )
@@ -39,6 +45,9 @@ from omnibase_infra.models.registration.model_node_registration_record import (
 )
 
 __all__ = [
+    # Event bus configuration
+    "ModelEventBusTopicEntry",
+    "ModelNodeEventBusConfig",
     # Metrics
     "ModelIntrospectionMetrics",
     # Decision events (C1 Orchestrator output)

omnibase_infra/models/registration/model_event_bus_topic_entry.py

@@ -0,0 +1,59 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Event Bus Topic Entry Model.
+
+This module provides the model for a single topic entry in the event bus
+configuration, containing the environment-qualified topic string and
+optional tooling metadata.
+
+Key Design Decisions:
+    1. Topics stored as environment-qualified strings (e.g., "dev.onex.evt.intent-classified.v1")
+    2. Metadata fields (event_type, message_category, description) are tooling-only
+    3. Routing uses ONLY the topic string - never metadata fields
+    4. Model is frozen (immutable) with extra="forbid" for safety
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ModelEventBusTopicEntry(BaseModel):
+    """Single topic entry with optional metadata.
+
+    IMPORTANT: Routing depends ONLY on the `topic` string.
+    Metadata fields (event_type, message_category, description) are
+    tooling-facing only and are never used for routing decisions.
+
+    Attributes:
+        topic: Environment-qualified topic string (e.g., "dev.onex.evt...").
+            This is the ONLY field used for routing.
+        event_type: Optional event model name. Tooling metadata only.
+        message_category: Message category (EVENT, COMMAND, INTENT).
+            Tooling metadata only. Defaults to "EVENT".
+        description: Optional human-readable description. Tooling metadata only.
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    topic: str = Field(
+        ...,
+        description="Environment-qualified topic string (e.g., 'dev.onex.evt.intent-classified.v1'). "
+        "This is the ONLY field used for routing.",
+    )
+    event_type: str | None = Field(
+        default=None,
+        description="Optional event model name. Tooling metadata only - never used for routing.",
+    )
+    message_category: str = Field(
+        default="EVENT",
+        description="Message category (EVENT, COMMAND, INTENT). "
+        "Tooling metadata only - never used for routing.",
+    )
+    description: str | None = Field(
+        default=None,
+        description="Optional human-readable description. Tooling metadata only.",
+    )
+
+
+__all__ = ["ModelEventBusTopicEntry"]

omnibase_infra/models/registration/model_node_event_bus_config.py

@@ -0,0 +1,99 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Node Event Bus Configuration Model.
+
+This module provides the model for a node's resolved event bus configuration,
+containing lists of topics the node subscribes to and publishes to.
+
+Key Design Decisions:
+    1. Topics stored as environment-qualified strings (e.g., "dev.onex.evt.intent-classified.v1")
+    2. Metadata fields are tooling-only; routing uses ONLY topic strings
+    3. Property methods extract topic strings only for routing lookups
+    4. Model is frozen (immutable) with extra="forbid" for safety
+
+Example:
+    >>> from omnibase_infra.models.registration import (
+    ...     ModelEventBusTopicEntry,
+    ...     ModelNodeEventBusConfig,
+    ... )
+    >>> entry = ModelEventBusTopicEntry(
+    ...     topic="dev.onex.evt.intent-classified.v1",
+    ...     event_type="ModelIntentClassified",
+    ... )
+    >>> config = ModelNodeEventBusConfig(subscribe_topics=[entry])
+    >>> config.subscribe_topic_strings
+    ['dev.onex.evt.intent-classified.v1']
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from omnibase_infra.models.registration.model_event_bus_topic_entry import (
+    ModelEventBusTopicEntry,
+)
+
+
+class ModelNodeEventBusConfig(BaseModel):
+    """Resolved event bus configuration for registry storage.
+
+    This model holds the resolved, environment-qualified topic strings
+    that a node subscribes to and publishes to. It is designed for
+    storage in the registry to enable dynamic topic-based routing.
+
+    The property methods (subscribe_topic_strings, publish_topic_strings)
+    extract only the topic strings for routing lookups, ignoring all
+    metadata fields.
+
+    Attributes:
+        subscribe_topics: List of topics the node subscribes to.
+        publish_topics: List of topics the node publishes to.
+
+    Example:
+        >>> config = ModelNodeEventBusConfig(
+        ...     subscribe_topics=[
+        ...         ModelEventBusTopicEntry(topic="dev.onex.evt.input.v1"),
+        ...     ],
+        ...     publish_topics=[
+        ...         ModelEventBusTopicEntry(topic="dev.onex.evt.output.v1"),
+        ...     ],
+        ... )
+        >>> config.subscribe_topic_strings
+        ['dev.onex.evt.input.v1']
+        >>> config.publish_topic_strings
+        ['dev.onex.evt.output.v1']
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    subscribe_topics: list[ModelEventBusTopicEntry] = Field(
+        default_factory=list,
+        description="List of topics the node subscribes to.",
+    )
+    publish_topics: list[ModelEventBusTopicEntry] = Field(
+        default_factory=list,
+        description="List of topics the node publishes to.",
+    )
+
+    @property
+    def subscribe_topic_strings(self) -> list[str]:
+        """Extract topic strings only, for routing lookups.
+
+        Returns:
+            List of environment-qualified topic strings from subscribe_topics.
+            Metadata fields are ignored.
+        """
+        return [entry.topic for entry in self.subscribe_topics]
+
+    @property
+    def publish_topic_strings(self) -> list[str]:
+        """Extract topic strings only, for routing lookups.
+
+        Returns:
+            List of environment-qualified topic strings from publish_topics.
+            Metadata fields are ignored.
+        """
+        return [entry.topic for entry in self.publish_topics]
+
+
+__all__ = ["ModelNodeEventBusConfig"]

omnibase_infra/models/registration/model_node_introspection_event.py

@@ -26,6 +26,9 @@ from omnibase_infra.models.discovery.model_introspection_performance_metrics imp
 from omnibase_infra.models.registration.model_node_capabilities import (
     ModelNodeCapabilities,
 )
+from omnibase_infra.models.registration.model_node_event_bus_config import (
+    ModelNodeEventBusConfig,
+)
 from omnibase_infra.models.registration.model_node_metadata import ModelNodeMetadata
 from omnibase_infra.utils import (
     validate_endpoint_urls_dict,
@@ -63,6 +66,8 @@ class ModelNodeIntrospectionEvent(BaseModel):
         deployment_id: Deployment/release identifier.
         epoch: Registration epoch for ordering.
         performance_metrics: Optional metrics from introspection operation.
+        event_bus: Resolved event bus topic configuration for registry-driven routing.
+            If None, node is NOT included in dynamic topic routing lookups.
 
     Example:
         >>> from uuid import uuid4
@@ -179,6 +184,12 @@ class ModelNodeIntrospectionEvent(BaseModel):
         default=None,
         description="Performance metrics from introspection operation",
     )
+    event_bus: ModelNodeEventBusConfig | None = Field(
+        default=None,
+        description="Resolved event bus topic configuration. "
+        "Contains environment-qualified topic strings for registry-driven routing. "
+        "If None, node is NOT included in dynamic topic routing lookups.",
+    )
 
 
 __all__ = ["ModelNodeIntrospectionEvent"]

omnibase_infra/models/runtime/__init__.py

@@ -27,7 +27,15 @@ from omnibase_infra.models.runtime.model_plugin_load_summary import (
     ModelPluginLoadSummary,
 )
 
+# ModelContractLoadResult and ModelRuntimeContractConfig are exported from
+# omnibase_infra.runtime.models (canonical location for runtime loader models)
+from omnibase_infra.runtime.models import (
+    ModelContractLoadResult,
+    ModelRuntimeContractConfig,
+)
+
 __all__ = [
+    "ModelContractLoadResult",
     "ModelContractSecurityConfig",
     "ModelDiscoveryError",
     "ModelDiscoveryResult",
@@ -37,4 +45,5 @@ __all__ = [
     "ModelLoadedHandler",
     "ModelPluginLoadContext",
     "ModelPluginLoadSummary",
+    "ModelRuntimeContractConfig",
 ]

omnibase_infra/models/validation/model_coverage_metrics.py

@@ -13,7 +13,7 @@ and IDE support.
 
 from __future__ import annotations
 
-from collections.abc import Mapping
+from collections.abc import Collection, Mapping
 from uuid import uuid4
 
 from pydantic import BaseModel, ConfigDict, Field
@@ -90,7 +90,7 @@ class ModelCoverageMetrics(BaseModel):
         cls,
         total: int,
         registered: int,
-        unmapped: list[str] | set[str],
+        unmapped: Collection[str],
     ) -> ModelCoverageMetrics:
         """Create coverage metrics from raw counts.