omnibase_infra 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

omnibase_infra/runtime/protocol_lifecycle_executor.py

@@ -49,7 +49,7 @@ from omnibase_infra.runtime.models import (
 )
 
 if TYPE_CHECKING:
-    from omnibase_spi.protocols.handlers.protocol_handler import ProtocolHandler
+    from omnibase_infra.protocols import ProtocolContainerAware
 
 logger = logging.getLogger(__name__)
 
@@ -172,7 +172,7 @@ class ProtocolLifecycleExecutor:
         return self._health_check_timeout_seconds
 
     @staticmethod
-    def get_shutdown_priority(handler: ProtocolHandler) -> int:
+    def get_shutdown_priority(handler: ProtocolContainerAware) -> int:
         """Get shutdown priority for a handler.
 
         Returns the shutdown priority for the given handler. Handlers with higher
@@ -225,7 +225,7 @@ class ProtocolLifecycleExecutor:
     async def shutdown_handler(
         self,
         handler_type: str,
-        handler: ProtocolHandler,
+        handler: ProtocolContainerAware,
     ) -> ModelLifecycleResult:
         """Shutdown a single handler with error handling.
 
@@ -267,7 +267,7 @@ class ProtocolLifecycleExecutor:
     async def check_handler_health(
         self,
         handler_type: str,
-        handler: ProtocolHandler,
+        handler: ProtocolContainerAware,
         timeout_seconds: float = -1.0,
     ) -> ModelHealthCheckResult:
         """Check health of a single handler with timeout.
@@ -329,7 +329,7 @@ class ProtocolLifecycleExecutor:
 
     async def shutdown_handlers_by_priority(
         self,
-        handlers: dict[str, ProtocolHandler],
+        handlers: dict[str, ProtocolContainerAware],
     ) -> ModelBatchLifecycleResult:
         """Shutdown all handlers grouped by priority (higher first, parallel within group).
 
@@ -359,7 +359,7 @@ class ProtocolLifecycleExecutor:
             return ModelBatchLifecycleResult.empty()
 
         # Group handlers by priority
-        priority_groups: dict[int, list[tuple[str, ProtocolHandler]]] = {}
+        priority_groups: dict[int, list[tuple[str, ProtocolContainerAware]]] = {}
         for handler_type, handler in handlers.items():
             priority = self.get_shutdown_priority(handler)
             if priority not in priority_groups:

omnibase_infra/runtime/protocols/__init__.py

@@ -10,18 +10,28 @@ Available Protocols:
         The scheduler is the single source of truth for 'now' across orchestrators.
         It emits RuntimeTick events at configured intervals.
 
+    ProtocolTransitionNotificationPublisher: Interface for transition notification
+        publishing. Used by TransitionNotificationOutbox for delivering state
+        transition notifications to event buses.
+
 Related:
     - OMN-953: RuntimeTick scheduler implementation
+    - OMN-1139: TransitionNotificationOutbox implementation
     - See also: runtime.dispatcher_registry.ProtocolMessageDispatcher
     - See also: runtime.protocol_policy.ProtocolPolicy
 """
 
 from __future__ import annotations
 
+# Re-export from omnibase_core for convenience
+from omnibase_core.protocols.notifications import (
+    ProtocolTransitionNotificationPublisher,
+)
 from omnibase_infra.runtime.protocols.protocol_runtime_scheduler import (
     ProtocolRuntimeScheduler,
 )
 
 __all__: list[str] = [
     "ProtocolRuntimeScheduler",
+    "ProtocolTransitionNotificationPublisher",
 ]

omnibase_infra/runtime/registry/registry_protocol_binding.py

@@ -3,13 +3,13 @@
 """Protocol Binding Registry - SINGLE SOURCE OF TRUTH for handler registration.
 
 This module provides the RegistryProtocolBinding class which implements the
-ProtocolHandlerRegistry protocol from omnibase_spi. It serves as the
+ProtocolContainerAwareRegistry protocol from omnibase_spi. It serves as the
 centralized location for registering and resolving protocol handlers
 in the omnibase_infra layer.
 
 The registry is responsible for:
-- Registering protocol handlers by protocol type identifier
-- Resolving handler classes for protocol types
+- Registering infrastructure handlers by protocol type identifier
+- Resolving handler classes for protocol types (requires ProtocolContainerAware)
 - Thread-safe registration operations
 - Listing all registered protocol types
 
