feat(OMN-1732): Runtime dependency injection for zero-code nodes

src/omnibase_infra/errors/__init__.py

@@ -10,6 +10,7 @@
     ModelInfraErrorContext: Configuration model for bundled error context
     RuntimeHostError: Base infrastructure error class
     ProtocolConfigurationError: Protocol configuration validation errors
+    ProtocolDependencyResolutionError: Protocol dependency resolution errors
     SecretResolutionError: Secret/credential resolution errors
     InfraConnectionError: Infrastructure connection errors
     InfraTimeoutError: Infrastructure timeout errors
@@ -115,6 +116,7 @@
     InfraTimeoutError,
     InfraUnavailableError,
     ProtocolConfigurationError,
+    ProtocolDependencyResolutionError,
     RuntimeHostError,
     SecretResolutionError,
     UnknownHandlerTypeError,
@@ -162,6 +164,8 @@
     "ModelTimeoutErrorContext",
     "PolicyRegistryError",
     "ProtocolConfigurationError",
+    # Protocol dependency resolution errors
+    "ProtocolDependencyResolutionError",
     # Repository errors
     "RepositoryContractError",
     "RepositoryError",

src/omnibase_infra/errors/error_infra.py

@@ -597,13 +597,73 @@ def __init__(
         )
 
 
