omnibase_infra 0.3.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

omnibase_infra/runtime/event_bus_subcontract_wiring.py

@@ -9,7 +9,7 @@ all Kafka plumbing - nodes/handlers never create consumers or producers directly
 Architecture:
     The EventBusSubcontractWiring class is responsible for:
     1. Reading `subscribe_topics` from ModelEventBusSubcontract
-    2. Resolving topic suffixes to full topic names with environment prefix
+    2. Passing topic suffixes through unchanged (topics are realm-agnostic)
     3. Creating Kafka subscriptions with appropriate consumer groups
     4. Bridging received messages to the MessageDispatchEngine
     5. Managing subscription lifecycle (creation and cleanup)
@@ -50,16 +50,21 @@ DLQ Consumer Group Alignment:
     3. Using it in all _publish_to_dlq calls within the callback closure
 
 Topic Resolution:
+    Topics are realm-agnostic and do NOT include environment prefixes.
+    The environment/realm is a routing boundary enforced via envelope identity,
+    not a topic prefix. This enables cross-environment event routing when needed.
+
     Topic suffixes from contracts follow the ONEX naming convention:
         onex.{kind}.{producer}.{event-name}.v{n}
 
-    The wiring resolves these to full topics by prepending the environment:
-        {environment}.onex.{kind}.{producer}.{event-name}.v{n}
+    The wiring passes these topic suffixes through unchanged:
+        onex.{kind}.{producer}.{event-name}.v{n}
 
     Example:
         - Contract declares: "onex.evt.omniintelligence.intent-classified.v1"
-        - Resolved (dev): "dev.onex.evt.omniintelligence.intent-classified.v1"
-        - Resolved (prod): "prod.onex.evt.omniintelligence.intent-classified.v1"
+        - Resolved: "onex.evt.omniintelligence.intent-classified.v1"
+
+    Note: Consumer groups still include environment for isolation.
 
 Related:
     - OMN-1621: Runtime consumes event_bus subcontract for contract-driven wiring