@@ -65,12 +65,12 @@ from __future__ import annotations
 
 import threading
 import warnings
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, cast
 
 from omnibase_infra.errors import ModelInfraErrorContext, RuntimeHostError
 
 if TYPE_CHECKING:
-    from omnibase_spi.protocols.handlers.protocol_handler import ProtocolHandler
+    from omnibase_infra.protocols import ProtocolContainerAware
 
 
 # =============================================================================
@@ -115,10 +115,11 @@ class RegistryError(RuntimeHostError):
         if protocol_type is not None:
             extra_context["protocol_type"] = protocol_type
 
+        # NOTE: Cast required for mypy - **dict[str, object] doesn't satisfy **context: Any
         super().__init__(
             message=message,
             context=context,
-            **extra_context,
+            **cast("dict[str, Any]", extra_context),
         )
 
 
@@ -130,11 +131,11 @@ class RegistryError(RuntimeHostError):
 class RegistryProtocolBinding:
     """SINGLE SOURCE OF TRUTH for handler registration in omnibase_infra.
 
-    Thread-safe registry for protocol handlers. Implements ProtocolHandlerRegistry
+    Thread-safe registry for protocol handlers. Implements ProtocolContainerAwareRegistry
     protocol from omnibase_spi.
 
     The registry maintains a mapping from protocol type identifiers (strings like
-    "http", "db", "kafka") to handler classes that implement the ProtocolHandler
+    "http", "db", "kafka") to handler classes that implement the ProtocolContainerAware
     protocol.
 
     TODO(OMN-40): Migrate handler signature from tuple[str, str] to structured model.
@@ -162,13 +163,13 @@ class RegistryProtocolBinding:
 
     def __init__(self) -> None:
         """Initialize an empty handler registry with thread lock."""
-        self._registry: dict[str, type[ProtocolHandler]] = {}
+        self._registry: dict[str, type[ProtocolContainerAware]] = {}
         self._lock: threading.Lock = threading.Lock()
 
     def register(
         self,
         protocol_type: str,
-        handler_cls: type[ProtocolHandler],
+        handler_cls: type[ProtocolContainerAware],
     ) -> None:
         """Register a protocol handler.
 
@@ -218,10 +219,10 @@ class RegistryProtocolBinding:
         Args:
             protocol_type: Protocol type identifier (e.g., 'http', 'db', 'kafka').
                           Should be one of the HANDLER_TYPE_* constants.
-            handler_cls: Handler class implementing the ProtocolHandler protocol.
+            handler_cls: Handler class implementing the ProtocolContainerAware protocol.
 
         Raises:
-            RegistryError: If handler_cls does not implement the ProtocolHandler protocol
+            RegistryError: If handler_cls does not implement the ProtocolContainerAware protocol
                           (missing or non-callable execute()/handle() method).
 
         Example:
@@ -229,7 +230,7 @@ class RegistryProtocolBinding:
             >>> registry.register(HANDLER_TYPE_HTTP, HttpHandler)
             >>> registry.register(HANDLER_TYPE_DATABASE, PostgresHandler)
         """
-        # Runtime type validation: Ensure handler_cls implements ProtocolHandler protocol
+        # Runtime type validation: Ensure handler_cls implements ProtocolContainerAware protocol
         # Check if execute() or handle() method exists and is callable
         # Following RegistryEventBusBinding pattern of supporting alternative methods
         has_execute = hasattr(handler_cls, "execute")
@@ -239,7 +240,7 @@ class RegistryProtocolBinding:
             raise RegistryError(
                 f"Handler class {handler_cls.__name__!r} for protocol type "
                 f"{protocol_type!r} is missing 'execute()' or 'handle()' method "
-                f"from ProtocolHandler protocol",
+                f"from ProtocolContainerAware protocol",
                 protocol_type=protocol_type,
                 context=ModelInfraErrorContext.with_correlation(
                     operation="register",
@@ -278,7 +279,7 @@ class RegistryProtocolBinding:
     def get(
         self,
         protocol_type: str,
-    ) -> type[ProtocolHandler]:
+    ) -> type[ProtocolContainerAware]:
         """Get handler class for protocol type.
 
         Resolves the handler class registered for the given protocol type.