+class ProtocolDependencyResolutionError(RuntimeHostError):
+    """Raised when protocol dependencies cannot be resolved from container.
+
+    Used when a node's contract.yaml declares protocol dependencies that
+    are not registered in the container's service_registry. This is a
+    fail-fast error that prevents node creation with missing dependencies.
+
+    Example:
+        >>> context = ModelInfraErrorContext(
+        ...     transport_type=EnumInfraTransportType.RUNTIME,
+        ...     operation="resolve_dependencies",
+        ...     target_name="NodeContractPersistenceEffect",
+        ... )
+        >>> raise ProtocolDependencyResolutionError(
+        ...     "Missing required protocols for node",
+        ...     context=context,
+        ...     missing_protocols=["ProtocolPostgresAdapter"],
+        ...     node_name="node_contract_persistence_effect",
+        ... )
+
+    .. versionadded:: 0.x.x
+        Part of OMN-1732 runtime dependency injection.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        context: ModelInfraErrorContext | None = None,
+        *,
+        missing_protocols: list[str] | None = None,
+        node_name: str | None = None,
+        contract_path: str | None = None,
+        **extra_context: object,
+    ) -> None:
+        """Initialize ProtocolDependencyResolutionError.
+
+        Args:
+            message: Human-readable error message
+            context: Bundled infrastructure context
+            missing_protocols: List of protocol class names that could not be resolved
+            node_name: Name of the node requiring the protocols
+            contract_path: Path to the contract.yaml file (for debugging)
+            **extra_context: Additional context information
+        """
+        if missing_protocols is not None:
+            extra_context["missing_protocols"] = missing_protocols
+        if node_name is not None:
+            extra_context["node_name"] = node_name
+        if contract_path is not None:
+            extra_context["contract_path"] = contract_path
+
+        super().__init__(
+            message=message,
+            error_code=EnumCoreErrorCode.DEPENDENCY_ERROR,
+            context=context,
+            **extra_context,
+        )
+
+
 __all__: list[str] = [
     "EnvelopeValidationError",
     "InfraAuthenticationError",
     "InfraConnectionError",
     "InfraTimeoutError",
     "InfraUnavailableError",
     "ProtocolConfigurationError",
+    "ProtocolDependencyResolutionError",
     "RuntimeHostError",
     "SecretResolutionError",
     "UnknownHandlerTypeError",

src/omnibase_infra/models/runtime/__init__.py

@@ -26,6 +26,9 @@
 from omnibase_infra.models.runtime.model_plugin_load_summary import (
     ModelPluginLoadSummary,
 )
+from omnibase_infra.models.runtime.model_resolved_dependencies import (
+    ModelResolvedDependencies,
+)
 
 # ModelContractLoadResult and ModelRuntimeContractConfig are exported from
 # omnibase_infra.runtime.models (canonical location for runtime loader models)
@@ -45,5 +48,6 @@
     "ModelLoadedHandler",
     "ModelPluginLoadContext",
     "ModelPluginLoadSummary",
+    "ModelResolvedDependencies",
     "ModelRuntimeContractConfig",
 ]

src/omnibase_infra/models/runtime/model_resolved_dependencies.py

@@ -0,0 +1,116 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Model for resolved protocol dependencies.
+
+This module provides ModelResolvedDependencies, a container for protocol
+instances resolved from the container service_registry at node creation time.
+
+Part of OMN-1732: Runtime dependency injection for zero-code nodes.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ModelResolvedDependencies(BaseModel):
+    """Container for resolved protocol dependencies.
+
+    Holds protocol instances resolved from ModelONEXContainer.service_registry
+    for injection into node constructors. This model is immutable after creation.
+
+    The protocols dict maps protocol class names to their resolved instances:
+    - Key: Protocol class name (e.g., "ProtocolPostgresAdapter")
+    - Value: Resolved instance from container
+
+    Example:
+        >>> resolved = ModelResolvedDependencies(
+        ...     protocols={
+        ...         "ProtocolPostgresAdapter": postgres_adapter,
+        ...         "ProtocolCircuitBreakerAware": circuit_breaker,
+        ...     }
+        ... )
+        >>> adapter = resolved.get("ProtocolPostgresAdapter")
+
+    .. versionadded:: 0.x.x
+        Part of OMN-1732 runtime dependency injection.
+    """
+
+    model_config = ConfigDict(
+        frozen=True,
+        extra="forbid",
+        arbitrary_types_allowed=True,  # Required for protocol instances
+    )
+
+    # ONEX_EXCLUDE: any_type - dict[str, Any] required for heterogeneous protocol instances
+    # resolved from container.service_registry. Type varies by protocol (ProtocolPostgresAdapter,
+    # ProtocolCircuitBreakerAware, etc.). Cannot use Union as protocols are open-ended.
+    protocols: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Map of protocol class names to resolved instances",
+    )
+
+    # ONEX_EXCLUDE: any_type - returns heterogeneous protocol instance from protocols dict
+    def get(self, protocol_name: str) -> Any:
+        """Get a resolved protocol by name.
+
+        Args:
+            protocol_name: The protocol class name (e.g., "ProtocolPostgresAdapter")
+
+        Returns:
+            The resolved protocol instance.
+
+        Raises:
+            KeyError: If protocol_name is not in the resolved protocols.
+
+        Example:
+            >>> adapter = resolved.get("ProtocolPostgresAdapter")
+        """
+        if protocol_name not in self.protocols:
+            raise KeyError(
+                f"Protocol '{protocol_name}' not found in resolved dependencies. "
+                f"Available: {list(self.protocols.keys())}"
+            )
+        return self.protocols[protocol_name]
+
+    # ONEX_EXCLUDE: any_type - returns heterogeneous protocol instance, default can be any type
+    def get_optional(self, protocol_name: str, default: Any = None) -> Any:
+        """Get a resolved protocol by name, returning default if not found.
+
+        Args:
+            protocol_name: The protocol class name
+            default: Value to return if protocol not found
+
+        Returns:
+            The resolved protocol instance or default.
+        """
+        return self.protocols.get(protocol_name, default)
+
+    def has(self, protocol_name: str) -> bool:
+        """Check if a protocol is available.
+
+        Args:
+            protocol_name: The protocol class name
+
+        Returns:
+            True if protocol is resolved, False otherwise.
+        """
+        return protocol_name in self.protocols
+
+    def __len__(self) -> int:
+        """Return number of resolved protocols."""
+        return len(self.protocols)
+
+    def __bool__(self) -> bool:
+        """Return True if any protocols are resolved.
+
+        Warning:
+            **Non-standard __bool__ behavior**: Returns True only when
+            at least one protocol is resolved.
+        """
+        return len(self.protocols) > 0
+
+
+__all__ = ["ModelResolvedDependencies"]

src/omnibase_infra/nodes/node_contract_persistence_effect/node.py

@@ -56,8 +56,14 @@
 
 if TYPE_CHECKING:
     from omnibase_core.models.container.model_onex_container import ModelONEXContainer
+    from omnibase_infra.models.runtime.model_resolved_dependencies import (
+        ModelResolvedDependencies,
+    )
 
 
+# ONEX_EXCLUDE: declarative_node - OMN-1732 DEC-003 requires constructor injection
+# for protocol dependencies. The _resolved_dependencies instance variable stores
+# pre-resolved protocols from ContractDependencyResolver.
 class NodeContractPersistenceEffect(NodeEffect):
     """Declarative effect node for contract registry persistence.
 
@@ -76,6 +82,9 @@ class NodeContractPersistenceEffect(NodeEffect):
 
     Args:
         container: ONEX dependency injection container.
+        dependencies: Optional pre-resolved protocol dependencies. If provided,
+            the node will use these instead of resolving from container.
+            Part of OMN-1732 runtime dependency injection.
 
     Dependency Injection:
         Backend adapters (PostgreSQL) are resolved via container.