@@ -93,12 +98,13 @@ from omnibase_core.protocols.event_bus.protocol_event_bus_subscriber import (
 from omnibase_core.protocols.event_bus.protocol_event_message import (
     ProtocolEventMessage,
 )
-from omnibase_infra.enums import EnumInfraTransportType
+from omnibase_infra.enums import EnumConsumerGroupPurpose, EnumInfraTransportType
 from omnibase_infra.errors import (
     ModelInfraErrorContext,
     ProtocolConfigurationError,
     RuntimeHostError,
 )
+from omnibase_infra.models import ModelNodeIdentity
 from omnibase_infra.models.event_bus import (
     ModelConsumerRetryConfig,
     ModelDlqConfig,
@@ -106,6 +112,7 @@ from omnibase_infra.models.event_bus import (
     ModelOffsetPolicyConfig,
 )
 from omnibase_infra.protocols import ProtocolDispatchEngine, ProtocolIdempotencyStore
+from omnibase_infra.utils import compute_consumer_group_id
 
 if TYPE_CHECKING:
     from omnibase_infra.event_bus.event_bus_inmemory import EventBusInmemory
@@ -124,7 +131,7 @@ class EventBusSubcontractWiring:
 
     Responsibilities:
         - Parse subscribe_topics from ModelEventBusSubcontract
-        - Resolve topic suffixes to full topic names with environment prefix
+        - Pass topic suffixes through unchanged (topics are realm-agnostic)
         - Create Kafka subscriptions with appropriate consumer groups
         - Deserialize incoming messages to ModelEventEnvelope
         - Check idempotency and skip duplicate messages (if enabled)
@@ -194,7 +201,7 @@ class EventBusSubcontractWiring:
     Attributes:
         _event_bus: The event bus implementation (Kafka or in-memory)
         _dispatch_engine: Engine to dispatch received messages to handlers
-        _environment: Environment prefix for topics (e.g., 'dev', 'prod')
+        _environment: Environment identifier for consumer groups (e.g., 'dev', 'prod')
         _node_name: Name of the node/handler for consumer group and logging
         _idempotency_store: Optional store for tracking processed messages
         _idempotency_config: Configuration for idempotency behavior
@@ -217,6 +224,8 @@ class EventBusSubcontractWiring:
         dispatch_engine: ProtocolDispatchEngine,
         environment: str,
         node_name: str,
+        service: str,
+        version: str,
         idempotency_store: ProtocolIdempotencyStore | None = None,
         idempotency_config: ModelIdempotencyConfig | None = None,
         dlq_config: ModelDlqConfig | None = None,
@@ -227,14 +236,19 @@ class EventBusSubcontractWiring:
 
         Args:
             event_bus: The event bus implementation (EventBusKafka or EventBusInmemory).
-                Must implement subscribe(topic, group_id, on_message) -> unsubscribe callable.
+                Must implement subscribe(topic, node_identity, on_message) -> unsubscribe callable.
                 Duck typed per ONEX patterns.
             dispatch_engine: Engine to dispatch received messages to handlers.
                 Must implement ProtocolDispatchEngine interface.
                 Must be frozen (registrations complete) before wiring subscriptions.
-            environment: Environment prefix for topics (e.g., 'dev', 'prod').
-                Used to resolve topic suffixes to full topic names.
+            environment: Environment identifier (e.g., 'dev', 'prod').
+                Used for consumer group naming and node identity. Topics are
+                realm-agnostic and do not include environment prefixes.
             node_name: Name of the node/handler for consumer group identification and logging.
+            service: Service name for node identity (e.g., 'omniintelligence', 'omnibridge').
+                Used to derive consumer group ID.
+            version: Version string for node identity (e.g., 'v1', 'v1.0.0').
+                Used to derive consumer group ID.
             idempotency_store: Optional idempotency store for message deduplication.
                 If provided with enabled config, messages are deduplicated by envelope_id.
             idempotency_config: Optional configuration for idempotency behavior.
@@ -254,15 +268,21 @@ class EventBusSubcontractWiring:
             Attempting to dispatch to an unfrozen engine will raise an error.
 
         Raises:
-            ValueError: If environment is empty or whitespace-only.
+            ValueError: If environment, service, or version is empty or whitespace-only.
         """
         if not environment or not environment.strip():
             raise ValueError("environment must be a non-empty string")
+        if not service or not service.strip():
+            raise ValueError("service must be a non-empty string")
+        if not version or not version.strip():
+            raise ValueError("version must be a non-empty string")
 
         self._event_bus = event_bus
         self._dispatch_engine = dispatch_engine
         self._environment = environment
         self._node_name = node_name
+        self._service = service
+        self._version = version
         self._idempotency_store = idempotency_store
         self._idempotency_config = idempotency_config or ModelIdempotencyConfig()
         self._dlq_config = dlq_config or ModelDlqConfig()
@@ -274,28 +294,36 @@ class EventBusSubcontractWiring:
         self._retry_counts: dict[UUID, int] = {}
 
     def resolve_topic(self, topic_suffix: str) -> str:
-        """Resolve topic suffix to full topic name with environment prefix.
+        """Resolve topic suffix to topic name (realm-agnostic, no environment prefix).
+
+        Topics are realm-agnostic in ONEX. The environment/realm is enforced via
+        envelope identity, not topic naming. This enables cross-environment event
+        routing when needed while maintaining proper isolation through identity.
 
         Topic suffixes from contracts follow the ONEX naming convention:
             onex.{kind}.{producer}.{event-name}.v{n}
 
-        This method prepends the environment to create the full topic name:
-            {environment}.onex.{kind}.{producer}.{event-name}.v{n}
+        This method returns the topic suffix unchanged:
+            onex.{kind}.{producer}.{event-name}.v{n}
 
         Args:
             topic_suffix: ONEX format topic suffix
                 (e.g., 'onex.evt.omniintelligence.intent-classified.v1')
 
         Returns:
-            Full topic name with environment prefix
-                (e.g., 'dev.onex.evt.omniintelligence.intent-classified.v1')
+            Topic name (same as suffix, no environment prefix)
+                (e.g., 'onex.evt.omniintelligence.intent-classified.v1')
 
         Example:
             >>> wiring = EventBusSubcontractWiring(bus, engine, "dev")
             >>> wiring.resolve_topic("onex.evt.user.created.v1")
-            'dev.onex.evt.user.created.v1'
+            'onex.evt.user.created.v1'
+
+        Note:
+            Consumer groups still include environment for proper isolation.
+            See wire_subscriptions() for consumer group naming.
         """
-        return f"{self._environment}.{topic_suffix}"
+        return topic_suffix
 
     async def wire_subscriptions(
         self,
@@ -348,9 +376,21 @@ class EventBusSubcontractWiring:
 
         for topic_suffix in subcontract.subscribe_topics:
             full_topic = self.resolve_topic(topic_suffix)
-            # Consumer group ID derived from environment and node_name
-            # This same group_id is passed to DLQ publishing for traceability
-            consumer_group = f"{self._environment}.{node_name}"
+
+            # Create typed node identity for consumer group derivation
+            # The event bus derives consumer group as: {env}.{service}.{node_name}.{purpose}.{version}
+            node_identity = ModelNodeIdentity(
+                env=self._environment,
+                service=self._service,
+                node_name=node_name,
+                version=self._version,
+            )
+
+            # Consumer group for logging and DLQ traceability
+            # Use shared helper for consistent derivation across codebase
+            consumer_group = compute_consumer_group_id(
+                node_identity, EnumConsumerGroupPurpose.CONSUME
+            )
 
             # Create dispatch callback for this topic, capturing the consumer_group
             # used for this subscription to ensure DLQ messages have consistent
@@ -360,7 +400,7 @@ class EventBusSubcontractWiring:
             # Subscribe and store unsubscribe callable
             unsubscribe = await self._event_bus.subscribe(
                 topic=full_topic,
-                group_id=consumer_group,
+                node_identity=node_identity,
                 on_message=callback,
             )
             self._unsubscribe_callables.append(unsubscribe)

omnibase_infra/runtime/publisher_topic_scoped.py

@@ -9,7 +9,7 @@ event emission and maintaining clean architectural boundaries.
 
 Design Principles:
     - **Contract-Driven Access Control**: Topics must be declared in contract
-    - **Environment-Aware Routing**: Topic suffixes are prefixed with environment
+    - **Realm-Agnostic Topics**: Topics passed through unchanged (no env prefix)
     - **Fail-Fast Validation**: Invalid topics raise immediately, not at delivery
     - **Duck-Typed Protocol**: Implements publisher protocol without explicit inheritance
 
@@ -95,7 +95,7 @@ class PublisherTopicScoped:
 
     Features:
         - Contract-driven topic access control
-        - Environment-aware topic resolution
+        - Realm-agnostic topics (no environment prefix)
         - Fail-fast validation on disallowed topics
         - JSON serialization for payloads
         - Correlation ID propagation for distributed tracing
@@ -103,7 +103,7 @@ class PublisherTopicScoped:
     Attributes:
         _event_bus: The underlying event bus for publishing
         _allowed_topics: Set of topic suffixes allowed by contract
-        _environment: Environment prefix for topic resolution
+        _environment: Environment identifier (retained for future use)
 
     Example:
         >>> publisher = PublisherTopicScoped(
@@ -132,8 +132,8 @@ class PublisherTopicScoped:
                 Must implement publish(topic, key, value) method. Duck typed per ONEX.
             allowed_topics: Set of topic suffixes from contract's publish_topics.
                 These are the ONLY topics this publisher can publish to.
-            environment: Environment prefix (e.g., 'dev', 'staging', 'prod').
-                Used to construct full topic names.
+            environment: Environment identifier (e.g., 'dev', 'staging', 'prod').
+                Retained for future use; topics are realm-agnostic (no prefix).
 
         Example:
             >>> publisher = PublisherTopicScoped(
@@ -174,22 +174,27 @@ class PublisherTopicScoped:
         return str(correlation_id).encode("utf-8")
 
     def resolve_topic(self, topic_suffix: str) -> str:
-        """Resolve topic suffix to full topic name with environment prefix.
+        """Resolve topic suffix to topic name (realm-agnostic, no environment prefix).
 
-        The full topic name follows the ONEX convention:
-        `{environment}.{topic_suffix}`
+        Topics are realm-agnostic in ONEX. The environment/realm is enforced via
+        envelope identity, not topic naming. This enables cross-environment event
+        routing when needed while maintaining proper isolation through identity.
 
         Args:
             topic_suffix: ONEX format topic suffix (e.g., 'onex.events.v1')
 
         Returns:
-            Full topic name with environment prefix (e.g., 'dev.onex.events.v1')
+            Topic name (same as suffix, no environment prefix)
 
         Example:
             >>> publisher.resolve_topic("onex.events.v1")
-            'dev.onex.events.v1'
+            'onex.events.v1'
+
+        Note:
+            The environment is still stored for potential consumer group derivation
+            in related components. Topics themselves are realm-agnostic.
         """
-        return f"{self._environment}.{topic_suffix}"
+        return topic_suffix
 
     async def publish(
         self,

omnibase_infra/runtime/registry_policy.py

@@ -86,7 +86,6 @@ from typing import TYPE_CHECKING
 
 from pydantic import ValidationError
 
-from omnibase_core.models.primitives import ModelSemVer
 from omnibase_infra.enums import EnumInfraTransportType, EnumPolicyType
 from omnibase_infra.errors import PolicyRegistryError, ProtocolConfigurationError
 from omnibase_infra.models.errors.model_infra_error_context import (
@@ -97,6 +96,7 @@ from omnibase_infra.runtime.mixin_semver_cache import MixinSemverCache
 from omnibase_infra.runtime.models import ModelPolicyKey, ModelPolicyRegistration
 from omnibase_infra.runtime.util_version import normalize_version
 from omnibase_infra.types import PolicyTypeInput
+from omnibase_infra.utils import validate_policy_type_value
 
 if TYPE_CHECKING:
     from omnibase_infra.runtime.protocol_policy import ProtocolPolicy
@@ -463,11 +463,13 @@ class RegistryPolicy(MixinPolicyValidation, MixinSemverCache):
         and string literals, normalizing them to their string representation while
         ensuring they match valid EnumPolicyType values.
 
+        Delegates validation to the shared ``validate_policy_type_value()`` utility,
+        which is the SINGLE SOURCE OF TRUTH for policy type validation in omnibase_infra.
+
         Validation Process:
-            1. If policy_type is EnumPolicyType instance, extract .value
-            2. If policy_type is string, validate against EnumPolicyType values
-            3. Raise PolicyRegistryError if string doesn't match any enum value
-            4. Return normalized string value
+            1. Delegate to validate_policy_type_value() for validation and coercion
+            2. Extract .value from the validated EnumPolicyType
+            3. Return normalized string value
 
         This centralized validation ensures consistent policy type handling across
         all registry operations (register, get, list_keys, is_registered, unregister).
@@ -498,12 +500,14 @@ class RegistryPolicy(MixinPolicyValidation, MixinSemverCache):
             PolicyRegistryError: Invalid policy_type: 'invalid'.
                                  Must be one of: ['orchestrator', 'reducer']
         """
-        if isinstance(policy_type, EnumPolicyType):
-            return policy_type.value
-
-        # Validate string against enum values
-        valid_types = {e.value for e in EnumPolicyType}
-        if policy_type not in valid_types:
+        try:
+            # Use shared validation utility (SINGLE SOURCE OF TRUTH)
+            validated_enum = validate_policy_type_value(policy_type)
+            return validated_enum.value
+        except ValueError as exc:
+            # Convert ValueError from shared utility to PolicyRegistryError
+            # for consistent error handling in the registry
+            valid_types = {pt.value for pt in EnumPolicyType}
             context = ModelInfraErrorContext.with_correlation(
                 transport_type=EnumInfraTransportType.RUNTIME,
                 operation="normalize_policy_type",
@@ -512,11 +516,9 @@ class RegistryPolicy(MixinPolicyValidation, MixinSemverCache):
                 f"Invalid policy_type: {policy_type!r}. "
                 f"Must be one of: {sorted(valid_types)}",
                 policy_id=None,
-                policy_type=policy_type,
+                policy_type=str(policy_type),
                 context=context,
-            )
-
-        return policy_type
+            ) from exc
 
     @staticmethod
     def _normalize_version(version: str) -> str:
@@ -656,6 +658,10 @@ class RegistryPolicy(MixinPolicyValidation, MixinSemverCache):
         Partial version strings (e.g., "1", "1.0") are auto-normalized to
         "x.y.z" format by ModelPolicyRegistration.
 
+        .. deprecated::
+            This method is deprecated. Use ``register(ModelPolicyRegistration(...))``
+            directly for new code. This method will be removed in a future version.
+
         Note:
             For new code, prefer using register(ModelPolicyRegistration(...))
             directly. This is a convenience method for simple registrations.
@@ -684,6 +690,14 @@ class RegistryPolicy(MixinPolicyValidation, MixinSemverCache):
             ...     version="1.0.0",
             ... )
         """
+        # Emit deprecation warning at runtime
+        warnings.warn(
+            "register_policy() is deprecated. Use register(ModelPolicyRegistration(...)) "
+            "instead. This method will be removed in a future version.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
         # Version normalization is handled by ModelPolicyRegistration validator
         # which normalizes partial versions and v-prefixed versions automatically
         try:

omnibase_infra/runtime/request_response_wiring.py

@@ -191,7 +191,7 @@ class RequestResponseWiring(MixinAsyncCircuitBreaker):
 
     Attributes:
         _event_bus: Event bus for publishing requests
-        _environment: Environment prefix for topics (e.g., 'dev', 'prod')
+        _environment: Environment identifier for consumer groups (e.g., 'dev', 'prod')
         _app_name: Application name for consumer group identification
         _instances: Dict mapping instance names to their state
         _bootstrap_servers: Kafka bootstrap servers from event bus
@@ -211,8 +211,9 @@ class RequestResponseWiring(MixinAsyncCircuitBreaker):
         Args:
             event_bus: Event bus for publishing requests. Must implement
                 ProtocolEventBusPublisher interface.
-            environment: Environment prefix for topics (e.g., 'dev', 'prod').
-                Used to resolve topic suffixes to full topic names.
+            environment: Environment identifier (e.g., 'dev', 'prod').
+                Used for consumer group naming. Topics are realm-agnostic and
+                do not include environment prefixes.
             app_name: Application name for logging and consumer group naming.
             bootstrap_servers: Kafka bootstrap servers. If not provided, attempts
                 to read from event_bus._bootstrap_servers or environment variable.
@@ -263,17 +264,24 @@ class RequestResponseWiring(MixinAsyncCircuitBreaker):
         )
 
     def resolve_topic(self, topic_suffix: str) -> str:
-        """Resolve topic suffix to full topic name with environment prefix.
+        """Resolve topic suffix to topic name (realm-agnostic, no environment prefix).
+
+        Topics are realm-agnostic in ONEX. The environment/realm is enforced via
+        envelope identity, not topic naming. This enables cross-environment event
+        routing when needed while maintaining proper isolation through identity.
 
         Args:
             topic_suffix: ONEX format topic suffix
                 (e.g., 'onex.cmd.intelligence.analyze-code.v1')
 
         Returns:
-            Full topic name with environment prefix
-                (e.g., 'dev.onex.cmd.intelligence.analyze-code.v1')
+            Topic name (same as suffix, no environment prefix)
+                (e.g., 'onex.cmd.intelligence.analyze-code.v1')
+
+        Note:
+            Consumer groups still include environment for proper isolation.
         """
-        return f"{self._environment}.{topic_suffix}"
+        return topic_suffix
 
     async def wire_request_response(
         self,

omnibase_infra/runtime/service_runtime_host_process.py

@@ -73,6 +73,12 @@ from omnibase_infra.errors import (
 from omnibase_infra.event_bus.event_bus_inmemory import EventBusInmemory
 from omnibase_infra.event_bus.event_bus_kafka import EventBusKafka
 from omnibase_infra.models import ModelNodeIdentity
+from omnibase_infra.models.runtime.model_resolved_dependencies import (
+    ModelResolvedDependencies,
+)
+from omnibase_infra.runtime.contract_dependency_resolver import (
+    ContractDependencyResolver,
+)
 from omnibase_infra.runtime.envelope_validator import (
     normalize_correlation_id,
     validate_envelope,
@@ -764,6 +770,10 @@ class RuntimeHostProcess:
         # Enables contract config to be passed to handlers via initialize()
         self._handler_descriptors: dict[str, ModelHandlerDescriptor] = {}
 
+        # Contract dependency resolver for protocol auto-injection (OMN-1903)
+        # Lazy-created when first needed during handler population
+        self._dependency_resolver: ContractDependencyResolver | None = None
+
         # Pending message tracking for graceful shutdown (OMN-756)
         # Tracks count of in-flight messages currently being processed
         self._pending_message_count: int = 0
@@ -1798,11 +1808,44 @@ class RuntimeHostProcess:
                     handler_type
                 )
 
-                # Instantiate the handler with container for dependency injection
+                # Get descriptor early for dependency resolution (OMN-1903)
+                descriptor = self._handler_descriptors.get(handler_type)
+
+                # R1/R3: Resolve dependencies if contract has them (OMN-1903)
+                # Returns None if descriptor has no contract_path or no dependencies
+                resolved_dependencies: ModelResolvedDependencies | None = None
+                if descriptor:
+                    # This may raise ProtocolDependencyResolutionError (R2: fail-fast)
+                    resolved_dependencies = await self._resolve_handler_dependencies(
+                        descriptor
+                    )
+
+                # Instantiate the handler with container (and dependencies if supported)
                 # ProtocolContainerAware defines __init__(container: ModelONEXContainer)
-                handler_instance: ProtocolContainerAware = handler_cls(
-                    container=container
-                )
+                # Handlers that support OMN-1732 can accept optional dependencies parameter
+                handler_instance: ProtocolContainerAware
+                if resolved_dependencies and self._accepts_dependencies_param(
+                    handler_cls
+                ):
+                    # New-style handler with dependency injection
+                    # Type ignore: handler_cls is typed as ProtocolContainerAware which doesn't
+                    # have dependencies param, but runtime introspection confirmed it exists
+                    handler_instance = handler_cls(  # type: ignore[call-arg]
+                        container=container,
+                        dependencies=resolved_dependencies,
+                    )
+                    logger.debug(
+                        "Instantiated handler with resolved dependencies",
+                        extra={
+                            "handler_type": handler_type,
+                            "resolved_protocols": list(
+                                resolved_dependencies.protocols.keys()
+                            ),
+                        },
+                    )
+                else:
+                    # Legacy handler without dependency parameter
+                    handler_instance = handler_cls(container=container)
 
                 # Call initialize() if the handler has this method
                 # Handlers may require async initialization with config
@@ -1814,7 +1857,6 @@ class RuntimeHostProcess:
                     config_source = "runtime_only"
 
                     # Layer 1: Contract config as baseline (if descriptor exists with config)
-                    descriptor = self._handler_descriptors.get(handler_type)
                     if descriptor and descriptor.contract_config:
                         effective_config.update(descriptor.contract_config)
                         config_source = "contract_only"
@@ -1890,6 +1932,106 @@ class RuntimeHostProcess:
             },
         )
 
+    async def _resolve_handler_dependencies(
+        self,
+        descriptor: ModelHandlerDescriptor,
+    ) -> ModelResolvedDependencies | None:
+        """Resolve protocol dependencies for a handler from its contract.
+
+        Part of OMN-1903: Runtime dependency injection integration.
+
+        If the handler's contract declares protocol dependencies, this method
+        resolves them from the container's service_registry. Returns None if:
+        - No contract_path in descriptor (opt-in behavior, R3)
+        - Contract has no dependencies section
+
+        Args:
+            descriptor: Handler descriptor containing contract_path.
+
+        Returns:
+            ModelResolvedDependencies with resolved protocols, or None if no
+            dependencies to resolve.
+
+        Raises:
+            ProtocolDependencyResolutionError: If any required protocol cannot
+                be resolved (fail-fast behavior, R2).
+            ProtocolConfigurationError: If contract file cannot be loaded.
+        """
+        # R3: Opt-in behavior - skip if no contract_path
+        if not descriptor.contract_path:
+            logger.debug(
+                "Handler has no contract_path, skipping dependency resolution",
+                extra={"handler_id": descriptor.handler_id},
+            )
+            return None
+
+        # Lazy-create resolver on first use
+        if self._dependency_resolver is None:
+            container = self._get_or_create_container()
+            self._dependency_resolver = ContractDependencyResolver(container)
+
+        # R1: Call resolver with contract path
+        contract_path = Path(descriptor.contract_path)
+        logger.debug(
+            "Resolving dependencies for handler",
+            extra={
+                "handler_id": descriptor.handler_id,
+                "contract_path": str(contract_path),
+            },
+        )
+
+        # R2: Fail-fast on missing protocols (allow_missing=False)
+        resolved = await self._dependency_resolver.resolve_from_path(
+            contract_path,
+            allow_missing=False,
+        )
+
+        if resolved:
+            logger.debug(
+                "Resolved dependencies for handler",
+                extra={
+                    "handler_id": descriptor.handler_id,
+                    "resolved_protocols": list(resolved.protocols.keys()),
+                },
+            )
+        else:
+            logger.debug(
+                "No protocol dependencies in contract",
+                extra={
+                    "handler_id": descriptor.handler_id,
+                    "contract_path": str(contract_path),
+                },
+            )
+
+        return resolved if resolved else None
+
+    def _accepts_dependencies_param(self, handler_cls: type) -> bool:
+        """Check if a handler class accepts 'dependencies' in its constructor.
+
+        Part of OMN-1903: Runtime dependency injection integration.
+
+        Uses introspection to check if the handler's __init__ accepts a
+        'dependencies' keyword argument. This enables gradual migration:
+        - Legacy handlers: __init__(container) - no dependencies param
+        - New handlers: __init__(container, dependencies=...) - receives deps
+
+        Args:
+            handler_cls: The handler class to check.
+
+        Returns:
+            True if the handler accepts 'dependencies' parameter, False otherwise.
+        """
+        import inspect
+
+        try:
+            # Use inspect.signature on the class itself, not __init__
+            # This avoids the "unsound instance access" mypy warning
+            sig = inspect.signature(handler_cls)
+            return "dependencies" in sig.parameters
+        except (ValueError, TypeError):
+            # Cannot inspect signature (e.g., builtin class)
+            return False
+
     async def _load_contract_configs(self, correlation_id: UUID) -> None:
         """Load contract configurations from all discovered contracts.
 
@@ -2919,6 +3061,8 @@ class RuntimeHostProcess:
             dispatch_engine=self._dispatch_engine,
             environment=environment,
             node_name="runtime-host",
+            service=self._node_identity.service,
+            version=self._node_identity.version,
         )
 
         # Wire subscriptions for each handler with a contract

omnibase_infra/runtime/util_version.py

@@ -14,6 +14,7 @@ ModelPolicyKey, and ModelPolicyRegistration.
 
 from __future__ import annotations
 
+from omnibase_core.models.errors import ModelOnexError
 from omnibase_core.models.primitives import ModelSemVer
 
 
@@ -81,9 +82,12 @@ def normalize_version(version: str) -> str:
     expanded_version = ".".join(version_nums)
 
     # Parse with ModelSemVer for validation
+    # Note: ModelSemVer.parse() raises ModelOnexError for invalid versions,
+    # but we also catch ValueError for defensive programming against
+    # potential upstream changes.
     try:
         semver = ModelSemVer.parse(expanded_version)
-    except Exception as e:
+    except (ModelOnexError, ValueError) as e:
         raise ValueError(f"Invalid version format: {e}") from e
 
     result: str = semver.to_string()