@@ -102,13 +111,21 @@ class NodeContractPersistenceEffect(NodeEffect):
         ```
     """
 
-    def __init__(self, container: ModelONEXContainer) -> None:
+    def __init__(
+        self,
+        container: ModelONEXContainer,
+        dependencies: ModelResolvedDependencies | None = None,
+    ) -> None:
         """Initialize effect node with container dependency injection.
 
         Args:
             container: ONEX dependency injection container.
+            dependencies: Optional pre-resolved protocol dependencies from
+                ContractDependencyResolver. If provided, the node uses these
+                instead of resolving from container. Part of OMN-1732.
         """
         super().__init__(container)
+        self._resolved_dependencies = dependencies
 
 
 __all__ = ["NodeContractPersistenceEffect"]

src/omnibase_infra/nodes/node_contract_persistence_effect/registry/registry_infra_contract_persistence_effect.py

@@ -24,10 +24,14 @@
 
 from __future__ import annotations
 
+import warnings
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from omnibase_core.models.container.model_onex_container import ModelONEXContainer
+    from omnibase_infra.models.runtime.model_resolved_dependencies import (
+        ModelResolvedDependencies,
+    )
     from omnibase_infra.nodes.node_contract_persistence_effect.node import (
         NodeContractPersistenceEffect,
     )
@@ -62,7 +66,10 @@ class RegistryInfraContractPersistenceEffect:
     """
 
     @staticmethod
-    def create(container: ModelONEXContainer) -> NodeContractPersistenceEffect:
+    def create(
+        container: ModelONEXContainer,
+        dependencies: ModelResolvedDependencies | None = None,
+    ) -> NodeContractPersistenceEffect:
         """Create a NodeContractPersistenceEffect instance with resolved dependencies.
 
         Factory method that creates a fully configured NodeContractPersistenceEffect
@@ -73,6 +80,10 @@ def create(container: ModelONEXContainer) -> NodeContractPersistenceEffect:
                 following protocols registered:
                 - ProtocolPostgresAdapter: PostgreSQL database operations
                 - ProtocolCircuitBreakerAware: Backend circuit breaker protection
+            dependencies: Optional pre-resolved protocol dependencies from
+                ContractDependencyResolver. If provided, the node uses these
+                instead of resolving from container. Part of OMN-1732 runtime
+                dependency injection.
 
         Returns:
             Configured NodeContractPersistenceEffect instance ready for operation.
@@ -84,14 +95,22 @@ def create(container: ModelONEXContainer) -> NodeContractPersistenceEffect:
             >>> container = ModelONEXContainer()
             >>> container.register(ProtocolPostgresAdapter, postgres_adapter)
             >>> effect = RegistryInfraContractPersistenceEffect.create(container)
+            >>>
+            >>> # With pre-resolved dependencies (OMN-1732)
+            >>> resolved = resolver.resolve(contract)
+            >>> effect = RegistryInfraContractPersistenceEffect.create(
+            ...     container, dependencies=resolved
+            ... )
 
         .. versionadded:: 0.5.0
+        .. versionchanged:: 0.6.0
+            Added optional ``dependencies`` parameter for constructor injection (OMN-1732).
         """
         from omnibase_infra.nodes.node_contract_persistence_effect.node import (
             NodeContractPersistenceEffect,
         )
 
-        return NodeContractPersistenceEffect(container)
+        return NodeContractPersistenceEffect(container, dependencies=dependencies)
 
     @staticmethod
     def get_required_protocols() -> list[str]:
@@ -100,6 +119,11 @@ def get_required_protocols() -> list[str]:
         Returns the protocol class names that must be registered in the
         container before creating a NodeContractPersistenceEffect instance.
 
+        .. deprecated:: 0.6.0
+            Use contract.yaml dependencies field instead. This method will be
+            removed in a future version. The contract is now the single source
+            of truth for protocol requirements (OMN-1732).
+
         Returns:
             List of protocol class names required for node operation.
 
@@ -111,6 +135,13 @@ def get_required_protocols() -> list[str]:
 
         .. versionadded:: 0.5.0
         """
+        warnings.warn(
+            "get_required_protocols() is deprecated. Use contract.yaml dependencies "
+            "field instead. The contract is the single source of truth for protocol "
+            "requirements (OMN-1732).",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         return [
             "ProtocolPostgresAdapter",
             "ProtocolCircuitBreakerAware",

src/omnibase_infra/runtime/__init__.py

@@ -282,6 +282,11 @@
     get_baseline_topics,
 )
 
+# Contract dependency resolver (OMN-1732)
+from omnibase_infra.runtime.contract_dependency_resolver import (
+    ContractDependencyResolver,
+)
+
 # Chain-aware dispatch (OMN-951) - must be imported LAST to avoid circular import
 from omnibase_infra.runtime.chain_aware_dispatch import (
     ChainAwareDispatcher,
@@ -458,4 +463,6 @@
     "BASELINE_CONTRACT_TOPICS",
     "BASELINE_PLATFORM_TOPICS",
     "get_baseline_topics",
+    # Contract dependency resolver (OMN-1732)
+    "ContractDependencyResolver",
 ]